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

With no annotations, the description must disclose behavior, but it only says 'Measure', which implies a read-only operation without confirming side effects or lack of mutations. It fails to mention return format, potential errors, or any safety guarantees.

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, which is brief but severely under-specified. It omits critical information like parameter roles, expected inputs, and output semantics, making it more under-specified than concise.

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 high complexity of the input schemas (nested object types, many fields) and the existence of an output schema, the description lacks completeness. It doesn't explain what 'measure safety' means in terms of return values or how the tool evaluates the bone map against the provided rigs and scene.

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 4 complex parameters (profile, source_rig_id, target_rig_id, scene_snapshot) with 0% description coverage. The description provides no explanation of what these parameters mean or how they are used, leaving the agent without essential semantic guidance.

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 verb 'Measure' and specifies three measurable aspects (hierarchy, rest-axis, proportion safety) for a reviewed bone map. This distinguishes it from sibling tools like validate_retarget_profile, though the phrase 'reviewed bone map' is somewhat unclear and doesn't explicitly reference the profile object.

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

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

No guidance is provided on when to use this tool versus alternatives such as validate_retarget_profile or suggest_retarget_profile_map. The description gives no context for selection or preconditions.

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 must disclose behavioral traits itself. It indicates a bypass of review staging but lacks details on side effects, validation, undo capability, or safety implications. This is insufficient for a mutation tool that applies patches directly.

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 clear, front-loaded sentence that efficiently expresses the core purpose. It is not bloated, though it could be expanded slightly without losing conciseness.

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

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

Given the tool's complexity (large nested schema), absence of annotations, and no parameter descriptions, a single sentence is inadequate. Major gaps include patch structure, fingerprint validation, the meaning of 'white-listed', and workflow integration with sibling tools.

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

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

Schema description coverage is 0% and the description provides zero information about the patch parameter or instance_id. The complex ScenePatch schema is left entirely self-documenting, leaving the agent without semantic guidance for constructing valid inputs.

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 ('apply'), the resource ('a white-listed patch'), and the key differentiator ('without Blender review staging'), effectively distinguishing it from the staged patch workflow represented by 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?

The phrase 'power-user escape hatch' implies an alternative to the normal staging workflow, but it does not explicitly name alternatives (like stage_scene_patch) or provide when-not-to-use guidance. The usage context is implied rather than clearly stated.

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. It only states that a human-reviewed patch is applied, but doesn't disclose side effects, reversibility, or whether it requires any prerequisites. For a mutating operation, this is insufficient behavioral transparency.

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?

Single sentence with no filler, front-loads the core action. It's appropriately sized for a simple tool, though it sacrifices completeness for brevity.

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

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

The tool has an output schema and low parameter count, but the description omits crucial context about the patch application workflow, such as whether it can be undone, how it relates to staged patches, or what the output means. Given the sibling tools suggest a review/apply pipeline, more context would be needed.

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 lists one optional parameter, instance_id, with no description in the schema (0% coverage). The description provides no context for what instance_id means or how it should be used, leaving the agent to guess. Since the parameter name is relatively self-explanatory, it's not a 0, but the description adds no value.

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 verb 'Apply' and identifies the resource as 'the patch that a human has reviewed in Blender,' clearly distinguishing it from staging or discarding operations. However, it doesn't explicitly contrast with apply_scene_patch, a closely named sibling, so it's clear but not fully differentiated.

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 'that a human has reviewed' implies the appropriate time is after human review, offering some guidance. But there are no explicit when-to-use versus alternatives, no mention of workflow steps like get_staged_patch or discard_staged_patch, and no exclusions. The guidance is implied rather than 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 must carry the transparency burden. It reveals a key behavioral aspect—this operation does not change Blender—but does not disclose other important details such as idempotency, whether the discard is reversible, or any side effects on the patch data. More specifics would be needed for full transparency.

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, single-purpose sentence without extraneous words. It effectively communicates the tool's function in as few words as possible, demonstrating excellent conciseness and structure.

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 tool with an optional parameter and an existing output schema, the description adequately covers the core functionality. It could be improved by noting the consequence of discarding (e.g., the patch is permanently lost), but overall it is sufficient for an agent to understand the primary use.

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

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

