Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

With no annotations, the description carries the full burden. It describes the output visualization (grey/blue/red, IoU and edge-error bands 'placed exactly, no rescaling') and the checks performed, which conveys non-destructive intent implicitly. It does not explicitly state whether the tool modifies anything or describe the return format, leaving some behavioral ambiguity.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Is the description appropriately sized, front-loaded, and free of redundancy?

The description is a single dense paragraph but packs a lot of information efficiently. It leads with the core purpose, then details the checks in a structured list-like format using semicolons. No filler words; every clause adds value. It is concise for the content it conveys.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

The tool is fairly complex with multiple verification aspects, yet the description omits parameter semantics and output structure. It explains what is checked but not how to call it or interpret the full result. An agent would struggle to invoke it correctly without schema descriptions (which are absent).

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

Schema description coverage is 0%, so the description must explain the parameters. It never mentions 'name' (likely the model/plan identifier) or 'resolution' (default 160). The agent receives no guidance on what values to supply or how they affect the check. This is a critical gap.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Does the description clearly state what the tool does and how it differs from similar tools?

The description clearly states the tool's purpose: 'Check the model against its plan' and enumerates the specific checks (silhouette, IoU, edge-error, landmarks, sections). This distinguishes it from siblings like 'compare' or 'measure' through the explicit plan-checking scope. It lacks a direct contrast to sibling tools but is specific enough.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Does the description explain when to use this tool, when not to, or what alternatives exist?

It provides explicit timing guidance: 'Run it after every stage.' This tells the agent when to use it. However, it does not mention when not to use it or name alternatives, so it lacks exclusions. Still, the directive is clear and actionable.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

With no annotations, the description carries the full burden of behavioral disclosure. It transparently describes the output artifacts (IoU, diff image with color meanings, band tables), explains how 'fit' handles scale and offset (ignoring absolute size in auto mode), and clarifies how 'against' selects references or plan. It stops short of mentioning side effects, but for a read-oriented comparison tool this is a minor gap.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Is the description appropriately sized, front-loaded, and free of redundancy?

The description is dense yet organized: it starts with the core purpose, then enumerates outputs, then defines the two key parameters. Every sentence contributes information without fluff. It is a little long but remains efficient and logically structured.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

Given the absence of annotations and output schema, the description provides substantial detail about comparison semantics and output, but it omits clarification for 'views' and 'resolution'. These have defaults, so a basic call may be possible, but advanced usage would require inferring their meaning. The tool is moderately complex, and the description is only partially complete.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

Schema description coverage is 0%, so the description must compensate. It adds rich meaning for two parameters ('fit' with values auto/height/width, 'against' with refs/plan/auto) and their behavior, but it leaves 'name', 'views', and 'resolution' unexplained. The description adds value for key parameters but is incomplete for the others.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Does the description clearly state what the tool does and how it differs from similar tools?

The description uses a specific verb ('compare') and resource ('model silhouettes') and clarifies the reference target. It details the per-view outputs (IoU, diff image, band tables) so an agent understands exactly what the tool produces, distinguishing it from measurement or editing tools.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Does the description explain when to use this tool, when not to, or what alternatives exist?

The description explains the semantics of the 'fit' and 'against' parameters, giving context on when to use specific values, but it does not explicitly compare this tool to siblings like 'check' or 'measure' or state when to choose one over another. Usage is implied but not contrasted with alternatives.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

With no annotations, the description carries the full burden and does so thoroughly: atomicity, merge/create semantics, null-field removal, delete/rename/move/scale behaviors, reference updates on rename, and automatic .R propagation are all disclosed.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Is the description appropriately sized, front-loaded, and free of redundancy?

The definition is dense but compact: a one-line summary, then a terse op list where each line adds a distinct semantic. There is no filler and the most important framing (atomic batch) is front-loaded.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

The op vocabulary is exceptionally complete for a tool with no output schema and no annotations. The main gaps are the unaddressed top-level name/note parameters and lack of any statement about return values or error behavior, but the core invocation semantics are well covered.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

