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

With no annotations, the description carries full burden and does well: it discloses side effects ('May change scene or write files'), instructs verification ('Verify resulting state'), and clarifies timeout semantics ('A timed-out operation is UNKNOWN: reconcile_operation before any retry'). This goes well beyond a simple 'assigns fabric' statement.

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 compact and front-loaded: purpose first, then legacy parameter warning, then side-effect and timeout guidance. Every sentence adds distinct value with no 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?

It covers purpose, key parameter semantics, side effects, and timeout behavior, but with no output schema and 0% schema coverage, it should also clarify what assign_option expects and what a successful result looks like. The instruction to 'Verify resulting state' is useful but does not say how.

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 face parameter's legacy meaning and says to prefer assign_option, but it does not explain what assign_option values mean or clarify fabric_index/pattern_index beyond their names. This is a partial improvement over an empty schema, but leaves gaps.

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 'Assign and verify,' which states a clear verb and resource, and the face parameter explanation ('colorway option, NOT surface face') adds specificity about what is being assigned. However, it does not explicitly name the object being assigned (e.g., fabric to patterns/colorways) beyond the tool name, and it does not differentiate from siblings beyond that.

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 explicitly tells the agent to prefer assign_option over the legacy face parameter, which is direct usage guidance. It also instructs to call reconcile_operation before any retry after a timeout, providing clear when-not-to-retry and fallback 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 provided, the description carries the full burden. It explicitly discloses non-mutation of the MD scene and 'Read' signals a side-effect-free operation. For a simple zero-parameter read tool, this is sufficient transparency; more detail about output format would elevate it further.

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 extremely concise: one sentence states exactly what is read, and a second sentence states the key safety property. No filler or redundant information is present.

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 simple with no parameters and no output schema. The description names the categories of output (count, names, runtime properties) and its non-mutating nature, which is enough for an agent to select and call it correctly. Slightly more explicit return-format details could improve it, but none are essential for 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 tool has zero parameters and the input schema is empty, so there is no parameter semantics to document. The baseline of 4 applies because no parameter information is needed in the description.

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 a specific verb ('Read') and resource ('avatar'), and lists the returned content: count, names, and runtime properties. It also distinguishes itself from mutating tools by explicitly stating it does not mutate the MD 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 when to use the tool: whenever avatar count, names, or runtime properties are needed. However, it does not explicitly name alternatives or state when not to use this tool, especially given the large sibling list containing scene_info, environment_info, and project_info.

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 takes on the full behavioral burden and does so thoroughly. It discloses retention limits, cleanup timing, potential effects on the project path and scene, file-writing behavior, the need to verify state, and the ambiguity of timed-out operations. This is substantially more transparency than most tool descriptions provide.

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 compact and front-loaded, starting with the core action. Every sentence adds distinct value: retention policy, cleanup behavior, side-effect warnings, verification guidance, and retry handling. There is no redundant or filler content.

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 description covers the most important operational concerns: safety, side effects, retention, cleanup, and timeout ambiguity. It does not describe what the tool returns, but the 'Verify resulting state' guidance partially mitigates that gap. Given the risky nature of the operation, this is a well-rounded description.

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 only parameter, label, is required, yet the description never explains what label should contain, whether it must be unique, or how it relates to the checkpoint. Schema description coverage is 0%, so the description needed to compensate for the missing parameter documentation, but it does not.

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 specific action ('Save a unique ZPRJ checkpoint') on a concrete resource, making the tool's purpose immediately clear. It also implicitly distinguishes this from durable saves by describing the checkpoint as an auto-cleaned cache, so an agent can tell it apart from save_project and restore_checkpoint.

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 explicit when-not-to-use guidance: 'Keep durable project saves outside this auto-cleaned cache.' It also provides a post-timeout procedure, telling the agent to call reconcile_operation before retrying. It does not explicitly name sibling tools like restore_checkpoint or save_project, but the exclusion of durable saves is strong context.

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 disclosure burden and does it well: it flags mutation ('May change scene or write files'), demands state verification ('Verify resulting state'), and states non-obvious timeout semantics ('A timed-out operation is UNKNOWN: reconcile_operation before any retry'). It stops short of a 5 because it doesn't hint at what 'verify' entails or what failure modes other than timeout look like.

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?

Roughly 50 words across four sentences, with the core action and format front-loaded before safety and timeout notes. The only waste is redundancy: 'Verify resulting pattern' and 'Verify resulting state' express nearly the same instruction in consecutive sentences.

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 and no output schema, the description covers the highest-stakes facts well: point format, side effects, verification requirement, and timeout handling. However, it leaves three gaps an agent would hit: what 'name' does, what the tool returns on success (no output schema to fall back on), and whether this appends vertices to an existing pattern or creates a new one. Solid for the essentials, incomplete on the edges.

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. It fully documents the critical 'points' parameter structure — each element is [x_mm, y_mm, type] with type meaning explained — which the raw schema (array of arrays of numbers) entirely fails to convey. The optional 'name' parameter is never mentioned, preventing a 5.

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?

States a specific verb and resource ('Create [x_mm,y_mm,type] vertices') with the type encoding spelled out (0=straight, 2=spline, 3=Bezier). This is distinguishable from the sibling family (list_patterns, get_pattern_points, move_pattern_point, delete_pattern). Minor ambiguity remains about whether this creates a new pattern object or adds vertices to an existing one, given the tool name says 'pattern' but the description only mentions vertices.

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 on when to use this tool versus alternatives among the many pattern/sewing siblings. The only usage-adjacent guidance is operational — 'Verify resulting pattern' and 'reconcile_operation before any retry' — which addresses post-call behavior, not tool selection. An agent gets no help deciding between create_pattern, create_sewing, or move_pattern_point.

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 responsibility and does well: it discloses side effects ('May change scene or write files'), instructs to verify resulting state, and explicitly states that a timed-out operation is UNKNOWN with a reconciliation step. This is meaningful behavioral context beyond what structured data provides, though it omits details like permission requirements or rollback 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 dense but every sentence carries weight: preferences, constraints, unsupported cases, prerequisites, side effects, and timeout behavior are all covered in a compact block. No filler or redundancy; critical safety information ('May change scene or write files') is included succinctly.

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 8-parameter tool with no schema descriptions, no annotations, and no output schema, the description covers several critical aspects (edge refs, ranges, directions, side effects, timeout semantics) but leaves gaps: pattern_a/pattern_b are unexplained, the return value/result format is not addressed, and 'fresh topology' is mentioned without detail. It is useful but not fully complete for a tool of this complexity.

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. It does clarify side_a/side_b as edge refs with 0..1 ranges, directions, and legacy indices (likely line_a/line_b), but pattern_a/pattern_b are never explained, and the mapping between parameter names and described concepts is left implicit. Over half the parameters lack direct semantics.

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 tool name and context imply it creates a sewing, but the description never explicitly states the action or resource. It immediately jumps into usage guidance ('Prefer side_a/side_b edge refs...') without a clear 'Create a sewing between two edges' statement, leaving the agent to infer the core purpose from the name and sibling 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?