The lone parameter instance_id has no description in the schema, and the description does not mention it at all. With 0% schema description coverage, the tool description should compensate but does not, leaving the agent to rely on the parameter 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 uses a specific verb 'discard' and names the resource 'staged patch,' clearly identifying what the tool does. The phrase 'without changing Blender' adds a distinguishing context, differentiating it from sibling tools like apply_staged_patch or undo_last_apply.

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

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

The description implies the tool is for discarding a staged patch, but it does not explicitly state when to use it versus alternatives like apply_staged_patch or get_staged_patch. No exclusions or alternative guidance is provided, so usage context is only implicitly conveyed.

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 alone must convey behavioral traits such as read-only safety, side effects, or behavior when instance_id is null, but none of this is stated. 'Check' weakly implies a read operation, but the description does not disclose what happens to the connection, what capabilities are probed, or any error behavior.

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

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

The description is a single, front-loaded sentence of nine words with no filler or redundancy. It communicates the core purpose immediately, which is appropriate for a simple health-check tool.

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

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

The tool has low complexity and an output schema, so return-value details are not required, but the description still lacks usage guidance and behavioral context. It is minimally viable for selecting the tool, but an agent would have to infer when to call it and what optional-instance_id omission implies.

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 needed to explain instance_id, but it only says 'one FaceLink Blender instance.' It does not clarify that the parameter is optional, what null/default means, or how the instance_id is used. The schema provides type/default, but the description adds little semantic value.

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 ('Check') and names the resource ('connectivity and capabilities for one FaceLink Blender instance'), making the tool's scope clear. This also distinguishes it from sibling tools like list_blender_instances or get_blender_job, which cover different facets.

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 wording implies this is a health/capability check for one specific instance, but it provides no explicit guidance on when to use it, no prerequisites (e.g., obtaining instance_id via list_blender_instances), and no exclusions versus sibling tools. The context is only 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, the description must carry the burden of behavioral disclosure. It accurately indicates this is a read-only operation, but it doesn't explain what happens when the job ID is invalid, whether it returns partial results, or any side effects. The simplicity of the tool lowers the risk, but the description adds no extra context beyond the basic read 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?

A single, concise sentence that gets straight to the point. It contains no fluff, no redundant content, and is immediately scannable. The length is appropriate for the tool's simplicity.

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 presence of an output schema means return-value documentation is already handled, so the description does not need to explain response fields. For a simple get-status operation, the description covers the core scenario. It doesn't mention error cases or status semantics, but given the tool's narrow scope and the output schema, it is sufficiently complete.

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

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

Schema description coverage is 0%, so the description needed to compensate. The word 'Blender job' implies that 'job_id' refers to the Blender job identifier, but 'instance_id' is left entirely unexplained. The optional parameter's purpose is unclear—does it specify a particular instance or filter? Because the description does not clarify either parameter beyond what the schema already shows, it falls short for a 0%-coverage case.

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

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

The description uses a specific verb and object: 'Get the status of a previously submitted Blender job.' It clearly identifies the resource (Blender job) and the action (retrieve status), and it implicitly distinguishes this from siblings like 'list_blender_instances' or 'preview_shot.' The phrase 'previously submitted' hints that the job must already exist, which adds scope.

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 guidance on when to use this tool versus alternatives, nor does it mention any prerequisites or exclusions. Usage is only implied by the verb 'get' and the term 'status.' No comparison with sibling tools is provided, so this is a bare minimum.

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?

Annotations are not provided, so the description carries the burden. It says 'Read', which indicates a non-mutating operation, but it doesn't disclose details such as whether the patch is returned in a specific format, what happens if there's no staged patch, or any rate limits. It adds minimal behavioral context beyond the verb itself.

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 concise sentence, about 12 words, with no redundancy. It is front-loaded with the verb 'Read' and quickly identifies the target. Perfectly concise.

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?

