# Agent tools

> Talos next

134 pages.

| Name | Summary |
|---|---|
| activity | Who else works on this project: the roster (agents and the human, what each is doing), holds (a human's always wins), changes since a cursor, and yours. |
| asset.derived | Every project file derived from one scan source (its SHA-256 or an 8+ hex prefix): cooked GLBs, kept source, byte-identical copies in .argus, the project thumbnail if it may show the scan. |
| asset.import | [editor or disk] Measure a GLB or FBX (Blender converts it), copy it into the project with an entity in the open scene: a workspace-service revision, else an editor undo step, else written to the files. |
| asset.place | [editor or disk] Put a project model into the open scene at the origin, one revision (or undo step): the Content browser's Place, no re-import. |
| asset.reprocess | Re-cook a scan asset from its kept source with changed scan settings (triangles, levels, texture size, hulls, cuts hiding scan triangles where a modelled part sits), one undo step. |
| asset.ruler | Set an imported model's unit scale from two points on it (file space) and their real distance in metres, one undo step. |
| audio.synth | [editor or disk] Synthesise a WAV audio asset into the project (as asset.import does) with the make-your-own-sounds recipe's synthesiser: a preset, or voices on a timeline. |
| behaviour.list | This project's behaviour modules, with what each says it does. |
| behaviour.read | One project behaviour's source, by name or module name. |
| behaviour.write | [editor or disk] Write a TypeScript behaviour to scenes/behaviors/<name>.ts beside the scene, landed only if the build's type checker passes it; else NOTHING is written and the answer has the diagnostics. |
| bridge.generate | [editor or disk] Stone bridge between two points: arches, parapets, end towers. |
| build.apply | Turn files changed outside the workspace API (a save is one) into a revision; wait until its build is Ready (and in the editor) or failed (build.state). |
| build.status | [editor or service] What the workspace service made of the newest revision: editing, building, checking, ready, failed (first error's file and line) or superseded; the last Ready build (exports compose from it); pendingExternal: files in no revision yet, for build.apply. |
| building.generate | [editor or disk] One building of kit pieces, metres. |
| building.kit | Read a kit folder, or with none the engine's own (styles, roles, unit); later calls reuse it. |
| critic.check | Deterministic checks of the scene FILE (save editor edits first): unreachable goals, dangling script modules, geometry that cannot be stood on, budgets. |
| critic.check_ui | UI critic over every screen on the stack across themes, UI scales and locales: text overflow, off-screen or overlapping controls, contrast, unreachable focus, missing strings, no way back, undefined theme tokens. |
| critic.play | The playtester walks each goal entity in order with the real controller: per goal reached, stuck, fell-out, softlock, navmesh coverage. |
| critic.selftest | Play scripted scenarios headless (argus://docs/agent#self-test-scenarios): press, hold actions, wait for a screen, text or goals. |
| dress | [editor or disk] Place kit objects by rule on the terrain: in polygons, along paths, around points; targets may name network or parcels ids. |
| editor.capture | A PNG of the viewport (the game while playing), to a file, shown unless image is false. |
| editor.click | Press a control by drawn name: cursor move, press, release over three frames, as a person does. |
| editor.controls | Every control the editor drew last frame, by name, with its rectangle: the names editor.click takes. |
| editor.hover | Rest the pointer on a control for some frames, which opens a submenu. |
| editor.key | A key down and up, or one half with "down". |
| editor.set | Set the selection and the hidden, isolated (only these drawn) and locked id lists, as the Outliner does. |
| editor.start | [disk (starts an editor)] Start an editor on this project and wait for its control endpoint and first build ([editor], build.*, play.*, ui.* tools): the fix for a no-editor refusal. |
| editor.state | [editor or disk] What a person set by hand outside the scene: selection, hidden, isolated, locked ids, camera, prefs; unsaved files, autosave, crash-recovery offers, undo history. |
| editor.type | Type text a character at a time, through the keyboard's boundary. |
| entity.add | [editor or disk] A new entity in the scene, as one undo step. |
| entity.add_behaviour | [editor or disk] Attach a behaviour: a script component with module and props, one undo step. |
| entity.align | Move an entity so points on it land on matching points elsewhere (a modelled part onto a scan): world-space pairs, 3+; rigid, or with one uniform scale. |
| entity.copy | [editor or disk] Entities and descendants as Ctrl+C's clipboard JSON {argusEntities, assets}. |
| entity.fit_proxies | Fit static collision boxes to a mesh entity (a room scan): the floor, up to `walls` walls, a box around the mesh in each world-space region [min, max]. |
| entity.paste | [editor or disk] Add a clip (entity.copy's answer or its clip, or copied text) with fresh ids where it was copied; one undo step. |
| entity.reparent | [editor or disk] Reparent (null: root), keeping world transform unless keepWorld=false; one undo step. |
| entity.set_component | [editor or disk] Put this component on this entity, replacing any of its type, one undo step. |
| example.behaviour | The smallest compiling behaviour module doing what you describe, from tested fixtures: door, collect, rotate, move, trigger, timer, hud, camera, input, nav. |
| explain.api | One @argus/api symbol or @argus/gameplay helper: its declaration, doc, import line and the examples that use it. |
| explain.component | A component kind's fields (type, default, values), nested types, rules refusing it, a valid fragment. |
| explain.rule | What a refusal's or finding's code means: severity, trigger, where it points, whether a check offers a fix patch. |
| explain.search | Find what the explain tools and argus:// resources hold, by words: rule and runtime codes, components, API, examples, recipes, docs, UI. |
| export.compose | [disk (with a Ready build)] Compose the player's native executable from a Ready build (build.status names it). |
| export.info | A composed executable's payload: scene, engine, source revision, branding, as the launcher's --info prints. |
| export.run | [disk (starts the game, no window)] Start a composed executable offscreen as a player would; answers its screen stack, a first-frame PNG (unless image: false) and a development export's query URL (a release export has none: it runs its self-test once). |
| foliage.generate | Write or edit a .foliage.json from recipe or template and cook it into .argus/flora/. |
| foliage.preset | Plant a scene's terrain over an area with a plant preset as instancedMesh entities; a re-run replaces it. |
| foliage.preview | A PNG contact sheet drawn on the CPU: a row per variant and age, a column per view. |
| foliage.species | Species and templates, scored first. |
| foliage.stats | Triangles per submesh, bounds, collider, cook ms, and whether the baked meshes are fresh. |
| kit.check | What a kit can build (houses by roof, wall, fence, bridge) and the roles each still needs; pieces that do not sit in their cell, in metres; a test house pictured. |
| kit.piece | Declare kit pieces from models (the kit file is made on the first call): yaw, offset, scale and size are fitted from each model's bounds and outer side. |
| kit.sheet | What a folder of models holds, 12 a page, pictured with each origin and axes: size, bounds, material names, and the materials a scene puts on each. |
| library.gate | Gate a GLB the user already has and save it. |
| library.generate | Answers library candidates first (no provider call): accept:"<id>" takes one; accept:"none" or force:true generates. |
| library.import | Copy a gated asset into the project (failed-gate ones are refused); then asset.place. |
| library.process | Paid Tripo step on a GLB path or taskId: smart_uv, auto_rig (preset, default mixamo), retopo (faceLimit). |
| library.search | Search saved, gated assets before generating; then library.import. |
| library.share | publish: per asset, gate-passed, attest:true, licence CC0-1.0 default; a service's assets need policy clearance, then tier and consent:true. |
| look.apply | Put a named look (sky, ambient, render look; e.g. |
| material.compare | Draw a material headless on a 4 m panel under key, backlit or dusk light (or take an image) and compare with a reference picture: colour difference, brightness/contrast/highlight/detail ratios, hints. |
| material.measure | Mean linear albedo, roughness, metallic, emission in nits, checked against a class (grass, rock, plaster, brick, clay-tile, timber, stone, cobble, iron...). |
| material.preview | Draw a material on a shape: contact sheet PNG (4 angles x 3 rigs). |
| material.write | Check a *.material.json, then save it. |
| music.add | [editor or disk] A paid song on the user's key (music must be on), or with file their Suno download (free), as an audio asset; scene loops it there. |
| network.grow | [editor or disk] Grow a street network from seeds over the terrain (metres, XZ): a carved road per edge; answers blocks for parcels.subdivide. |
| notes.append | Record one thing about THIS project for the next session: a decision, a name, what failed, what a refusal meant. |
| notes.read | What earlier sessions recorded about this project. |
| parcels.subdivide | [editor or disk] Split a network's blocks (or polygons) into plots and fit kit archetype buildings on the terrain. |
| play.capture | Render a frame of the running game, overlays optional (colliders, navmesh, paths), to out or a temp file, shown to you (max 1024 px) unless image is false; a clip is one sheet of up to 12 numbered frames. |
| play.desync | Where two runs part: on {every} hashes each sim system per tick; compare {ticks} (another run's read with leaves) names the first tick, system and entity; dump {system, entity} the state. |
| play.input | Press input-map actions through their bound keys, as the player's keyboard does. |
| play.measure | Step Play tick by tick with actions held over chosen ticks, reading entity fields after each: per field first, final, min and max with the tick; the first tick each condition held; rows on request. |
| play.query | One request to Play's query API: /entities, /entity/{id}, /contacts, /perf, /events, /trace, /frame, /navmesh, /feel, POST /raycast, POST /path; shapes in argus://docs/query-api. |
| play.roads | Each road entity's centre line in WORLD space: samples {s, pos, tangent, halfWidth, curvature, bankRad}, length, closed, gates in lap order. |
| play.save | Read or change the running game's ctx.save store: set {key: value}, remove [keys]; answers the store after. |
| play.start | Play the open scene in the editor; waits until it runs. |
| play.step | Pause Play and advance exactly this many fixed ticks, to reason about a frame rather than watch it. |
| play.stop | End Play; back to authoring, scene and camera as they were. |
| plugin | [service, or disk] Plugins (argus://docs/plugins): list; info, tools {id}; add {id, set: ["k=v"], dryRun}; remove {id}; run {id: a tool's name, args}. |
| prefab | [editor or disk] create {entity, path}: subtree -> prefab file + instance. |
| prefab.place | [editor or disk] Many prefab instances as ONE undo step and revision. |
| profile.blame | Cost by script behaviour, phase, entity, draw group, physics, asset memory or load phase. |
| profile.capture | save the flight recorder's last seconds (action save, reason), list, read one, or export a Perfetto trace (redact hashes script and scene names). |
| profile.diff | Replay a saved capture's run on the edited project (or compare with another capture or the live ring): per-span deltas with a noise band, a verdict per finding. |
| profile.explain | What the running game is bound by, with ranked fixes, each with evidence, a suggested change and estimated saving. |
| profile.view | Profile picture by kind: strip (frame times, spikes marked), timeline (one frame's spans by track), flame (where time went), heat (viewport, costly entities tinted, legend). |
| project.create | Make a project from a template and take it as this session's: argus.project.json and scenes/main.scene.json only, no editor or service. |
| project.files | Every file a revision of this project would hold, with role (scene, behavior, asset, data, settings) and size, 100 a page; prefix and role narrow it. |
| project.open | Take this project as the session's, which every other tool works on; reports its editor, workspace service, scenes and startup scene. |
| project.settings.set | Field edits three-way merged onto the manifest into a revision by the workspace service (needs it running): each {field, expect: the value last seen, value}; a field changed since is a conflict, never overwritten. |
| replay.verify | Play a --save-replay file on its scene and check its per-system state hashes: ok, or the first tick window and system where the playback parts from the recording. |
| revert | Undo one of your changes as a new revert change. |
| road.edit | Set or remove .road.json fields by dotted path (null removes), e.g. |
| road.sample | Points ON a road's surface from its file, no Play: each [s, offset] (metres along, metres right) gives WORLD position, normal, bankDeg, strip and a rotation standing a prop flush on it, facing along the road. |
| scene.list | Every scene in the project, the open one, and the one a packaged build boots. |
| scene.open | [editor or disk] Make this the open scene: the editor's Open scene (an unsaved-work prompt may appear; the answer says so), or with no editor the scene later tools use. |
| scene.patch | [editor or disk] An RFC 6902 JSON Patch on the scene, ONE undo step, all or nothing; an invalid result is refused with its contract violations. |
| scene.read | [editor or disk] The scene as canonical JSON (argus://contract/scene): the workspace service's when one runs (an open editor's unsaved edits only once saved: dirty says they exist), else the editor's document (unsaved edits too), else the file. |
| settlement.generate | [editor or disk] A settlement from a recipe (inline or a .settlement.json): network.grow, parcels.subdivide, dress in turn under <id>-net/-plots/-dress. |
| shader.library | What a shader may use: models, functions (the prelude), glsl (a cheat sheet), examples (six shaders). |
| shader.measure | Static cost, caps met (desktop, web, hd: uncalibrated), derived metadata (usesDerivatives, usesScreenInputs), what HD would downgrade, hd (passes, pipelines, ray-hit handling, codes), variants, pre-warm estimate. |
| shader.preview | Material contact sheet PNG: 4 angles x 3 times x day/backlit/night. |
| shader.write | [editor or disk] Check a *.shader.wgsl, then save it: errors come back as {code, line, col, message, hint}, nothing written. |
| terrain.apply | [editor or disk] Add ops as ONE change, a whole recipe a call; later ops read earlier ones. |
| terrain.create | [editor or disk] A terrain file, empty or a landform (terrain.ops lists them), with entity also its scene entity, as one change; a layer material the project lacks is written plain. |
| terrain.edit | [editor or disk] Change one op (set, enabled) or the surface; answers as terrain.apply. |
| terrain.ops | Stack ops; op: <name> gives fields, defaults, reach, a runnable example. |
| terrain.preview | A PNG and legend of the terrain; upTo an op id; grid draws coordinates. |
| terrain.sample | Height, normal, slope, layer and channels at points, in metres. |
| terrain.stack | [editor or disk] The stack with each op's cost, layers, channels. |
| terrain.stats | Heights, land and sea, bands, slopes, walkable %, layers, look. |
| tools.enable | Add toolsets to this session's list. |
| ui.activate | [editor (test session)] Press a node by its ui.tree id, as a click would. |
| ui.focus | [editor (test session)] Focus a node by id, or move focus one step up, down, left or right: test gamepad and keyboard navigation without either. |
| ui.input | [editor (test session)] Pointer, key and navigation events straight into the UI, in the logical pixels of ui.tree's bounds.logical (a node's centre needs no arithmetic). |
| ui.locale | Switch the language text keys resolve in, for a screenshot matrix. |
| ui.pop | [editor (test session)] Pop the top screen, as ctx.ui.pop and the player's Escape do. |
| ui.push | [editor (test session)] Push a registered screen (ui.screens lists them) with optional props, as ctx.ui.push does, to look at it without a behaviour. |
| ui.scale | Set the player's UI-scale multiplier, 0.5 to 4, for a screenshot matrix. |
| ui.schema | [editor or disk] Every style property, unit, selector, pseudo-class, role, design token, binding and refusal code the UI supports, from the parser's tables. |
| ui.screens | [editor or disk] The stack bottom-first with each screen's modality, dismissibility, click-through, input context, focus and props; every registered screen; the live input context; the UI scale. |
| ui.theme | Switch the UI to a theme the project's stylesheets declare, for a screenshot matrix. |
| ui.tree | The live UI tree across the screen stack: per node its stable id (the one to press), role, classes, bounds (logical and device px), state, text with string key, computed style. |
| ui.viewport | Size the engine's surface in device pixels, 64 to 8192 a side, and lay the UI out at it: a screenshot matrix's resolution axis, on one engine. |
| vfx.describe | Every setting of a *.vfx.json: unit, range, default and what it does to the look. |
| vfx.explain | Plain reasons from the measurements, each with a fix: nothing alive and why, a short pool, no lift, too faint, under a pixel. |
| vfx.patch | RFC 6902 ops on a project *.vfx.json, all or nothing; emitters by name (/emitters/@smoke/init/life). |
| vfx.read | An effect file as written, or a preset's source to copy from; a preset is read-only. |
| vfx.report | What an effect does, measured with no GPU: live against capacity, dropped spawns, rise and spread, pixel width at distances, lints. |
| vfx.sheet | Draws an effect on a fixed stage at set moments and distances into one labelled PNG, with an optional param sweep. |
| view.render | Offscreen PNG of the scene from eye to target, shown to you. |
| wall.generate | [editor or disk] Town wall (towers, gates) or fence along a path, metres, on terrain. |

### project.settings.get 

*Since next*

[service, or disk read-only] The manifest's editable fields and values via the workspace service; without one, the file as read, read-only (only the service makes writes revisions).

| | |
|---|---|
| Title | Read project settings |
| Mode |  |
| Token cost | about 85 tokens (listed only when its toolset is enabled) |
| Toolset | `release` |

#### Arguments

None.

#### Example

An MCP `tools/call` with the required arguments (placeholders in angle brackets).

```json
{
  "name": "project.settings.get",
  "arguments": {}
}
```