Provides explicit and actionable guidance: prefer side_a/side_b refs, require explicit boolean directions, restrict to full-edge ranges [0,1], and warn that partial/free sewing is unverified. It also directs the agent to obtain refs from fresh topology and to use reconcile_operation before retry on timeout. However, it does not contrast this tool with alternatives like inspect_sewing or list_sewings for normal verification.

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 it does so excellently. It reveals that remaining indices may shift, that the operation may change the scene or write files, that state must be verified, and that a timed-out operation is UNKNOWN until reconciled. This is far beyond a typical delete description.

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?

Every sentence earns its place: the core action, the index-shift warning, the side-effect warning, the verification instruction, and the timeout reconciliation rule. It is compact, front-loaded, and free of padding.

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 tool with no output schema and no annotations, the description gives a remarkably complete operational picture: verify before, handle side effects, verify after, and recover from timeout. It could be more explicit about where pattern_index comes from, but the tool is otherwise callable without missing critical steps.

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 has one parameter, pattern_index, with no description and 0% schema coverage. The description only indirectly references indices by saying they may shift; it never explicitly defines pattern_index as identifying the target pattern in a list or explains indexing origin. The parameter meaning must be inferred from the name alone.

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 operation: 'delete' a pattern, with additional verification steps. It distinguishes itself from the many inspect/list siblings by naming the delete action and the expected count change. The purpose is immediately recognizable.

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 no explicit when-to-use or when-not-to-use guidance versus alternatives. It does provide a useful conditional: on timeout, use reconcile_operation before retrying. That is specific but narrow; broader usage context is left implicit.

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 burden of behavioral disclosure. It explicitly declares that the operation does not mutate the MD scene, which is valuable side-effect transparency for an environment/diagnostic tool. It could add more context about network interaction or error behavior, but the non-mutation guarantee is clear.

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 two short sentences with no filler. The most informative content is front-loaded, and the safety statement adds meaningful distinction without bloat.

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 read-only informational tool, the description is complete: it lists exactly what will be returned (runtime, version, timestamp, connection health) and clarifies that the scene is not mutated. No output schema exists, but the enumerated contents provide sufficient expectation of the response.

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 parametersks, so per the rubric the baseline is 4. The description adds no parameter information, but none is needed.

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 resource ('environment_info') and lists precise contents: runtime, MCP commit/version, documentation timestamp, and connection health. It is clear and not tautological, but lacks an explicit verb and does not distinguish itself from the similarly diagnostic sibling 'ping'.

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 'Does not mutate the MD scene' implies this is a safe, read-only diagnostic call, which is useful usage guidance. However, there is no explicit statement about when to prefer it over alternatives such as 'ping' or 'scene_info', so the usage context is implied rather than fully specified.

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 full responsibility and covers side effects, safety limits, and state ambiguity well: it warns "Not a sandbox," says raw code "can change the scene," may "access embedded Python filesystem/process capabilities," and notes a timed-out operation is "UNKNOWN" requiring reconcile_operation. This is exemplary disclosure for a dangerous execution tool.

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 each warning earns its place for a high-risk tool. Minor redundancy exists: "Static guard is not a sandbox" is followed by "Not a sandbox," which repeats the same point. Overall, critical safety information is front-loaded and readable.

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 there is no output schema and no annotations, the description covers the essential operational concerns: environment gating, side effects, filesystem/process capabilities, timeout ambiguity, and post-execution verification. It is slightly incomplete on what "modal-risk" means precisely and how to set the override, but it is otherwise sufficient for safe 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?

Schema description coverage is 0%, so the description must compensate. It partly does: "import API modules and assign result" explains the intent of code, and "modal-risk calls require explicit override" implies the allow_potentially_modal parameter. However, it never names either parameter directly, leaving the agent to infer the mapping.

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?

"Execute reviewed Python" names a specific verb and resource, and "import API modules and assign result" clarifies what execution is for. It is not a tautology and the resource is clear, though it does not explicitly distinguish itself from sibling tools like preflight_python.

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?

"Look up docs/runtime first" and "MD_MCP_ALLOW_RAW_PYTHON=0 refuses this tool" provide useful context about prerequisites and environment gates. However, the description does not explicitly state when to use this tool versus alternatives or list any excluded cases.

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 and does an excellent job: it discloses side effects ('May change scene or write files'), instructs verification of output and state, and explicitly warns that a timed-out operation is UNKNOWN and must be reconciled before retry. This goes well beyond the schema.

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?

Four terse, purposeful sentences with the primary action front-loaded. Every sentence adds value: precondition, option guidance, side-effect warning, verification step, and timeout handling. No 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 2-parameter mutation tool with no annotations and no output schema, the description covers the full calling context: required path condition, option sourcing, side effects, post-operation verification, and failure semantics. Nothing an agent needs to invoke it safely is missing.

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 add meaning. It does: 'path' must be a new absolute path, and 'options' should be selected from runtime ExportFBXOption fields. It compensates meaningfully, though it does not enumerate the option fields.

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 'Export FBX', a specific verb and clear resource, and clarifies that it exports with 'explicit runtime options'. It does not explicitly name sibling tools like export_obj or export_project for differentiation, so it misses the full 5.

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 gives concrete preconditions: requires a new absolute path, and advises inspecting runtime ExportFBXOption fields before choosing options. It does not state when to prefer an alternative tool, but the context for correct 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?

With no annotations provided, the description carries the full burden of behavioral disclosure, and it does so thoroughly. It warns that the operation 'may change scene or write files', prescribes verifying the resulting state, and explicitly states that a timed-out operation is UNKNOWN and must be reconciled before any retry. This is strong, honest risk communication.

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 compact and front-loaded, with no filler. Every sentence adds actionable information: format details, path requirement, option inspection, side-effect warning, verification, and timeout handling.

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 file-export operation with no output schema and no annotations, the description covers the high-risk aspects: side effects, path constraints, option selection, and timeout reconciliation. It does not describe the exact return shape or how to identify successful output beyond 'verify', but enough guidance is present for safe 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 provides zero description coverage, and the description compensates meaningfully: it clarifies that 'path' must be a new absolute path and that 'options' should align with runtime ExportOBJOption fields. It does not enumerate all possible fields within the options object, but it gives enough direction for an agent to know how to populate the 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 states a specific verb and resource: 'Export OBJ' with explicit options, scale, axes, and object selection. It clearly distinguishes this from sibling export tools like export_fbx by specifying the OBJ format and its unique concerns.

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 preconditions and context: it requires a new absolute path, tells the agent to inspect runtime ExportOBJOption fields before choosing options, and instructs verification of the resulting state. It does not explicitly name alternatives or say when not to use this tool, but the usage context is otherwise well defined.

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, and it delivers: it discloses that the active project path may change, that files/scene may be written, that the resulting state must be verified, and that a timed-out operation is UNKNOWN. This is unusually transparent for a mutating tool.

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?