With an output schema present, the description needn't explain return values, but it still lacks context on preconditions (e.g., a staged patch exists), side effects, or the meaning of instance_id. Given the sibling tools like apply_staged_patch and discard_staged_patch, it is clearly part of a workflow, but the description doesn't elaborate. Overall, adequate but with notable gaps, earning a 3.

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%, but there is only one parameter (instance_id) that is optional and nullable. The description doesn't explain what instance_id refers to (likely the instance identifier) or how it affects the result. Given the low coverage, the description should compensate, but it adds no param information. The baseline for low coverage is below 3, but the single param is simple, so a 3 seems 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 states the tool reads (Read) a patch and artist-facing summary waiting for approval, distinguishing it from apply_staged_patch and discard_staged_patch. It is specific about the resource (staged patch) and its state (waiting for approval), though it doesn't explicitly mention the return type.

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 'currently waiting for approval' implies it's used before applying or discarding a staged patch, which provides context. However, it doesn't explicitly state when not to use it or mention alternatives like get_blender_job, so it falls short of a 5.

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 full burden. It adds the behavioral condition 'currently have the FaceLink bridge running', which is useful. However, it does not explicitly state read-only nature or side effects; while 'List' implies a safe operation, the description could be more explicit about being read-only and non-destructive.

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, front-loaded with the verb, and contains no filler. Every word contributes meaning, making it highly concise and 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?

Given the simplicity of the tool (no params, no annotations, and an output schema exists), the description is complete. It states what it lists and the specific filter condition. The output schema covers return values, so no further detail is needed.

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 is empty, so there is nothing to explain. The baseline for 0 params is 4, and the description does not need to add parameter details. It appropriately avoids irrelevant information.

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 ('List') and the resource ('Blender windows that currently have the FaceLink bridge running'). It distinguishes from sibling tools like facelink_health and get_blender_job by specifying the exact scope (only instances with the bridge active).

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 usage when you need to enumerate active Blender instances. It does not explicitly mention alternatives or exclusions, but the context is clear given the sibling list; the agent can infer this is the tool for listing connected instances. No explicit guidance on when not to use, but the purpose 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?

No annotations are provided, so the description carries the burden. It discloses that audit entries are persistent and rollback availability is current-session, which adds context. However, it doesn't mention side effects, read-only nature, or what 'availability' entails 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?

The description is one concise sentence, front-loaded with the core action. It is efficient, though it could benefit from a brief note on the parameter.

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 an output schema exists, the description need not explain return values. But with no annotations and a single undocumented parameter, it leaves some gaps about why instance_id matters and what 'rollback availability' means practically. It's adequate but not complete.

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

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

Schema coverage is 0%, and there is only one parameter with no description. The description does not explain what instance_id does, so it fails to add meaning. However, with only one optional parameter, the gap is less critical, but the description should at least hint at filtering by instance.

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

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

The description clearly states the tool lists persistent audit entries and rollback availability for FaceLink, using specific verbs and resources. It distinguishes from siblings like rollback_to_revision by focusing on listing, though it doesn't explicitly name alternatives.

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 implies usage for auditing and checking rollback, but no explicit when-to-use or when-not-to-use guidance. Sibling tools suggest a broader ecosystem, but the description lacks exclusions or alternatives.

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

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

With no annotations provided, the description carries the burden of behavioral disclosure. It usefully states that the tool does not apply the shot and that navmesh paths are deterministic, but it does not clarify whether temporary state is created, what the compiled output represents, or whether a valid scene snapshot is a prerequisite.

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 that front-loads the verb and key constraints, with no filler, repetition, or vague qualifiers. It conveys the core purpose and the most important behavioral qualifier extremely efficiently.

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?

Despite a very complex schema with two large required structs and no annotations, the description is only one sentence. The output schema exists, so return values need not be detailed, but the description omits invocation context, prerequisites, and the distinction from validation/staging tools, making it insufficient for reliable tool selection in a complex workflow.

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%, yet the description adds no meaning to the two required top-level parameters, shot_spec and scene_snapshot, or how they interact. The parameter names are somewhat self-explanatory, but the description fails to compensate for the absent schema descriptions.

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

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

The description uses a specific verb ('Compile') and resource ('shot'), and adds scope via 'including deterministic navmesh paths' and 'without applying it,' which distinguishes it from apply/stage tools. It is clear enough for a preview action, though 'compile' is somewhat domain-specific and does not explicitly contrast with validate_shot_spec.

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 applying it' implies this is for previewing before an apply/stage action, giving some usage context. However, it never names alternatives like apply_scene_patch, stage_scene_patch, or validate_shot_spec, nor states when to prefer this tool over them.

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 burden. It discloses the scope of the operation ('selected revision and every newer') and session-level scoping, which is useful. However, it does not state whether the operation is reversible, whether it creates a new revision, or how it affects instances, leaving important safety aspects undisclosed.

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, front-loaded sentence with no superfluous words. It conveys the core action and scope in 12 words, achieving excellent conciseness without sacrificing immediate clarity.

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 destructive rollback operation with no annotations, the description omits critical context: the role of instance_id, the permanence of the undo, and any relationship to the output schema. While the output schema is available, the description is not complete enough for safe and correct invocation.

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

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