The description richly documents the nested ops structure, which is critical given the schema's 0% description coverage. However, it never explicitly ties the top-level 'name' parameter to the model being edited, nor explains 'note'; the op-level 'name' field could be confused with it.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Does the description clearly state what the tool does and how it differs from similar tools?

The description opens with a specific verb and resource: 'Apply a batch of edits atomically.' It then enumerates the exact edit operations, making it clear this is the batch mutation tool for models and distinguishing it from read/list/export siblings.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Does the description explain when to use this tool, when not to, or what alternatives exist?

It clearly frames when to use the tool (batch edits that should be atomic) and adds the concrete constraint 'Edit only .L and centre elements; .R follows automatically.' However, it does not explicitly name alternative tools or say when not to use it.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

Since no annotations are provided, the description must fully disclose behavior. It mentions resolution and OBJ format, and gives a Blender import example with axis configuration, which is valuable. However, it does not disclose whether the export overwrites files, requires authentication, or what happens if the path is invalid. For a tool with no annotations, this is a moderate disclosure – it covers the key technical detail but misses side effects and error behavior.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Is the description appropriately sized, front-loaded, and free of redundancy?

The description is concise, two sentences, and front-loads the core purpose. The Blender import example is a practical addition that earns its place. No wasted words.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

The tool has three parameters, no output schema, and no annotations, so the description must carry full weight. It lacks parameter explanations, error handling, and prerequisites (e.g., does the model need to be built first?). The example is helpful but does not compensate for the missing parameter details and safety implications. The absence of annotations and output schema makes this description insufficient for reliable tool use.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

Schema description coverage is 0%, so the description must explain all parameters. It does not mention 'name' or 'path' at all, and only implicitly mentions 'resolution' via 'at the given resolution'. The description fails to clarify what 'name' and 'path' refer to (e.g., the model name, the file path), leaving the agent to guess. This is a significant gap for a tool with three parameters.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Does the description clearly state what the tool does and how it differs from similar tools?

The description clearly states the action (export/build to OBJ) and the resource (the model being built), and mentions the coordinate system (Z up, metres) which adds precision. However, it does not explicitly differentiate from siblings like 'put_model' or 'get_model', though 'export' is a distinct concept. It could be clearer about what exactly is exported (e.g., the current model in the scene).

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Does the description explain when to use this tool, when not to, or what alternatives exist?

The description implies use for exporting to OBJ for Blender import, but does not explicitly state when to use this tool versus alternatives like 'put_model' (which might be for uploading) or 'get_model' (which might be for downloading). It gives a concrete usage example for Blender import, which helps, but lacks explicit when/when-not guidance or comparison to alternatives.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

With no annotations, the description carries the full burden and meets it: it discloses the side effect of saving a new version, the limited view-based scope, what stays fixed, how max_step and stiffness affect behavior, the return payload (diff images, IoU before/after, every change), and revert support. There is no annotation contradiction.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Is the description appropriately sized, front-loaded, and free of redundancy?

The description is dense but every clause earns its place. It front-loads the core action, then packs operational details about scope, locking, parameters, constraints, and return values without fluff or repetition.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

For an 11-parameter tool with no annotations and no output schema, the description is unusually complete: it covers preconditions, parameter effects, scope, outputs, and undo. The only notable gap is the unexplained align parameter, but an agent could still use most advanced functionality safely.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

Schema coverage is 0%, so the description compensates well: it explains allowed params values (pos, r, offset, size), only/lock name syntax, max_step units, stiffness as a spring toward starting values, and the against options. However, the align parameter is not explained, and name/iterations/resolution are only inferable from their titles.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Does the description clearly state what the tool does and how it differs from similar tools?

The description opens with a concrete verb-resource-result: 'Auto-fit the model to its reference silhouettes and save the result as a new version.' It then specifies exactly what moves (joints, radii, blob offsets, blob sizes), making it clearly distinct from sibling tools like measure, compare, or check.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Does the description explain when to use this tool, when not to, or what alternatives exist?