Four short sentences, each carrying distinct information: purpose, requirement, side effects, and timeout handling. Warnings are front-loaded around the core operation, with no 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 single-parameter tool with no annotations and no output schema, it covers prerequisites, side effects, and failure-mode behavior well. The gap is the unexplained 'API bool' and lack of any statement about return values or how success is observed beyond verification.

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 single parameter path is described as 'explicit path' and 'new absolute output path', adding meaning beyond the schema's bare 'Path' label. However, the description references an 'API bool' for thumbnail creation that is not represented in the input schema, which could confuse invocation.

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?

States a specific verb and resource: 'Save ZPRJ with explicit path'. This clearly distinguishes it from siblings like save_project, export_obj, and export_fbx. The additional mention of thumbnail creation adds nuance without obscuring the core purpose.

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?

Provides clear context: requires a new absolute output path, warns to verify resulting state, and instructs to call reconcile_operation before retrying after a timeout. It does not explicitly name alternatives, but the conditions for correct use are clear enough for an 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, and it excels: it discloses that the operation 'May change scene or write files,' warns to 'Verify resulting state,' and explicitly states that a timeout leaves state UNKNOWN and requires reconciliation before retry. It also reveals the BACK/SIDE unlink behavior, going far beyond a basic read/set statement.

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?

Every sentence earns its place: purpose is front-loaded, followed by unlink behavior, version verification, read/set switch, a distinction from colorways, side-effect warnings, and timeout protocol. There is no filler or redundant wording.

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 no-annotation, no-output-schema tool with three parameters, the description is remarkably complete, covering semantics, side effects, read/set behavior, and error handling. The only minor gap is not explicitly describing the exact shape of a read result, though 'omit rgba to read' strongly implies it returns the current RGBA value.

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 fully explains face (FRONT/BACK/SIDE), rgba range (0..1), and the read/write toggle via omission of rgba. fabric_index is left to inference from its name, but the most semantically ambiguous parameters are well-covered.

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 'Read/set FRONT/BACK/SIDE RGBA (0..1)', providing a specific verb and resource that immediately clarifies the tool's role as per-face material color manipulation. It also distinguishes the face enum from 'fabric assignment colorway options,' which differentiates it from sibling tools like assign_fabric.

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 gives explicit mode selection guidance ('Omit rgba to read'), explains the unlink side effect for BACK/SIDE, and points to reconcile_operation for timed-out operations. However, it does not name a specific alternative sibling for when a different tool should be used, aside from implicitly excluding fabric-assignment colorways.

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 behavioral disclosure burden. It states that the tool is non-mutating, requires a local index, and may return stale information because documentation can lag the runtime. These are valuable and specific behavioral traits. It could go further with error conditions or output size, but it is already strong.

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 four short sentences with no filler. The first sentence front-loads the core purpose, and the subsequent sentences add essential prerequisites and caveats. Every sentence earns its place.

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, no-output-schema tool, the description covers the purpose, return content, safety profile, prerequisite, and staleness warning. It is missing explicit guidance on selecting between sibling documentation tools and the exact semantics of 'name', but overall it is sufficient for an agent to use the tool correctly in most situations.

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. The single parameter 'name' is implicitly the API/type name to look up, and the listed content types clarify what is retrieved. However, the description does not specify the expected format, namespace, or whether the name must be exact or can be a partial match.

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 specifies the resource: exact API/type documentation including overloads, parameter meanings, returns, and source. It also clarifies a key behavioral trait by saying it does not mutate the MD scene. However, it lacks an explicit verb such as 'fetch' or 'return', and it does not explicitly distinguish itself from sibling tools like search_md_docs.

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 an important prerequisite ('Requires local index: md-mcp update-docs') and a caveat about documentation lagging the runtime, which helps agents decide whether to rely on it. It does not mention alternative tools, when-not-to-use, or how to choose between this and search_md_docs.

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 and explicitly states 'Does not mutate the MD scene,' signaling a safe read operation. It also discloses an external dependency ('Requires local index') and a maintenance caveat ('Documentation can lag the runtime'). This goes well beyond what the schema provides.

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 sentences, front-loaded with the core operation, followed by prerequisites and caveats. Every clause adds useful information; there is no filler or repetition of the tool name.

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 read operation with no output schema, the description provides enough context to invoke it correctly: it is read-only, requires an index update, and needs path/mutation review before execution. The main omission is the return shape or content structure of the scenario, which matters because there is no output schema to fill that gap.

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 only parameter, 'name', has no schema description (0% coverage), and the description does not explain what valid name values look like, how to locate them, or whether they are IDs, paths, or titles. Saying 'one official scenario' only weakly implies that name is the scenario identifier. The description fails to compensate for the schema's missing 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 opens with a specific verb ('Read') and a specific resource ('one official scenario'), which clearly distinguishes it from sibling search_md_scenarios and general get_md_doc. The word 'official' further narrows the tool's object. There is no ambiguity about what operation is performed.

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 gives concrete usage context: adapt paths and review mutations before execution, and requires the local index via 'md-mcp update-docs'. It also warns that documentation can lag the runtime. It does not explicitly name alternatives or when-not conditions, but the read-only pre-execution context 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?

With no annotations, the description takes on the burden of disclosing side effects, and it explicitly states 'Does not mutate the MD scene.' It does not describe return shape or error behavior, but for a simple getter the key non-mutation guarantee is 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?

Two short, front-loaded sentences with no filler. The purpose and key behavioral note are both present and the description is easy to scan.

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 read-only getter, the description provides enough to invoke it correctly: pass pattern_index to read the current assignment. No output schema exists, but the return meaning is implied; some detail on return format would make it fully 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% and the description does not explain pattern_index at all, so the agent must infer the indexing scheme from the parameter name alone. Since coverage is low, the description was expected to compensate and did not.

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 ('Read') and identifies the resource ('actual pattern fabric assignment'), making the tool's purpose clear. It implicitly distinguishes this from assign_fabric (write) and list_fabrics (available fabrics), though it does not name sibling tools explicitly.

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 establishes a clear read-only context: use this to inspect the current fabric assignment, not to change it. It does not explicitly name assign_fabric as the mutation alternative or list exclusions, 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?