Schema description coverage is 0% and the description does not map 'selected revision' to the revision_id parameter or explain the purpose of instance_id. The agent cannot derive parameter meanings from the description beyond their names, and instance_id is entirely unexplained.

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 'Undo' with the resource 'FaceLink revision' and explicitly defines the scope as 'the selected revision and every newer', which clearly distinguishes it from sibling tools like list_revision_history and undo_last_apply. The purpose is immediately understandable.

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 explicit guidance is given on when to use this tool versus alternatives. It does not mention list_revision_history, undo_last_apply, or any criteria for when a rollback is appropriate, leaving the agent to infer usage from the broad description.

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. While 'Read' implies a read-only operation, it does not explicitly state safety, authorization requirements, or potential side effects, leaving the agent uncertain about the tool's impact.

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 lists the data types without any redundant wording or unnecessary detail. It front-loads the action and immediately conveys the scope of the tool.

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?

Despite having an output schema (so return format disclosure is less critical), the description remains incomplete. It misses usage context, parameter semantics, and any indication of when this tool is appropriate, leaving an agent underprepared 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?

The sole parameter instance_id is completely absent from the description, and the schema has no description for it (0% coverage). The description fails to explain what this parameter is for or how it affects the scan, forcing the agent to infer its meaning from the title 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 uses the verb 'Read' and explicitly lists the data types (stable IDs, bounds, nav data, armature bones, Action channel inventories), making the tool's purpose specific and understandable. It clearly distinguishes from siblings by focusing on a broad scene scan rather than specialized validation or analysis, even though it doesn't name alternatives.

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 use this tool versus alternatives. It lacks any mention of use cases, prerequisites, or contexts where this scan is preferred, and doesn't address 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?

The description is transparent about the key behavior: it stages the patch without modifying the scene. However, it does not detail potential side effects (e.g., storing the patch, requiring permissions) or what happens to existing staged patches. Given the lack of annotations, it covers the most critical behavior but not exhaustively.

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, clear sentence with no fluff. It efficiently conveys purpose and behavior without unnecessary detail.

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 is sufficient for a basic understanding of the operation, but it omits any context about the patch structure, the meaning of 'staging', or how it relates to other tools like get_staged_patch or discard_staged_patch. While an output schema exists (so return values are not required), the description does not address prerequisites or error conditions.

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%. The description does not explain any of the parameters (patch, instance_id) or the nested structure (ScenePatch, PatchOperation). With a complex schema, this omission leaves the agent without guidance on how to construct valid inputs, failing to compensate for the low schema coverage.

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

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

The description clearly states the tool's purpose: to stage a patch in Blender for human review, explicitly noting it does not change the scene. This distinguishes it from apply_scene_patch and other 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?

It specifies when to use it (for review before applying) and highlights the non-destructive nature ('without changing the scene'), giving clear guidance. It does not explicitly mention when not to use it, but the context implies it is for staging rather than applying.

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 burden. It discloses an important behavioral trait: 'output always requires human review', which implies the tool doesn't commit changes and returns suggestions only. However, it does not describe what happens on failure, whether the output is a full map or just candidate matches, or what the output schema contains (though an output schema exists). The description adds the human-review requirement, which is valuable, but it's minimal.

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 with two clauses. It front-loads the core purpose and adds one behavioral note. No waste, but it is so short it lacks detail for other dimensions. For what it intends to cover, it's well-structured.

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

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

The tool takes a complex scene_snapshot object, has an output schema, and is in a domain where sibling tools suggest a workflow (validate/analyze/suggest). The description is insufficient: it does not mention how the scene_snapshot is used, whether action_name is required for generating a map, what the output format is (despite an output schema), or potential side effects. Given the complexity of the input and the tool's role in a pipeline, the description is too thin.

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%, meaning the description provides no parameter explanations beyond what the schema names suggest. The schema itself has 5 parameters (source_rig_id, target_rig_id, profile_name, scene_snapshot, action_name optional) with clear names and types, but no descriptions anywhere. The tool description does not explain the role of scene_snapshot or action_name, nor how they affect the suggestion. Since coverage is 0%, the description must compensate, and it fails to do so.

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

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