Gives actionable guidance such as 'Block out the body plan by hand first: fitting is local and can't fix a missing or misplaced limb' and explains the against options (refs, plan, auto). It does not explicitly name alternative sibling tools or state when not to use this tool, so it stops short of full routing guidance.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

With no annotations, the description carries the burden. It communicates that the call returns data rather than performing an update, which is useful, but it does not state whether the operation is read-only, whether the measurement summary is stored or recomputed, or what happens for unknown names.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Is the description appropriately sized, front-loaded, and free of redundancy?

One short sentence, front-loaded with the verb and output, and no filler. Every word adds information.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

For a one-parameter getter this is mostly sufficient, and no output schema exists so describing the return shape at a high level helps. It is incomplete as a standalone spec because it omits valid-name sourcing, potential errors, and explicit differentiation from sibling tools.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

Schema coverage is 0%, so the description must compensate. 'a model's stored spec' indicates that 'name' identifies a model, but it does not explain the naming convention or mention using list_models to find valid names. The single obvious 'name' parameter makes the gap minor.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Does the description clearly state what the tool does and how it differs from similar tools?

The description names a specific verb ('Return') and resource ('a model's stored spec'), and identifies the output format (JSON) plus a measurement summary. It is clear for a getter, though it does not explicitly contrast with sibling inspection tools like 'look' or 'check'.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Does the description explain when to use this tool, when not to, or what alternatives exist?

No guidance is given for when to call get_model instead of list_models, look, check, or measure. There are no prerequisites or exclusions, so an agent must infer the intended use from the name alone.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

With no annotations supplied, the description is responsible for disclosing behavioral traits. It merely states the action without mentioning read-only status, output format, potential side effects, authentication requirements, or any other operational details. This is insufficient for a tool the agent might invoke.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Is the description appropriately sized, front-loaded, and free of redundancy?

The description is a single, direct sentence with no extraneous words. It conveys the essential action efficiently, though it could be structured to include more behavioral context without sacrificing conciseness.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

For a simple list operation with one parameter, the description is minimal but incomplete. It does not describe the return format, whether versions are chronological, or any pagination/limiting behavior. Without an output schema, more detail on what the tool returns would be expected.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

The schema provides only a 'name' field with no description, and schema_description_coverage is 0%. The description clarifies that 'name' refers to the model for which versions are listed, which adds meaning beyond the bare schema and partially compensates for the lack of parameter documentation.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Does the description clearly state what the tool does and how it differs from similar tools?

The description states a clear verb ('list') and resource ('saved versions of a model'), making the tool's function immediately understandable. It does not explicitly differentiate from sibling tools like 'list_models', which might list models rather than versions, but the purpose is specific enough to be unambiguous.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Does the description explain when to use this tool, when not to, or what alternatives exist?

No guidance is provided on when to use this tool versus alternatives such as 'list_models', 'get_model', or 'revert'. There are no prerequisites, exclusions, or conditional usage instructions, leaving the agent to infer the appropriate context from the tool name alone.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

No annotations are provided, so the description carries the full burden of behavioral disclosure. It reveals the content domain but does not state that the tool is read-only, what it returns, what side effects it has, or whether it requires any setup. The agent is left to infer behavior from the name 'reference.'

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Is the description appropriately sized, front-loaded, and free of redundancy?

The description is a single, short phrase with no filler and lists concrete categories, which is efficient. However, it is a fragment lacking a main verb, so it is concise but not a complete, well-formed specification.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

For a parameterless reference tool with no annotations and no output schema, the description should clarify what the agent receives and when to use it. It does neither, and it does not distinguish itself from similarly named siblings such as set_reference, making it incomplete for correct invocation.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

The input schema has zero parameters, so there is no parameter-level meaning to add. The description's mention of 'parameters' refers to reference content, not tool inputs; with no parameters, the baseline of 4 is appropriate.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Does the description clearly state what the tool does and how it differs from similar tools?

The description names a concrete subject area (kits, strokes, plans) and specific categories, but it is a noun phrase without a verb. It does not state whether the tool retrieves, lists, or exports this reference data, nor does it differentiate itself from siblings like set_reference or get_model.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Does the description explain when to use this tool, when not to, or what alternatives exist?

No usage conditions or alternatives are given. The phrase 'Parameters and defaults for...' weakly implies this is a lookup source, but the description never says when to call this tool instead of a sibling such as look, set_reference, or set_plan.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

No annotations are provided, so the description carries the full behavioral burden. 'List' reasonably implies a read-only operation with no side effects and a returned collection of models, which is useful. However, it doesn't state ordering, pagination, or what exactly qualifies as 'saved'.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Is the description appropriately sized, front-loaded, and free of redundancy?

A single sentence with no filler, and the action and object are front-loaded. This is appropriately sized for a parameterless list command.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

For a zero-parameter list operation with no output schema, the description covers the core action and implied return value. It would benefit from a brief note on what 'saved models' includes or whether results are sorted/filtered, but the low complexity makes this nearly complete.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

The tool has zero parameters, so the input schema fully documents the call. The description adds no parameter-level information, but none is needed; the baseline for zero-parameter tools applies.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Does the description clearly state what the tool does and how it differs from similar tools?

The description uses a specific verb and resource ('List saved models'), making the operation unambiguous. It is naturally distinct from sibling get_model (singular retrieval) and mutating tools like edit_model or put_model, though it does not explicitly name them.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Does the description explain when to use this tool, when not to, or what alternatives exist?

The phrase 'List saved models' implies a use case: when you need an inventory of saved models. However, it gives no explicit guidance about when to prefer it over get_model or how it relates to the other siblings, so the usage context is only implied.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

With no annotations provided, the description carries full behavioral disclosure and does so thoroughly. It explains close-up cropping behavior (parts outside the focus region are left out), shared scale across panels, grid lines with rulers, hidden-part omission for strokes, and the meaning of shading colors. This far exceeds typical descriptions.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Is the description appropriately sized, front-loaded, and free of redundancy?

The description is long but information-dense; nearly every clause adds value and front-loads the main purpose before parameter details. It could be better structured with formatting like bullets, but no sentence is wasted.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

For a 10-parameter tool with no output schema and no annotations, the description covers the most important behavioral and parameter aspects, including edge cases like close-up resolution behavior. It falls short on matcap/size/name semantics and does not explicitly describe the return format beyond 'clay contact sheet,' but overall it is remarkably complete.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

Schema coverage is 0%, so the description must compensate, and it explains views, focus, zoom, resolution, strokes, grid, and shading in meaningful detail. However, three parameters—name, size, and matcap—are not described at all, including the required name. This leaves noticeable gaps for a 10-parameter tool.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Does the description clearly state what the tool does and how it differs from similar tools?

The description opens with 'Build the mesh and return a clay contact sheet,' a specific verb and resource that clearly identifies this as a rendering/preview tool. It is easily distinguished from siblings like list_models, history, or export, though it does not explicitly name an alternative. The purpose is unmistakable.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Does the description explain when to use this tool, when not to, or what alternatives exist?

The description offers rich context on when to use specific options: strokes=True for checking placement, raking for revealing shallow forms, and curvature for analyzing convexity/concavity. It gives practical guidance (e.g., 'check placement before judging form') but does not explicitly state when to prefer this tool over siblings or include exclusions.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

With no annotations provided, the description carries the full burden of behavioral disclosure. It explains that measurements are independent of build resolution, describes the output semantics (distances on w-/w+ and h-/h+ axes, section area), and clarifies the difference between bone-chain and world-axis modes. It does not mention side effects or permissions, but this appears to be a read-only measurement tool, and the description's detail about what is computed and how is substantial.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Is the description appropriately sized, front-loaded, and free of redundancy?

The description is dense but well-organized, with the two modes clearly separated by 'along =' clauses. It front-loads the core purpose and then details each mode. It is somewhat long, but every sentence adds necessary information about output semantics or usage. The structure is logical and scannable.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

For a measurement tool with no output schema and no annotations, the description is quite complete: it explains what is measured, how the output is structured, and how to select modes. It does not explicitly document the 'name' parameter or provide examples of return values, but the description's detail about section areas and axis ranges gives an agent enough to invoke it correctly. The lack of an output schema is partially compensated by the description's explanation of what the tool returns.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

Schema description coverage is 0%, so the description must compensate for the schema's lack of parameter documentation. It does this well: it explains 'along' can be a bone name/list or 'x'/'y'/'z', describes 'samples' as evenly spaced t, and mentions 'lo' and 'hi' as optional bounds. The 'name' parameter is not explicitly described, but it is clearly the model name from context. The description adds significant meaning beyond the bare schema types.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Does the description clearly state what the tool does and how it differs from similar tools?

The description clearly states the tool measures cross-section sizes as numbers, and distinguishes two modes: along a bone chain or along a world axis. It names the resource (the model) and the specific operation (measure), and the examples ('y' gives body width and height, 'z' shows where legs merge) make the purpose concrete. It is clearly differentiated from siblings like 'look' or 'check' by focusing on quantitative cross-section measurements.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Does the description explain when to use this tool, when not to, or what alternatives exist?

The description explains when to use the tool ('Use it to find pinches, bulges and lumps along a limb') and gives concrete examples of axis modes. It does not explicitly state when not to use it or name alternative tools, but the context is clear enough for an agent to select it for measurement tasks. The two modes are well explained with conditions (bone chain vs world axis, optional lo/hi range).

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

With no annotations, the description carries the full behavioral burden. It discloses the destructive replacement behavior, the defaulting behavior for missing keys, and the return summary. It does not mention permissions or irreversibility, but the core behavioral traits are present.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Is the description appropriately sized, front-loaded, and free of redundancy?

Two short sentences deliver the primary action, the critical defaulting behavior, and the return type. There is no filler, and the main semantic is front-loaded.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

For a three-parameter tool with no output schema, the description covers the essential invocation semantics: create/replace, defaults, and summary return. It is slightly thin on explicit sibling differentiation and spec structure, but an agent can reasonably invoke the tool based on the provided information.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

Schema description coverage is 0%, so the description must compensate. It adds meaningful semantics for the spec parameter ('Missing keys get defaults') and clarifies replace semantics, but it does not explain the shape of spec or add detail for the name and note parameters beyond what is obvious from their names.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Does the description clearly state what the tool does and how it differs from similar tools?

The description uses a specific verb-resource pair ('Create a model or replace its whole spec') and clearly communicates upsert semantics. The phrase 'whole spec' distinguishes it from a partial-update sibling like edit_model.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Does the description explain when to use this tool, when not to, or what alternatives exist?

The description clearly implies when to use this tool: when creating a model or fully replacing its spec, especially since missing keys get defaults. However, it does not explicitly name edit_model or state when not to use this tool, leaving some routing inference to the agent.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

With no annotations, the description carries the full burden of behavioral disclosure. It meaningfully discloses that the operation is non-destructive: it is 'saved as a new version, so nothing is lost.' This directly addresses the most important side effect an agent needs to know. It does not mention permissions, output, or failure modes, but the key safety trait is well covered.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Is the description appropriately sized, front-loaded, and free of redundancy?

The description is a single efficient sentence with a valuable parenthetical. Every part earns its place, and the core behavior is front-loaded.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

Given no annotations, no output schema, and 0% schema description coverage, the description is not complete enough. It explains the main effect but leaves parameter semantics, expected output, and usage context to be inferred. An agent calling revert correctly would likely need additional information about what 'name' and 'version' refer to.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

Schema description coverage is 0%, and the description must compensate but largely does not. It loosely aligns 'earlier version' with the version parameter, but it never explains what name refers to, how version is interpreted, or how the two parameters relate. This is insufficient for a two-parameter tool with no schema descriptions.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Does the description clearly state what the tool does and how it differs from similar tools?

The description names a specific verb and resource: 'Restore an earlier version.' The parenthetical clarifies the operation creates a new version rather than overwriting. It does not explicitly differentiate from sibling tools like history or put_model, but the restores-a-prior-version meaning is clear enough to distinguish it from listing, exporting, or editing.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Does the description explain when to use this tool, when not to, or what alternatives exist?

The description implies the use case: when a user wants to go back to an earlier version. However, it provides no explicit guidance about when to use revert versus history, edit_model, or put_model, and it offers no exclusions or prerequisites.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

With no annotations, the description carries the full burden. It discloses that the operation replaces an existing plan, auto-creates the model if missing, and returns the plan drawn with rulers. It does not discuss permissions, reversibility, or side effects beyond replacement, but the core mutation and return behavior are transparent.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Is the description appropriately sized, front-loaded, and free of redundancy?

The essential action and result are front-loaded, followed by a dense but organized plan specification. The description is long, but the technical detail is necessary for correct invocation and is not filler.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

For a complex nested-object tool with no annotations and no output schema, the description covers creation, replacement, return value, coordinate conventions, and points to kit_reference for further details. Minor gaps are the semantics of 'name'/'note' and explicit error/failure behavior, but overall it is complete enough for an agent to use correctly.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

The input schema provides only a free-form 'plan' object and empty property titles. The description compensates substantially by specifying the full plan grammar: views, shapes, landmarks, sections, axes, mirroring, and subtraction. The 'name' and 'note' parameters are not explicitly explained, but their schema titles are reasonably self-explanatory.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Does the description clearly state what the tool does and how it differs from similar tools?

The description opens with a specific verb and resource: 'Set (or replace) a model's plan', and defines what a plan is ('the 2D blockout you model against'). This clearly distinguishes it from sibling tools like get_model, edit_model, or set_reference.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Does the description explain when to use this tool, when not to, or what alternatives exist?

The description gives clear context: use this tool when setting or replacing a model's plan, and it notes the model is created if it doesn't exist. It also says the returned ruler-drawn plan is for checking proportions before modelling. It does not explicitly contrast with alternatives or state when not to use it, but the intended usage is clear.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

The description discloses important behavioral details: how the silhouette is extracted (alpha channel or background difference with threshold), the orientation convention (side view faces LEFT), and that the tool returns the extracted mask for verification. These are meaningful behavioral traits beyond what annotations would provide, though no annotations are present.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Is the description appropriately sized, front-loaded, and free of redundancy?

Three sentences with no wasted words. The most important information (what it does, how silhouette extraction works, orientation caveat, return value) is packed efficiently. The orientation caveat is front-loaded before the flip parameter explanation.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

For a tool with 5 parameters and no output schema, the description covers the key behavioral aspects: extraction method, orientation, flip, threshold, and return value. It doesn't explain the 'name' parameter or provide examples, but the core usage is well covered.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

Schema description coverage is 0%, so the description must compensate. It explains the meaning of 'view' (front/side/top), 'flip' (for right-facing references), 'threshold' (background difference threshold), and 'image_path' (reference image). The 'name' parameter is not explained, but the description covers most parameters meaningfully.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Does the description clearly state what the tool does and how it differs from similar tools?

The description clearly states the action ('Attach a reference image'), the resource (reference image for a view), and the specific views ('front', 'side', 'top'). It also distinguishes itself from sibling tools by focusing on reference image attachment, which is unique among the listed siblings.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Does the description explain when to use this tool, when not to, or what alternatives exist?

The description provides clear context on when to use this tool: when attaching a reference image for a specific view. It also gives practical guidance about the side view orientation and the flip parameter. However, it doesn't explicitly state when NOT to use it or name alternative tools for similar tasks.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.