No annotations are provided, so the description carries the full burden — and it does disclose the most critical trait: 'Does not mutate the MD scene,' which is the key safety-relevant behavior for an inspection tool. It falls short of disclosing what 'ambiguous mappings are flagged' means operationally (e.g., return format, error behavior on an invalid pattern_index). Adequate but not rich.

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 sentences with zero filler; the core purpose and the safety disclaimer are both front-loaded and every clause earns its place. Efficient and well-ordered.

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 one-parameter read tool this is reasonably complete: purpose, timing, and non-mutation are all stated. However, with no output schema, the return content is only sketched ('geometry and line indices', 'ambiguous mappings flagged'), and pattern_index semantics are undocumented. Adequate with clear gaps.

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 never mentions pattern_index, its valid range, or indexing semantics (e.g., 0-based, relationship to list_patterns order). The only clue is the contextual inference that the index selects which pattern is inspected. With zero schema coverage, the description was obligated to compensate and largely does not.

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 specific verb ('Inspect') and resource ('geometry and line indices'), and frames the tool's purpose ('before edits'), which is clear and distinct in role. It does not explicitly name a sibling it differs from, but the inspection-vs-mutation contrast is evident. Slightly terse, yet unambiguous about what the tool does.

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 'before edits' gives a clear temporal context for when to call the tool, which is genuinely useful guidance. However, no alternatives are named or excluded despite many overlapping siblings (get_pattern_points, list_patterns, inspect_md_api) that an agent might confuse it with. Usage context exists but exclusions and alternative routing are absent.

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 behavioral disclosure burden. It explicitly discloses that the call does not mutate the MD scene and warns that curve point mutation mapping is unverified, giving agents valuable side-effect and data-freshness information.

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 front-load the return data, then cover the caveat and side-effect profile. No filler or redundant schema 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 a one-parameter getter with no output schema, the description gives the key output type and confirms non-mutation, but it omits any usage guidance or parameter semantics and leaves the unverified curve-mapping caveat ambiguous. This is an adequate minimum but with clear gaps.

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% and the description does not explain pattern_index beyond its name and title. The single parameter's role is inferable from context, but the description adds no meaning about how pattern_index is interpreted.

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 identifies the output as point coordinates in mm and IDs, making the tool's retrieval purpose clear even without an explicit verb. It contrasts with mutation siblings by stating it does not mutate the MD scene, but it doesn't explicitly differentiate from other getter tools like get_pattern_info or get_pattern_topology.

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 on when to prefer this tool over alternatives is provided. The non-mutation note implies it is safe to call but does not state prerequisites or when point coordinates are needed versus information from get_pattern_info or get_pattern_topology.

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 explicitly states 'Does not mutate the MD scene,' which is a clear read-only declaration. It also discloses that ambiguous mappings are never guessed, implying it may error or request clarification rather than silently misresolve, and that stale references require re-reading. These are meaningful behavioral traits that go beyond the minimal requirements. It does not cover error codes or response format, but the provided transparency is strong.

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 run-on sentence, packed with information but not well-structured. It starts with a cryptic feature list, then moves to usage and behavior. While it is not excessively long, the lack of clear separation between purpose, usage, and behavior reduces readability. The content is efficient but the organization is poor, making it harder for an agent to parse quickly.

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 that likely returns a complex topology structure, the description is incomplete. It mentions 'native point/line enumeration' and 'geometry snapshot refs' but does not explain the structure of the return value, how the refs should be used, or what 'topology' means in this context. There is no output schema, so the description carries the responsibility of describing the result. It also omits error handling and edge cases. The description provides some context but leaves critical gaps that an agent would need to resolve.

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 a single parameter 'pattern' as either integer or string with zero description coverage. The description fully compensates by explaining that it can be a UUID (string), a unique name (string), or a freshly inspected index (integer). It also clarifies the notion of 'freshly inspected' implying the index must come from a recent list operation. This adds substantial semantic value beyond the schema, giving the agent clear guidance on how to construct the parameter correctly.

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 does not clearly state that this tool retrieves the topology of a pattern. It lists features like 'UUID + native point/line enumeration + geometry snapshot refs' without defining what 'topology' means or what the output represents. The verb 'get' is implicit in the name, but the description reads as a feature list rather than a purpose statement. It is not a tautology, but it is vague and cryptic, leaving the agent uncertain about the exact resource being returned.

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 some usage context: it explains how to select the pattern (by UUID, unique name, or freshly inspected index) and advises preferring stable refs for edits. It also mentions 'Read again after STALE_REFERENCE', which hints at when to re-invoke. However, it does not explicitly compare to sibling tools like get_pattern_points or get_pattern_info, nor does it state conditions for when to choose this tool over alternatives. The guidance is implied but not explicit.

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 full behavioral weight. It warns that the operation may change the scene or write files, says to verify resulting state, and clarifies that a timed-out operation is UNKNOWN and must be reconciled before retrying. This is unusually transparent about side effects and failure semantics.

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?

Every sentence earns its place: purpose, side effects, comparison precondition, and timeout handling. The description is dense but front-loaded with the core function and ends with the most critical failure behavior. No filler 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 a side-effecting 'get' tool with one param and no output schema, this is fully complete. It covers what the operation returns, when comparison is valid, side effects, verification expectations, and how to handle timeouts. An agent has everything needed to call and interpret this tool 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?

Schema coverage is 0% and there is one optional parameter. The description compensates by explaining how previous_snapshot_id should be used and what preconditions apply (topology match, no persistent IDs). It doesn't fully define the ID format or how it is obtained, but it gives enough operational meaning for an agent to use it safely.

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 identifies the tool as an on-demand operation that gets garment OBJ positions and index-based displacement, and explicitly states it never judges convergence. It also mentions writing an OBJ measurement in user cache, which distinguishes it from simulation_state and export_obj.

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?

Provides concrete usage conditions: compare to previous_snapshot_id only if topology matches, no persistent vertex IDs or collision/convergence guarantee, and calls out reconcile_operation as the required follow-up after a timeout. This gives an agent explicit when-to-use and what-not-to-assume 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 full burden, and it delivers: it discloses 'May change scene or write files', instructs to verify resulting state, and explains that a timed-out operation is UNKNOWN and must be reconciled before retry. This is unusually transparent about side effects and failure semantics.

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?

Four dense, front-loaded sentences with no filler. Every clause adds a constraint or caveat relevant to safe invocation, and the most important action and format are stated first.

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 mutation tool with no annotations and no output schema, it covers prerequisites, side effects, and timeout recovery. It does not describe the success/return shape explicitly, but 'Verify resulting state' signals that scene inspection is the expected success check.

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?

With 0% schema coverage, the description compensates by adding meaning to 'path' (existing absolute path) and 'options' (explicit scale/axes, ImportObjectType=0). It gives only indirect context for 'acknowledge_modal_risk' via the modal acknowledgement warning, so one parameter remains under-explained.

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 'Import verified OBJ avatar' – a specific verb, resource, and format. It clearly differentiates this from sibling import tools by stating OBJ ImportObjectType=0 is verified while FBX/AVT imports are unverified.

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 gives concrete call requirements: use an existing absolute path and explicit scale/axis options, and notes that OBJ is the verified path. It warns about modal acknowledgement and unverified FBX/AVT, but it does not explicitly name alternative sibling tools for those cases.

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 burden of disclosing side effects. It explicitly warns that the operation 'May change scene or write files' and instructs verification of the resulting state. It also discloses the timeout behavior ('timed-out operation is UNKNOWN') and the required reconcile step. This is valuable behavioral context beyond the schema, though it could further clarify the nature of 'verify count'.

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 compact and information-dense. Every sentence adds a distinct piece of guidance: file type, option requirement, verification, side effect warning, timeout handling. There is no 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?