The description clearly states the tool's purpose: 'Suggest exact/normalized/alias bone matches' for retarget profiles. It identifies the specific action (suggest bone matches) and the resource (retarget profile map). However, it doesn't explicitly distinguish itself from sibling tools like 'validate_retarget_profile' or 'analyze_retarget_profile', though the verb 'suggest' implies a generative step versus validation/analysis.

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 it's used when you need to suggest bone matches for a retarget profile, but it doesn't explicitly state when to use it versus alternatives like 'validate_retarget_profile' or 'analyze_retarget_profile'. It also doesn't mention prerequisites (e.g., that the profile must exist) or that the scene_snapshot is required. The sentence 'output always requires human review' gives some usage guidance (the output shouldn't be applied automatically), but it lacks explicit exclusions or alternative tool recommendations.

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

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

With no annotations, the description carries the full burden of behavioral disclosure. It only says 'undo,' but fails to mention side effects (e.g., whether it is destructive, if there's an undo history limit, or what happens if there are no edits to undo). The optional instance_id parameter's role is also unexplored.

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, concise sentence with no fluff. It is appropriately front-loaded, though its brevity sacrifices important detail.

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 presence of an output schema and only one optional parameter, a slightly richer description would suffice. However, the description omits crucial context about undo scope, error behavior, and when to use this tool, making it incomplete for a mutating 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?

The input schema has one parameter, instance_id, but the description provides zero explanation of what it does or how it affects the undo operation. With 0% schema description coverage, the description must compensate but doesn't.

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 ('undo') and the target ('most recent edit') in Blender. However, it does not distinguish from sibling tools like rollback_to_revision, which also reverts changes, so it misses the chance to differentiate.

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

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

No guidance is given on when to use this tool versus alternatives like rollback_to_revision or other undo mechanisms. The description only states what it does, not when it 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?

There are no annotations, so the description carries the burden. It explicitly states 'without changing Blender' which discloses non-destructive behavior. However, it doesn't disclose what the validation actually checks (e.g., bone map validity, adapter constraints) or what the output looks like, though an output schema exists.

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, concise sentence that efficiently conveys the purpose and key constraint. No wasted words, and the key phrase 'without changing Blender' is front-loaded.

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

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

The tool has an output schema (though not shown in the context) and a single complex parameter. The description is minimal but adequate for a validation tool with a clear non-destructive guarantee. It could benefit from noting what validation entails, but given the schema richness the description is reasonably 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 only one parameter, 'profile', which is fully defined in the input schema with a detailed retarget profile structure. Schema description coverage is 0%, but the schema itself provides rich semantics for the profile. The description adds minimal value beyond stating the validation scope, so a baseline of 4 is appropriate given the strong 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 clearly states the tool validates a retarget profile (rename-only or sampled pose-bake) and explicitly notes it does not change Blender. This distinguishes it from other profile-related tools like analyze_retarget_profile and suggest_retarget_profile_map.

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 usage for validating a profile before applying, and the explicit 'without changing Blender' provides a key safety context. However, it does not specify when to use this over analyze_retarget_profile or other validation tools, nor does it mention any prerequisites or alternatives.

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

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

The description discloses a key behavioral trait (non-destructive, 'without changing Blender'), which is valuable given no annotations are provided. However, it omits other important behaviors like return values, error handling, or side effects, leaving the agent to infer from the output 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?

The description is a single sentence with no wasted words, front-loading the action verb. It is efficient, though perhaps too terse given the tool's complexity, but conciseness itself is good.

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

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

For a tool with two highly complex nested parameters and an output schema, the description is severely inadequate. It provides zero context about validation logic, constraints, or expected behavior, making it almost useless for an agent to gauge what will happen or how to interpret 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?

Schema description coverage is 0%, and the description provides no information about the two parameters (shot_spec and scene_snapshot). While 'typed shot' hints at shot_spec, scene_snapshot is completely unmentioned, failing to compensate for the low schema coverage.

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

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

The description clearly states the tool validates a typed shot and explicitly notes it does not change Blender. It distinguishes from siblings like preview_shot by emphasizing validation over previewing, though it does not elaborate on what validation entails.

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

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

No guidance is provided on when to use this tool versus alternatives. The only hint is 'without changing Blender,' implying a dry-run safety check, but there is no explicit mention of use cases, exclusions, or related tools such as preview_shot or apply_scene_patch.

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