Given the tool's destructive potential conciseness and lack of annotations, the description covers the essential operational caveats: importing .zpac, required option, verifying count/state, and timeout reconciliation. It does not explain what 'verify count' means or provide alternatives, but it is reasonably complete for a tool with a simple 2-param schema.

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 some meaning by mentioning 'explicit ImportExportOption including bAdd' and the .zpac extension, but it does not explain the path parameter structure or the full options object beyond one member. The agent is left guessing about the value and shape of bAdd and other potential fields.

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 specific verb and resource: 'Import .zpac'. It clearly identifies the input file type and distinguishes itself from sibling tools like import_project and import_avatar by targeting garment-specific .zpac archives.

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 does not explicitly name alternatives, but it gives clear context: use this for .zpac imports with an explicit ImportExportOption including bAddсь. It also provides crucial post-conditions: verify count, verify resulting state, and reconcile before retry on timeout. This is strong usage guidance, though it lacks explicit exclusion of 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?

With no annotations, the description fully carries the behavioral disclosure burden. It states that the operation may change the scene or write files, tells the agent to verify the resulting state, and explicitly warns that a timed-out operation is UNKNOWN. This is exemplary transparency for a mutating tool.

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?

Five short, dense sentences, each carrying a distinct operational fact: preferred format, legacy caveat, side effects, verification, and timeout recovery. There is no filler or repetition, and the most important usage guidance 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 state-changing import with no output schema and no annotations, the description covers side effects, modal risk, verification, and timeout recovery. It does not describe return values or explicit error cases, but the stated postconditions and safety guidance are the most relevant completeness elements for this tool.

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 real semantics by recommending a .zprj path, an explicit ImportZPRJOption including bAppend, and connecting modal-risk acknowledgement to the legacy import path. It does not explicitly name 'allow_potentially_modal', but the meaning is strongly implied.

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 never literally says 'imports a project', but the tool name plus phrases like 'ImportZPRJOption' and 'Legacy generic import' make the operation clear. It adds useful format-specific meaning but does not explicitly differentiate from sibling import tools such as import_garment or import_avatar.

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 gives explicit guidance: prefer .zprj with explicit ImportZPRJOption, warns that legacy generic import requires modal-risk acknowledgement, and instructs the agent to call reconcile_operation before any retry after a timeout. This is concrete when/how/when-not guidance with a named alternative action.

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 carries the full behavioral disclosure burden. It clearly states the tool does not invoke functions and does not mutate the MD scene, which is essential safety-relevant behavior. It does not describe return format or error behavior, but the non-invocation guarantee is strong and specific.

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 sentences, tightly packed with the core purpose and a safety guarantee. There is no filler or repetition of the schema, and the most important non-mutation behavior is stated at the end rather than buried.

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 introspection tool with no output schema and no annotations, the description omits critical invocation details: what module names/function formats are accepted, how results are returned, and what happens when an item is unavailable. An agent could call it with the wrong module string and have no guidance from the description.

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 does not explain how 'module' or 'function' should be specified. The schema provides only names, types, and a default; it leaves unclear whether module is a dotted path, a registered alias, or something like 'md'. The description should have compensated but did not.

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 specific verb ('inspect') and resource (MD API), and enumerates the exact kinds of information returned: runtime availability, callable/type/signature, docstring, and pybind overloads. It also explicitly disclaims invocation, which distinguishes it from the sibling md_api and other executing 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 phrase 'without invoking functions' and 'Does not mutate' strongly imply this is the safe, read-only introspection choice. However, it does not explicitly name alternatives or state when an agent should choose inspect_md_api over md_api, execute_python, or documentation lookup tools.

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. It clearly states that the tool does not mutate the MD scene and adds a useful caveat that partial-edge/internal-shape line indices may be unresolved. It does not cover return semantics or failure modes, but the safety and data-quality caveats are valuable.

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 with no filler: the primary purpose is front-loaded, followed by the unresolved-indices caveat and the no-mutation guarantee. Every phrase earns its place.

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 tool with no output schema, the description is mostly adequate: it gives the operation, side-effect status, and an important data caveat. However, it does not explain how to obtain a valid group_index or what the response will contain, leaving minor but real invocation gaps.

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 has 0% description coverage for group_index, so the description must compensate. It only implies that group_index selects a sewing group, without saying where the index comes from, whether it is zero-based, or what range is valid. This is minimal added meaning beyond the schema's bare type declaration.

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 the specific verb 'Read' with the clear resource 'sewing group,' and the explicit 'Does not mutate the MD scene' distinguishes it from mutation-oriented siblings such as create_sewing. It immediately tells an agent what operation this tool performs.

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 read/mutate contrast implies when to use this tool, but no alternative tool or explicit condition is named. An agent may infer inspection use from the verb, but there is no guidance such as 'use list_sewings to enumerate groups' or 'use create_sewing to create one.'

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 behavioral disclosure burden. It explicitly states 'Does not mutate the MD scene,' which is a valuable non-destructive indicator for a listing operation. However, it does not disclose other behavioral traits such as whether an open project or scene is required, what the output format looks like, or any error conditions.

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 sentence with no filler. It front-loads the primary output ('All object-browser fabrics plus current-colorway used count') and then adds the crucial non-mutation note. Every word contributes value.

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, read-only listing tool, the description states both the content returned and the non-mutating behavior. Since there is no output schema, a bit more detail about return formatting could help, but the simplicity of the tool lowers that burden. Preconditions like an open scene are not mentioned, but this is a minor gap for a listing operation.

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?

There are zero parameters, so the schema completely defines the call signature. The description appropriately adds no parameter-specific detail; it simply describes what the tool returns. The zero-parameter baseline of 4 applies here.

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 identifies the resource ('all object-browser fabrics') and the specific data point ('current-colorway used count'), making the tool's purpose clear despite lacking an explicit verb. It is distinct from sibling tools like fabric_material or get_pattern_fabric because it targets a full fabric list with a count. The absence of an explicit 'list' verb is mitigated by the tool name and the listing-style phrasing.

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?

There is no guidance on when to use this tool versus alternatives such as fabric_material, get_pattern_fabric, or assign_fabric. The description offers context but no explicit use cases, prerequisites, or exclusions. An agent must infer when this listing is appropriate.

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 does disclose the non-mutating nature of the tool, which is a critical behavioral trait. However, it does not mention return shape, ordering, pagination, or any other runtime behavior an agent might need before relying on the call.

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 two short sentences with no filler. The most important safety property, non-mutation, is placed clearly at the end, and every phrase adds meaning about what the tool exposes.

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, read-only list operation with no output schema, the description gives a solid picture of the returned data and the operation's safety profile. It is not fully complete because it never explicitly states that the tool returns all patterns or describes the result structure as a list, but the tool name and phrasing make this reasonably clear.

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 the description is not required to explain argument semantics. The description instead clarifies what the returned pattern structures contain, which is useful context in the absence of an output schema. This matches the baseline for a parameterless 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 name and description together clearly identify this as a pattern-listing operation, and the description specifies the resource (patterns) and the kind of data included (runtime indices, geometry, fabrics, placement, sewing groups). However, the description lacks an explicit verb like 'returns' or 'lists', and it does not directly contrast with sibling query tools such as get_pattern_info or list_sewings.

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 statement 'Does not mutate the MD scene' implies this is a safe read-only operation, giving an agent a reason to prefer it over mutation tools like create_pattern or delete_pattern. But there is no explicit guidance on when to choose list_patterns over other read-only siblings such as list_sewings, list_fabrics, or get_pattern_info.

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?

It explicitly says 'Does not mutate the MD scene', which is a valuable behavioral disclosure in the absence of annotations. However, it doesn't mention return format, data freshness, permissions, or error behavior, so coverage is partial. 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 text is short and contains no filler, but the first sentence is a non-sentence fragment and 'raw properties' is vague. It is concise but the structure is not polished enough for a 4/5.

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 description leaves the agent to infer that the tool returns a list of all sewings and doesn't describe the result shape, which matters because there is no output schema. It also fails to point to inspect_sewing for per-sewing detail, so the tool is not fully self-contained.

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 and schema coverage is 100%, so there are no parameter semantics for the description to add. Baseline for zero-parameter tools is 4.

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 first sentence enumerates data categories ('Sewing groups, pattern/edge references, directions and raw properties') without a verb, so it doesn't affirmatively state that the tool returns or lists sewings. The name supplies the verb, and the second sentence only adds a negative safety property. This is a vague purpose rather than a specific action statement.

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 context is given: it doesn't say when to call list_sewings vs inspect_sewing or create_sewing, nor mention any prerequisites or conditions. The only hint is 'Does not mutate', which implies a read use but does not guide the choice among read siblings.

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 burden of behavioral disclosure. It explicitly states that the tool does not mutate the MD scene, which is useful safety information for an agent. It does not discuss rate limits, return format, failure modes, or prerequisites, but for a listing operation the non-mutation guarantee is a meaningful baseline.

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 short and front-loaded with the primary purpose, 'List runtime symbols'. The second sentence adds relevant differentiation from inspect_md_api. It is efficient, though the mention of 'inspect_md_api reads signatures safely without trial calls' is slightly tangential to md_api itself and could be clearer.

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?

This is a simple two-parameter tool, but with no output schema and no annotations, the description must provide more operational context. It explains the high-level purpose and safety profile, but omits parameter semantics and any guidance on expected results or edge cases, leaving an agent under-equipped to invoke it 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?

Schema description coverage is 0% and the description gives no meaning to either parameter, 'module' or 'contains'. An agent cannot know what values to supply for module or how contains filters results. The description does nothing to compensate for the schema's lack of explanatory text.

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 starts with a specific action and object: 'List runtime symbols', which clearly identifies what the tool does. It also hints at the distinction from the sibling inspect_md_api, which 'reads signatures safely without trial calls', giving the agent some differentiation. However, it does not define what 'runtime symbols' includes or what the output looks like, so it stops short of full clarity.

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 indirectly contrasts md_api with inspect_md_api: one lists symbols, the other reads signatures. This implies a usage split but does not explicitly state when to use md_api versus alternatives, nor does it mention any conditions or exclusions. The safety note 'Does not mutate the MD scene' offers some context but not concrete selection 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 full disclosure burden and does so strongly. It warns 'May change scene or write files', instructs 'Verify resulting state', and discloses that 'Geometry changes invalidate the old refs'. It also flags the critical uncertainty trait: 'A timed-out operation is UNKNOWN: reconcile_operation before any retry.' This is exactly the kind of behavioral context an agent needs beyond a bare mutation hint.

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 sentence contributes operational guidance, covering point selection, units, stale references, side effects, verification, and timeout semantics. It is front-loaded with the most important selection rule and contains no 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 mutation tool with 5 optional parameters, no output schema, and no annotations, the description covers side effects, stale refs, and timeout handling very well. Yet it leaves the core action unstated and the relationship between point_index, pattern_index, and the 'legacy numeric form' under-specified. An agent could invoke it safely but not with complete confidence about parameter roles and expected results.

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 adds meaning the schema lacks, such as 'x/y are 2D millimetres' and directing the agent to obtain point_ref from get_pattern_topology. However, it only vaguely refers to the 'legacy numeric form' without mapping it to point_index/pattern_index or explaining which parameters identify the target or whether any must be provided. With 0% schema coverage, the description only partially compensates for the opaque parameter list.

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 never explicitly states the tool's core action—it does not say it 'moves' or 'updates' a pattern point. It implies geometry mutation through phrases like 'outer endpoints', 'straight polygons', and 'Geometry changes invalidate the old refs', but the main operation is left to inference from the tool name. This is a recognizable but unstated purpose.

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 explicit guidance on invocation style: 'Prefer point_ref for verified outer endpoints, including curved boundaries. Legacy numeric form supports straight polygons.' It also sets a clear prerequisite ('obtain point_ref from get_pattern_topology') and timeout-specific follow-up ('reconcile_operation before any retry'). It does not, however, define when to choose this tool over an alternative editing tool, only which parameter form to prefer.

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 to rely on, the description carries the full burden and does it well: it warns that the operation may change the scene or write files, tells the agent to verify the resulting state, and defines timed-out operations as UNKNOWN requiring reconcile_operation before retry. This is actionable risk and failure-handling context.

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 tight and front-loaded: purpose first, then mode selection, then risk and failure semantics. The two 'not a world transform' sentences are partially overlapping but each adds a distinct clarification, and no sentence is 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 two-parameter tool with no annotations and no output schema, the description supplies all critical operational context: read vs set, side effects, verification requirement, and timeout retry policy. The read result is implied by 'read/set ... parameters' and the tool name, so nothing needed to call it correctly is missing.

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. It clearly explains arrangement_offsets ('omit to read; otherwise supply three integers') and gives the X/Y/offset ordering. It does not add detail for pattern_index, but the parameter name and required flag make its role clear.

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?

Description names a specific verb ('read/set') and resource ('verified arrangement X/Y/offset parameters'), and explicitly distinguishes the operation from world-space transforms and Euler rotation. An agent can immediately know what this tool does and what it does not do.

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 gives an explicit conditional: omit arrangement_offsets to read, otherwise supply three integers to set. It also states when-not: not for world translation or Euler rotation, so an agent will not misuse it as a transform tool. No alternative is named, but the when/when-not guidance is unambiguous.

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 tool performs a verification and returns the listener's echoed response, implying a read-only, non-mutating operation. It could explicitly state that no state changes occur, but the echo behavior is sufficient for such a simple tool.

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 one short sentence with no wasted words. The main purpose is front-loaded, and the return behavior is stated immediately after.

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, no-output-schema tool, the description fully covers what the agent needs: what the tool verifies and what it returns. No missing details would prevent correct invocation or interpretation.

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 there is no parameter semantics burden on the description. The schema already fully covers this, and the baseline of 4 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 ('Verify') plus a clear resource ('the MD listener') and states the observable result ('returns whatever the listener echoes back'). This distinguishes ping from all sibling tools without ambiguity.

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 context is clear: use this to check listener reachability, which implicitly supports pre-flight health checks before other MD operations. It does not explicitly list when not to use it or name alternatives, but for a zero-parameter ping tool no competing sibling exists.

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 and does well by disclosing that the tool does not execute and does not mutate the MD scene. It also communicates that it classifies into four named risk categories. It could still be more explicit about return format or failure behavior, but the key safety traits are 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?

One sentence, clear, and front-loaded with the primary action and classification categories. Every word earns its place; the no-mutation guarantee is a useful addition without bloat.

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 single-parameter classification tool, the description covers the core behavior and safety profile. However, it lacks explicit parameter semantics and does not describe the output shape, and there is no output schema to fill that gap. It is functional but not fully self-sufficient.

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 never explains the 'code' parameter beyond what the schema shows, and schema coverage is 0%. It is likely Python source text, but an agent cannot tell whether to pass source code, a file path, or a module reference. With low schema coverage, the description needed to compensate but did not.

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 specific verb ('Classify') and resource ('visible calls') and names the classification categories. It distinguishes itself from execute_python by explicitly saying 'without execution', though the phrase 'visible calls' is somewhat jargon and could be clearer.

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 that this is a non-executing analysis tool, but it does not explicitly state when to use it versus alternatives like execute_python. The 'preflight' name and 'without execution' imply the intended use before running code, but no direct when-to-use or when-not-to-use guidance is provided.

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 burden of behavioral disclosure. It clearly states the tool is non-mutating ('Does not mutate the MD scene'), which is valuable. However, it does not disclose what 'runtime state' includes, whether it can fail, or what the return shape looks like, 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 two short sentences with no wasted words. The core purpose is front-loaded ('Read active project and runtime state'), and the non-mutation guarantee is a useful, concise addition.

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 read tool, the description is mostly complete: it states what it reads and that it does not mutate. However, it does not clarify what 'runtime state' encompasses or how this differs from scene_info/environment_info, which are likely siblings with overlapping scope. Given the large sibling list, a bit more differentiation would make it fully 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 schema provides no parameter semantics to clarify. The description adds meaning by explaining what the tool reads (active project and runtime state), which is sufficient for a parameterless tool. Baseline 4 for zero params 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 states a clear verb ('Read') and resource ('active project and runtime state'), and explicitly distinguishes itself from mutating tools by noting it does not mutate the MD scene. It is not a tautology and is specific enough to be understood, though it doesn't name a sibling alternative.

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 a read-only usage context and explicitly says it does not mutate, which helps an agent know it is safe to call for inspection. However, it does not state when to prefer this over siblings like scene_info or environment_info, nor does it provide exclusions or alternative routing.

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 explicitly states that the tool never retries, returns UNKNOWN when inspection is needed, may report partial effects under FAILED, and does not mutate the MD scene. This is detailed and honest about observable 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 three compact sentences with no filler. It front-loads the core purpose and return values, then adds the parameter instruction and caveats. Every sentence earns its place.

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 single-parameter read-only reconciliation tool with no output schema, the description provides all needed context: purpose, input source, return statuses, failure semantics, and non-mutation guarantee. An agent can correctly select and call this tool without additional 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 does so effectively by explaining that the operation_id must come from the original call, which is the critical semantic detail an agent needs beyond the bare schema definition. The parameter is simple, and the description fully covers its meaning.

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 specific action with a clear resource: reading a durable MD completion receipt and outputting evidence. It further defines the return statuses (SUCCEEDED/FAILED/UNKNOWN), which makes the tool's function unambiguous and distinct from sibling tools like ping or inspect_sewing.

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 the tool: after an original operation, passing the operation_id from that call. It also gives guidance on interpreting FAILED and UNKNOWN outcomes. However, it does not explicitly name alternative tools or state when not to use it, so it stops short of full exclusion 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 fully discloses that this operation replaces the active scene, invalidates topology references, and may write files. It also warns that timeouts leave the state unknown and instructs reconciliation and verification, which are significant behavioral traits beyond the schema.

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?

All four sentences carry essential information: action, side effects, verification, and timeout handling. The most critical constraints are front-loaded before less urgent failure handling.

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 description covers purpose, side effects, post-verification, and timeout recovery, which is substantial for a single-parameter mutation without an output schema. It lacks an explicit statement of return value or prerequisites (e.g., the checkpoint must exist), but the instruction to verify resulting state compensates somewhat.

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 contains a single checkpoint_id string with no description (0% coverage). The description uses the phrase 'verified checkpoint' which implies the ID selects a previously created checkpoint, but it never explicitly maps checkpoint_id to a source or format, leaving the agent to infer parameter semantics from the name and tool context.

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 action: replace the active scene with a verified checkpoint, and it names a concrete side effect (invalidate all topology refs). This clearly differentiates it from sibling create_checkpoint and other scene tools without needing to open the schema.

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 a clear operational context (restore and then verify) and an explicit failure protocol: a timed-out operation is UNKNOWN, so reconcile_operation must be called before any retry. It does not list exclusions or compare directly with create_checkpoint, but the guidance is concrete 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 fully bears the burden of behavioral disclosure. It explicitly warns about side effects: 'ZPRJ save may change the active project path', 'May change scene or write files', and requires verification ('Verify resulting state'). It also handles timeout uncertainty clearly: 'A timed-out operation is UNKNOWN: reconcile_operation before any retry.' This is thorough transparency for a mutation operation.

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 compact yet information-dense. The main purpose is stated first, followed by key constraints, side effects, and a failure-handling instruction. Each sentence earns its place without fluff or repetition. The structure is logically ordered: purpose → constraints → side effects → verification → timeout handling.

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 mutation tool with no annotations and no output schema, the description covers all essential operational aspects: what it does, what to avoid (existing outputs), side effects, required verification, and timeout behavior. It gives the agent enough to safely invoke the tool and handle failures. The lack of return-value details is acceptable given no output schema and the verification instruction.

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 has zero description coverage for the 'path' parameter. The description compensates by specifying 'Requires a new absolute output path', which adds crucial semantics: the path must be new (not existing) and absolute. This goes beyond the schema's bare string type and gives the agent actionable guidance. It doesn't add format details like file extension, but the core meaning is covered.

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 a specific action: 'Save a new ZPRJ checkpoint and verify file.' It uses a precise verb ('Save') and resource ('ZPRJ checkpoint'), which distinguishes it from generic operations. While it doesn't name sibling tools, the phrasing is specific enough to avoid confusion with export/import or checkpoint management 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 provides constraints ('Requires a new absolute output path', 'Existing outputs are protected') but no explicit guidance on when to choose this tool over alternatives like export_project or create_checkpoint. It doesn't name any sibling tools or explain scenarios where this should be preferred. The timeout handling instruction is useful but not about usage selection.

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 behavioral burden. It explicitly guarantees the tool does not mutate the MD scene, which is the key side-effect disclosure for a scene-info operation. It does not discuss return format or performance, but for a no-parameter info tool this is solid disclosure.

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, front-loaded with the substantive output summary and followed by the safety guarantee. There is no filler or redundant phrasing.

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 tool with no output schema and no annotations, the description fully covers what the agent needs: the data categories returned and the non-mutating behavior. Nothing essential is missing for correct selection and 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 tool has zero parameters, so the baseline is 4. The description does not need to explain parameters; it instead clarifies what information will be produced, which is the only relevant semantic content.

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 identifies a clear resource and scope: project/version info plus pattern and fabric counts for the MD scene. It stops short of a 5 because it lacks an explicit retrieval verb and does not distinguish itself from sibling info tools such as project_info or environment_info.

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 non-mutation statement implies this is a safe, read-only tool to call when a scene summary is needed. However, it never states when to prefer this over alternative info tools, leaving routing to the agent's inference.

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 explicitly states the tool does not mutate the MD scene, declares the local index dependency, and warns that documentation can lag the runtime. It does not cover behavior when the index is missing, but the key safety and operational traits are 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 description is three tight sentences. Purpose is front-loaded, followed by the safety guarantee, then the prerequisite and caveat. No sentence is wasted or redundant.

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?

An output schema exists, so return-value details are already covered. The description supplies the essential context: what is searched, that it is read-only, the required index update step, and the staleness caveat. It is missing explicit sibling differentiation, but for a simple two-parameter search tool this is adequate.

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, but it provides no per-parameter guidance for 'query' or 'limit'. The mention of BM25 implies query is free-text, but limit semantics, formatting, and defaults are left entirely to the schema.

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 ('Search'), names the resource ('local official MD docs'), identifies the mechanism ('BM25'), and states the outputs ('signatures and sources'). This clearly differentiates it from scenario search and mutation tools like search_md_scenarios and create_pattern.

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 a clear prerequisite ('Requires local index: md-mcp update-docs') and implies this is the tool for local doc search, but it does not explicitly say when to use this versus siblings like get_md_doc or search_md_scenarios. No exclusions or alternative conditions are given.

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 does so well: it declares that the tool does not mutate the MD scene, it warns about a required local index, and it cautions that documentation can lag the runtime. These are meaningful, non-obvious behavioral traits that an agent needs to know.

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 short sentences, each earning its place: the first states the core purpose, the second states the non-mutating behavior, and the third states the prerequisite and a caveat. It is front-loaded and free of 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?

Given the tool's simplicity (2 params, no annotations, output schema available), the description is largely complete: purpose, safety, prerequisite, and staleness warning are all present. It would be slightly stronger if it mentioned what happens when the local index is missing or how results are limited, but no critical information needed to invoke the tool correctly is missing.

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 lack of parameter documentation. It does not: 'query' is implied by 'Search' but not explained, and 'limit' is not mentioned at all, including any semantics like default behavior, maximum values, or ordering. The tool name and schema field names carry most of the meaning here.

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 specific verb ('Search') and a well-defined resource ('official Pattern, Simulation, Animation and Substance scenarios'). This makes the tool's purpose clear and distinguishes it from sibling documentation-related tools such as search_md_docs and get_md_doc, even without naming 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 description gives clear context for use: it searches official scenarios and explicitly notes that it does not mutate the MD scene. It also states a prerequisite ('Requires local index: md-mcp update-docs'), which helps an agent know when the tool can be invoked. However, it does not explicitly contrast against sibling tools or state when not to use this tool.

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 bears full responsibility for behavioral disclosure. It does disclose the key side effects: stopping the listener, and releasing both timers and TCP connections. While it does not mention idempotency, reversibility, or error conditions, the explicit statement of resource cleanup goes beyond a vague 'shutdown' and is sufficient for a simple zero-parameter tool.

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, focused sentence that front-loads the verb and resource, and includes necessary detail about timers and TCP connections without extraneous words. It earns its place entirely and is easy to parse.

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 shutdown action with no output schema, the description covers the essential facts: what is stopped and what resources are released. It does not explain the lifecycle context (e.g., that this is a cleanup step for MD sessions) or expected return behavior, but given the simplicity of the operation, the gap is minor.

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, and the schema description coverage is 100% (empty schema). The baseline for zero parameters is 4, and the description does not need to add parameter details. It correctly reflects that no arguments are required.

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 ('Stop') and the resource ('the MD listener'), and specifies additional side effects ('release its timer and TCP connections'). This is a distinct operation from sibling tools like md_api or inspect_md_api, which are not about shutdown, so an agent can unambiguously understand the tool's purpose.

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 no guidance on when to call this tool versus alternatives, nor any exclusions or prerequisites. There is no mention of whether it should be used before exiting an MD session, whether it can be called after other operations, or what happens if the listener is already stopped. The agent must infer usage 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, the description carries the full burden of behavioral disclosure, and it does so well. It discloses that the tool may change the scene or write files, that it does not imply convergence, and that a timed-out operation should be treated as UNKNOWN. These are exactly the non-obvious behaviors an agent needs to invoke and react to this tool safely.

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?

Four short sentences carry the core action, side-effect warning, required follow-up verification, and timeout handling with no filler. Critical caveats are front-loaded immediately after the core purpose.

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 tool with no output schema or annotations, the description covers invocation, side effects, expectations about success, state verification, and timeout recovery. It leaves only minor gaps such as the exact success/error response shape, but the agent has enough to call it and react 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?

Schema coverage is 0% and the description must compensate. It only restates the parameter name in the phrase 'steps (=frames)' and adds the synonym 'frames', but gives no detail about ranges, missing-default behavior, how steps affect execution, or what a reasonable value might be. This is minimal added value beyond the schema's integer/default declaration.

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 ('Simulate'), a specific resource ('steps (=frames)'), and a non-obvious result semantic ('verify synchronous success; does not claim convergence'). This distinguishes it from state-querying siblings like simulation_state and from convergence-oriented operations.

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 gives explicit post-call guidance: verify the resulting state and do not blindly retry after a timeout; use reconcile_operation first. It does not enumerate when to use the tool versus related siblings like execute_python or get_simulation_metrics, but the timeout-handling rule is concrete 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 provided, the description carries the full burden of behavioral disclosure. It clearly declares read-only behavior ('Does not mutate the MD scene') and states what is not exposed (physical convergence/collision judgments), which is valuable context beyond the name. It lacks details on return format or performance, but the explicit non-mutation and scope limitations are strong.

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 two concise sentences with no filler. It front-loads the main purpose (counts) and then clarifies limitations and side effects. Every sentence adds essential information, making it highly efficient.

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 zero parameters and no output schema, the description covers the core: what it does and what it doesn't do. It is sufficient for an agent to call it safely. Missing details like return format or exact structure could be considered, but for such a simple tool, the description is nearly complete. A small deduction for not suggesting alternatives or noting any assumptions.

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 schema provides no semantic content. The description compensates by specifying the exact type of information returned (native quality, pattern and mesh counts) and what it does not include (physical convergence/collision judgments), which adds meaning to the empty schema. With no parameters, a 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 clearly specifies that the tool reports quality, pattern, and mesh counts, and states what it explicitly does not expose (physical convergence/collision judgments). This distinguishes it from siblings like get_simulation_metrics and simulate by focusing on count-level information. However, it does not name the sibling alternatives explicitly, so it slightly misses the top score.

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 when to use this tool: when you need native counts and verify that the operation is read-only. It clearly states it does not expose physical convergence/collision judgments and does not mutate the scene, which helps an agent decide to use it for safe state inspection. However, it does not explicitly say 'use X instead for physical metrics', so it is not a perfect 5.

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