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 discloses the outcome contract ('Returns PASS or detailed failure report'), which is genuinely useful, but says nothing about side effects, whether results are persisted, idempotency, or what happens when only a subset of the eight booleans is supplied (all default to false).

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, front-loaded with the action, then invocation, then return behavior. Nothing is padded, though the brevity is partly under-specification rather than discipline.

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 9-parameter tool with zero annotation coverage and zero schema coverage, the description is too thin. Output schema exists, so return values needn't be spelled out, but the eight audit criteria and the default-false semantics remain unexplained, leaving an agent unable to answer the audit 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% across 9 parameters, and the description only says '8 questions' with True/False answers. It does not define what any of gravity_correct, force_stops_motion, center_of_mass_drives, etc. actually mean, so an agent must guess at criterion interpretation and at the consequence of leaving defaults at false.

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: 'Run the Final Action Realism Audit (Audit Pass B — 8 questions) for a specific subject.' The 'Pass B' framing and the subject-scoped scope make it distinguishable from audit_camera, though it never names that sibling 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?

'Pass the subject name and True/False for each question' gives a minimal invocation instruction but says nothing about when this audit should be run, prerequisites (e.g., must audit_camera / validate_gate run first), or what to do on failure. Usage is implied by the tool name rather than 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?

With no annotations the description carries the full burden, and it does disclose the mechanics: six booleans go in, PASS or a detailed failure report comes out. It does not say whether the audit result is recorded/persisted, whether it can be re-run, or what the audit blocks downstream — gaps that matter for a gate-style 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?

Three short sentences, front-loaded with the audit name and scope, then the input convention, then the return shape. No filler, though the parenthetical 'Audit Pass A' adds little without further explanation.

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

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

An output schema exists, so the PASS/failure-report return needn't be spelled out, and the description does so briefly anyway. What's missing for a 6-parameter gate tool with zero schema coverage is any explanation of the individual criteria or the pass threshold — an agent can call it but may set the booleans arbitrarily.

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% — the six parameters have only bare titles like 'Framing Breathes' and 'Operator Anticipates Action'. The description only says 'pass True/False for each question', adding nothing about how to judge each criterion or whether all six must be true for PASS. The low-coverage case requires the description to compensate, and 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?

States a specific verb and resource: run the 'Final Camera Realism Audit (Audit Pass A — 6 questions)'. It is distinguishable from sibling audit_action and validate_gate by naming Audit Pass A and the camera-realism subject. What 'camera realism' criteria actually mean is left to the schema titles, so it stops short of 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?

The word 'Final' implies this is run at the end of a camera work pass, and 'Audit Pass A — 6 questions' implies a structured gate check. However, no explicit when-to-use rule, prerequisite phase, or alternative (audit_action, validate_gate, get_gate_criteria) is named, so the agent must infer the trigger condition.

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 already declare readOnlyHint and openWorldHint, so the safety/network profile is covered. The description still adds genuinely new context: no GitHub token is required (no auth setup needed) and nothing is installed as a side effect, which reinforces the read-only contract.

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, front-loaded with what the tool does and followed by the expected agent phrasing and the no-install guarantee. Slightly loose in that a quoted instruction is embedded, but nothing is wasteful.

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?

No output schema and no parameters, so the description should say roughly what the check returns (version comparison? availability flag?). It covers the network and safety angles but leaves the return/result shape implicit, which a caller must discover by invoking.

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 takes zero parameters, so there is no parameter semantics to explain; the description correctly does not invent any. Baseline 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?

States a specific verb+resource: queries GitHub for Previs updates. It is distinguishable from siblings like get_previs_update_notes and prepare_previs_update by being the read-only check step, though it never names those siblings 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?

Usage is implied by "Havendo novidade… posso instalar?" and "Nada é instalado", suggesting this is the pre-check before prepare_previs_update. But no explicit when-to-use/when-not or named alternatives are given, leaving the agent to infer the ordering.

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 mostly succeeds: it explicitly states the tool does not persist session state, does not access a remote host, and does not start a render. That is real behavioral disclosure of side effects an agent would otherwise fear. It stops short of saying whether competing calls or repeated calls are safe.

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, front-loaded with the purpose then the caller prerequisite then the non-effects. Every sentence carries information; only the stray double-backtick formatting is noise.

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 values need not be described, and the single required parameter is covered. For a one-parameter guidance tool this is close to sufficient; the only missing piece is what the two modes imply for downstream 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?

Schema coverage is 0% and the `mode` property has no enum, so the schema alone leaves the value space open. The description compensates by constraining `mode` to `local` or `remote`, which is the single most important semantic for this call. It does not explain what differs between the two modes, so it is not 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 action (return guidance) tied to a named input (the user's selected execution mode), so an agent knows exactly what comes back. It does not name or differentiate itself from any sibling tool, but the purpose is clear enough to route on.

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 caller must ask the user first" is an explicit usage prerequisite, which is the key gating condition for this tool. No alternative tools are named and there is no when-not guidance, but the ordering constraint 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 full behavioral burden. It clearly discloses what the tool returns: classification Type A/B/C/D, anatomical divergences, and recommended skeleton structure. It does not explicitly state that the operation is read-only or non-destructive, but the classification framing strongly implies it.

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, input guidance with examples, and output disclosure. It is front-loaded and 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?

The tool has one parameter and a present output schema, so the description does not need to explain return values in detail. It is nearly complete, but a brief note about when this classification should be invoked relative to skeleton blueprinting would improve contextual completeness.

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

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

Schema description coverage is 0%, so the description must explain the sole parameter. It does so by saying to provide a description of the character and gives several examples, which adds useful meaning beyond the bare string schema. It could still specify constraints on description length or detail, but the core semantics are 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 uses a specific verb and resource: 'Classify a character's body type for physics skeleton construction.' It also gives concrete example inputs and names the exact outputs, making the tool's scope unambiguous relative to general skeleton or rig 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 implies the tool should be used before skeleton construction by saying it is for physics skeleton construction, and it instructs the agent to provide a character description. However, it does not explicitly state when to use this tool versus alternatives such as get_skeleton_blueprint or get_body_kun_library.

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

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

With no annotations, the description carries the full behavioral burden. It discloses the shape of the result (severity, violated rule, fix priority), but says nothing about whether the call is a stateless read-only classification, whether it logs or mutates project state, or how it handles descriptions it cannot classify.

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 lines, front-loaded with the classification vocabulary, and zero filler. Slight redundancy in the second sentence restating the severity output already named in the 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 one-parameter classification call with an output schema available, the description covers purpose, input intent, and the nature of the response. Only the usage trigger and side-effect profile are left unstated, which is a modest gap at this complexity level.

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 single parameter is documented only by its title. The description partially compensates by telling the agent to 'provide a description of the issue', implying free-text problem statement, but adds no guidance on granularity, format, or whether structured context (scene, rig, phase) should be embedded.

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 (classify) and resource (previs error) and enumerates the output domain (FATAL, STRUCTURAL, POLISH), which makes the tool's job unambiguous. It does not explicitly contrast with the similarly-named sibling classify_character, so an agent must infer the distinction from the 'previs error' 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?

Usage is only implied: the agent should call this when it has an error to triage. There is no statement of when not to use it, no prerequisites, and no routing to alternatives such as get_previs_help or validate_gate.

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 usefully discloses persistence, the non-effects (no Pod start, no render), and the remote-mode prerequisite, but says nothing about collision behavior (existing project_id), permissions, failure modes, or expected result. Meaningful but incomplete disclosure for a write 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?

Short, front-loaded, and every sentence carries information (scope, path resolution, Pod prerequisite, non-effects). Minor wasted opportunity in the line-broken formatting, but 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 5-parameter mutation tool with no annotations and no output schema, the description covers the most confusing piece (scene_path resolution) and the remote precondition, but leaves mode values, project_id semantics, and post-call state undocumented. Adequate but with clear gaps that would cause agent guessing.

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 and only partially does: it clarifies scene_path semantics (relative to the target's configured workspace) and implies the pod_id condition for remote mode. The critical 'mode' parameter — a free-text string with no enum — is never given its allowed values, and 'project_id'/'name' are left entirely undefined.

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?

Specific verb + resource ('Create a persistent project') with scope tied to the user's selected local/remote target, which separates it from siblings like get_previs_project_status or set_previs_project_target. It does not explicitly name a sibling it could be confused with, so it falls short of a 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?

Gives concrete preconditions ('Remote mode requires an explicit existing Pod ID') and clear exclusions ('does not start a Pod or render'), which tells an agent what must already exist and what this call will not accomplish. It stops short of naming alternative tools or the sequencing (e.g., target selection first), so no explicit when-vs-which 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 behavioral burden. "Get" implies a read-only call and the description does disclose one genuinely useful trait — that the checklist contains a HOLD CONDITION blocking Seedance generation — but it says nothing about side effects, permissions, or whether the checklist is static or project-dependent.

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 front-loaded sentence delivering the resource and its most decision-relevant element (the blocking hold condition). Nothing extraneous, and the key term is placed at the end for emphasis without burying the 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?

With zero parameters and an output schema present, the description needn't explain return values, and it correctly stays high-level. It is nearly complete; the only gap is workflow placement — when in the previs pipeline an agent should pull this checklist relative to validate_gate and validate_human_greenlight.

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 takes zero parameters, which is the baseline-4 case; there is nothing for the description to disambiguate. Not scored higher because the description does not say whether the checklist is global or scoped to an implicit current project 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?

Specific verb ("Get") plus a named resource ("complete final delivery checklist") and a summary of its contents. It partially differentiates from near-siblings like get_gate_criteria and validate_gate by emphasizing the HOLD CONDITION that blocks Seedance generation, though it never names those siblings 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?

Usage is only implied: the reader infers this should be consulted before delivery/Seedance generation. There is no explicit "call this when..." statement, no exclusion of alternatives such as get_gate_criteria or validate_gate, and no ordering guidance despite the sibling set being dense with gate-related 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?

With no annotations, the description carries the full burden. It does usefully clarify that the tool emits specifications/settings rather than rendering media, and it enumerates what the spec covers. However it never states side effects: whether files are written, whether the scene is modified, or whether the call is read-only — a significant omission for a tool with zero annotation coverage.

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 tightly written sentences with the purpose front-loaded and no filler. Slight loss only because the second sentence lists spec contents without connecting them to the parameters or to output behavior.

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 values need not be explained. But with no annotations and 0% schema coverage on two parameters, the description should still say whether the tool is read-only versus file-writing and what fps/resolution control — neither is covered, leaving real gaps for a preview-spec generation 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% for both parameters, and the description does not mention fps or resolution at all, so it provides no compensating meaning. The parameter names and defaults are largely self-explanatory, which keeps this from scoring lower, but the description adds nothing about valid ranges, format of 'resolution', or how these values affect the generated spec.

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

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

The description names a specific verb and resource: generating viewport/playblast review specifications for director approval, plus the content of those specs (Solid/Clay shading, burn-in overlays, real-time playback). It is clear what is produced, though jargon like 'viewport exhibition' is unusual and it does not differentiate itself from siblings such as record_previs_review or list_previs_review_scenes.

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 'for human director approval' implies the workflow context in which this tool is used, but there is no explicit when-to-use, when-not-to-use, or named alternative among the many review-related sibling tools. An agent must infer that this precedes director sign-off rather than being told so.

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

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

With no annotations, the description carries the full burden and does so well: 'only reads the catalog and never opens Blender or writes scenes' is an explicit side-effect guarantee, plus asset caveats (61 bones, matte ID colors, GLB loses native IK, not a verified 1:1 scan) that matter for reuse decisions. The gap is that 'the supplied helper' is referenced but never named or described.

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 purpose and scope land in the first sentence, followed by strictly supporting facts (rig requirement, fallback limitation, usage rule, side-effect guarantee). No sentence merely restates the name, and the disclaimer is placed where it matters rather than padding the opening.

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-param read with no output schema and no annotations, the description covers purpose, constraints, side effects, and asset caveats. It is slightly thin on what is actually returned (entry names, paths, or color values) and does not name the helper it tells the agent to 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 tool takes zero parameters, so the baseline of 4 applies; there is nothing for the description to disambiguate at the argument level.

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 states a specific verb and resource: 'Locate the five saved Body-kun DX reference mannequins for reuse,' so an agent immediately knows this is a catalog-lookup, not a scene operation. It does not differentiate itself from rig-related siblings such as get_rig_constraints or get_skeleton_blueprint, which a reader might plausibly confuse it with.

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?

Usage is directive and concrete: 'Append with the supplied helper; never rebuild the mannequin per scene' rules out an obvious wrong approach. The Blender 5.1+ vs GLB-fallback split is a real selection criterion, though neither the helper nor a comparison with rig-blueprint siblings is named.

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 it discloses little: it never states this is a read-only lookup, what happens if gate_number is outside 1–7 or non-integer, or whether results are static versus dependent on project state. The one piece of behavioral context it does offer – that the return is the 'exact' keys and descriptions – is thin and largely covered by 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?

A single front-loaded sentence with zero filler. It is arguably under-specified rather than verbose, which is a completeness problem rather than a structure problem.

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 existence of an output schema means the description needn't describe return values, and for a one-parameter lookup this is close to adequate. However, with no annotations and 0% parameter coverage, the description should still say what happens for out-of-range gates and how it relates to validate_gate, both of which are 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% and the schema declares gate_number only as an unconstrained integer, so the description's 'Gate 1–7' usefully supplies the valid range that the schema omits. Beyond that range hint, it adds no format, default, or error semantics for the single parameter.

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 ('Return') and resource ('exact answer keys and descriptions') scoped to 'Gate 1–7', so an agent knows exactly what it retrieves. It doesn't explicitly distinguish itself from the sibling 'validate_gate', which is the obvious near-neighbor, so it falls short of a 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?

There is no when-to-use guidance, no mention of prerequisites, and no reference to the natural alternative (validate_gate) or to the sequencing of fetching criteria before validating a gate. The only usage signal is implicit in the purpose statement.

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. It usefully states what is returned (stride cycle, ground contact rules, center of mass behavior, common animation errors, tail dynamics) and that unsupported patterns are reported rather than substituted. However, it does not explicitly describe safety, side effects, permissions, or other operational constraints.

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 front-loaded with the core purpose and then structured into Args and Returns. It is efficient, though the Args block partly repeats parameter names that already appear in the schema.

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 small and the description covers purpose, parameter semantics, output contents, and error-like behavior for unsupported gait patterns. Since an output schema exists, it need not explain return values in full, but it does. The main missing context is when to choose this tool versus nearby constraint or blueprint 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%, so the description must compensate. It does so by documenting all three parameters, including allowed leg_type values, the meaning of has_tail, and conditional gait values for quadrupeds versus bipeds.

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 gives a specific verb and resource: get locomotion physics constraints for a given leg type and gait. It is clearly distinct from the other tools in this domain, but it does not explicitly name or differentiate against nearby siblings like get_rig_constraints or get_skeleton_blueprint.

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?

Usage is implied by the parameter-specific contexts: leg type and gait determine the constraints. The note that unsupported patterns are reported rather than substituted clarifies behavior, but there is no explicit when-to-use/when-not-to-use guidance or comparison with alternative 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 burden. It discloses the payload's contents (instructions plus gate criteria), implying a read-only lookup, but does not state side effects, error behavior for out-of-range phases, or whether it is safe/idempotent beyond the 'Get' verb.

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 compact sentences, front-loaded with the verb and resource, with no filler. The trailing 'including the gate criteria...' clause earns its place by describing the return payload, though it slightly blurs the boundary with get_gate_criteria.

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 detail needn't be spelled out, and the description covers the valid input domain and the main content returned. The remaining gap is the lack of any relation to the sibling gate/validation 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 single parameter has no schema description, so the description is the only source of meaning. It does compensate meaningfully by declaring the valid domain as phases 1–8, which the schema would otherwise leave as an unconstrained integer; it omits what happens outside that range.

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 ('Get') and resource ('detailed instructions for a specific phase'), plus the scope (phases 1–8 of the Previs Director pipeline). It is clearly distinguishable from validate_gate, though it does not explicitly distinguish itself from the sibling get_gate_criteria, which its mention of 'gate criteria' overlaps with.

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?

Usage is implied by the phrasing 'a specific phase (1–8) of the Previs Director pipeline', which tells the agent the context in which to reach for it. But there is no explicit when/when-not guidance and no routing versus the nearby get_gate_criteria or validate_gate siblings, which look closely related.

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 already declare readOnlyHint=true and openWorldHint=false, so the safety profile is covered. The description adds the useful clarification that it will not trigger scene execution, which guards against a plausible wrong expectation, but says nothing about the nature or size of the returned help content.

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, and the scope limitation is stated immediately after the purpose. Only minor cost is the vague 'Orientação assistida' phrasing occupying the front-loaded position.

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 no parameters and no output schema, the description carries the burden of explaining what the help actually contains and how it differs from the many other guidance-style siblings. It does not do that, leaving the agent able to call it safely but not confidently.

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 takes zero parameters and the input schema is an empty object, so there is nothing for the description to disambiguate. 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?

It indicates the tool returns guidance about how MCP PREVIS-DIRECTOR works and adds the negative scope 'Não executa cenas', but 'Orientação assistida' is vague about what the agent actually gets back (documentation text? an overview?). It never differentiates itself from closely related siblings such as get_previs_system_prompt or get_phase_instructions.

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 one exclusion ('does not execute scenes') but no positive when-to-use signal, no mention of when the agent should prefer this over get_previs_system_prompt, get_previs_update_notes, or get_phase_instructions. Usage must be inferred entirely from the name.

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 exist, so the description carries the full burden and it does substantial work: it discloses that the default path performs a live re-inspection of the target, that stale approvals are detected, that historical results are explicitly labeled, and that a fresh check fails rather than silently reporting stale approvals. Missing are permission/auth needs, cost/latency of the live check, and what the response contains.

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?

Front-loaded with the core action, then the default behavior, then the refresh=False branch, and finally the failure caveat. Three short units, each carrying information. The final sentence is slightly wordy but earns its place by preventing a wrong assumption about stale approvals.

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 tool with no annotations, no output schema, and 0% schema description coverage, the description covers refresh semantics and failure modes well but leaves the agent guessing about project_id and about what 'revision and review history' actually returns. Adequate but with a clear gap on the required parameter.

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 'refresh' parameter thoroughly (default, historical labeling, failure behavior), but says nothing about 'project_id' — where it comes from, its format, or whether it must be an existing Previs project. Half the parameters are effectively undocumented.

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: 'Return revision and review history' for a project. That is concrete enough to separate it from siblings like get_previs_revision or get_previs_review_notes in spirit, but it never names those siblings, and the tool name 'project_status' does not obviously map to 'revision and review history', so a small ambiguity remains.

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

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

Gives a clear default ('by default re-inspect the actual target') and an explicit alternative mode ('refresh=False returns the last recorded state'). It also states the consequence of that choice when the target is unavailable. It stops short of saying when to prefer the historical mode or naming sibling tools that also surface review data.

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 exist, so the description carries the full burden and does well: it discloses that notes are untrusted user-authored content, merely attributed rather than authenticated approval, and that resolved notes do not approve a gate or prove the .blend was fixed. Return shape details (pagination, size) remain unstated.

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?

Front-loads the action and purpose, then layers the trust caveats. Every sentence carries information; only the gate/approval sentence is slightly verbose relative to the rest.

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?

A read-only tool with no output schema and no annotations, where the description still covers trust level, semantics of the returned notes, snapshot identification, and format choice. Sufficient for correct invocation; only return-value shape is left implicit.

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%, but the prose compensates for both parameters: 'format is json or markdown' documents the format param, and 'Use the scene SHA-256 to identify the exact snapshot' clarifies that scene_id is a content hash rather than a name. Minor gap: allowed format values aren't enumerated as an actual schema enum.

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?

Opens with a specific verb+resource: 'Read the director's spatial/frame notes for the next previs pass.' That distinguishes it from the write-side siblings (submit_director_feedback, record_previs_review), though it never names an alternative 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?

Timing is implied ('for the next previs pass') and it tells the agent to use the scene SHA-256 to target a snapshot, but there is no explicit when-to-use/when-not or pointer to a sibling for submitting vs reading notes.

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. 'Read' and 'immutable' hint at a safe, non-mutating operation, which is useful, but there is no disclosure of permissions required, what the returned evidence contains, error behavior, or whether the result is paginated or cached.

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 single sentence is front-loaded and contains no filler, which is structurally sound. But the brevity comes at the cost of clarity, since the key resource term is left undefined.

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

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

Given no annotations, no output schema, and zero parameter descriptions, the definition is too thin for a domain-specific read tool. An agent cannot confidently determine what 'inspection evidence' is or how to correctly supply the IDs from this description alone.

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% for two required parameters. The description only implies that a project and a revision identify the target, without explaining formats, where to source IDs, or the relationship between project_id and revision_id. It does not compensate for the schema gap.

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

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

The description names a verb ('Read') and a resource ('immutable inspection evidence') scoped to a project revision, so the broad intent is clear. However, 'inspection evidence' is an undefined domain term, and the description does not distinguish this tool from siblings like get_previs_review_notes, inspect_previs_scene, or list_previs_review_scenes. This is a vague purpose rather than a specific one.

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 about when to call this tool, when not to, or which sibling to use instead. With many related read tools in the sibling list, the absence of routing guidance leaves the agent to infer usage entirely.

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 behavioral burden. "Get" and "Returns the full prompt text" imply a safe read, but the description does not explicitly state read-only behavior, side effects, or any operational constraints.

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 tight sentences, front-loaded with the core action and followed by the concrete use context. Every sentence adds useful information without repetition or fluff.

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 getter with an output schema, the description supplies enough context to call it correctly: what it returns and how the returned prompt is meant to be used. The main remaining gap is explicit read-only/no-side-effect disclosure, which annotations would normally carry but are absent here.

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 baseline is 4. No parameter semantics are needed, and the description correctly does not invent any.

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 clear verb+resource: "Get the complete Previs Director V2 system prompt." It distinguishes the content as the full director prompt, but does not explicitly contrast this with sibling tools like get_previs_help or get_phase_instructions.

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 clear usage context: the prompt is "ready to inject into a Blender AI session" with examples including Blender GPT, Blender MCP, or manual paste. It does not state when to avoid this tool or how it differs from adjacent prompt/help 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?

Annotations already declare readOnlyHint=true and openWorldHint=true, so safety baseline is covered. The description adds one genuinely valuable behavioral note — "Notas externas são dados" warns that externally sourced notes should be treated as data rather than instructions — but says nothing about what content to expect or how it relates to the two modes.

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 very short sentences, front-loaded with the action and followed by the security caveat. There is no padding, though the phrasing is vague enough that the brevity costs clarity rather than buying it.

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 read-only tool with one enum parameter and no output schema, the description should at least indicate the shape of the notes (changelog items? external text?) and which mode yields which. It gestures at both but leaves the agent without enough to call confidently, and the description is in Portuguese while the surrounding tooling and siblings are in English, which can impede matching.

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 single parameter is an enum (installed/available), so the description must carry the meaning. It does so implicitly by contrasting "mudanças disponíveis" (available) with "última atualização concluída" (last completed/installed), which maps onto the two enum values, though the mapping is not spelled out explicitly.

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 gives a verb plus resource ("Lista mudanças" / list changes), but it conflates two different things: available changes versus notes from the last completed update, without saying which is returned when. It does not distinguish itself from close siblings such as check_previs_updates, prepare_previs_update, or get_previs_revision, so an agent cannot easily tell them apart from text alone.

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 explicit statement of when to call this versus check_previs_updates or get_previs_revision, which are the obvious alternatives in the sibling list. The reader is left to infer usage entirely from the tool name and the ambiguous 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 behavioral burden. Calling it 'Get' plus returning 'constraints and rules' reasonably signals a read-only lookup, and it adds useful domain framing ('organic imperfection rules'), but it says nothing about permissions, caching, or failure behavior for an invalid type.

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 action and scope, then the constraint-relevant enumeration. 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?

An output schema exists, so return values needn't be explained, and the description supplies the critical input vocabulary the schema omits. Complete enough for a simple getter; only minor validation details are absent.

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

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

Schema coverage is 0% and the single rig_type parameter has no documented enum in the schema. The description compensates by enumerating all ten valid values, which is exactly the kind of meaning the schema lacks, though it does not clarify case sensitivity or rejection behavior for other strings.

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 ('Get the physical constraints and organic imperfection rules for a specific camera rig type'), which is unambiguous on its own. It does not explicitly distinguish itself from analogous siblings such as get_locomotion_constraints or get_skeleton_blueprint, so it falls short of a 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?

The description implies usage via 'for a specific camera rig type', making the intended call context inferable. However, it offers no when-to-use/when-not-to-use guidance and names no alternatives among the many sibling 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?

With no annotations at all, the description must carry the full behavioral burden. It discloses the return contents (bone hierarchy, center of mass, ground contact), which implies a pure read/lookup with no side effects, but never says so outright and says nothing about defaults or how the recommendation is derived. Useful but not complete for an annotation-free 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 one-line purpose is front-loaded, followed by a compact Args list and a single return sentence — no filler. The Google-style docstring formatting is slightly formal for a tool description but costs little and improves scannability.

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?

A four-parameter tool with an output schema; the description covers all parameters with concrete value sets, so it is nearly complete. Remaining gaps are the parameter defaults/interaction (tail_length vs. has_tail) and its position relative to sibling rig/locomotion 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 there are no enums in the schema, so the description is doing real work: it enumerates the allowed character_type values, the three leg_type values, and even quantifies tail_length thresholds (<20%, 20–60%, >60% body). It omits the schema defaults (has_tail=false, tail_length='none', leg_type='plantigrade') and any note that tail_length is only meaningful when has_tail is true.

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 leads with a specific verb+resource: 'Get the recommended physics skeleton bone chain for a character,' and names the concrete outputs (bone hierarchy, center of mass, ground contact). It does not explicitly distinguish itself from adjacent siblings like get_rig_constraints or classify_character, so it stops short of a 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?

Usage is only implied — an agent can infer this is the lookup to call when it needs bone chains for a character type, but there is no explicit when-to-use, when-not-to-use, or routing to alternatives such as get_rig_constraints or classify_character. No prerequisites or ordering guidance are 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?

With no annotations, the description carries the full load and discloses meaningful traits: imports are immutable, each import produces a distinct snapshot, old annotations never transfer silently, and Blender export runs with automatic Python disabled and without saving/rendering the original. It does not state permissions, failure modes, or idempotency 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?

Front-loaded with the core action, then constraint paragraphs. Every sentence conveys a distinct constraint (path base, export safety, local-only, snapshot uniqueness). Slightly dense but 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/import tool with no annotations and no output schema, the description omits what is returned (e.g., how the new snapshot is identified for later annotation), which matters for chaining. It also leaves the 'name' parameter unexplained.

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 only adds semantics for one of the two parameters: scene_path must be relative to PREVIS_WORKSPACE_DIR. The optional 'name' parameter is neither explained in the schema nor in the description, leaving part of the surface undocumented.

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: import a local .blend/.glb as an immutable Review Room snapshot. This is clearly distinguished from sibling tools like list_previs_review_scenes (listing) and inspect_previs_scene (reading an existing 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?

Explicitly scopes to LOCAL scenes and warns that a remote scene must first have its exported GLB transferred ('Never substitute local data for a remote project'). It does not name the concrete sibling tool to use for the remote path, so guidance is clear but not fully routed.

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

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

With no annotations, the description carries the burden and does well: it states the work happens in background Blender against the project's verified target, that no scene is saved or rendered, and that any change to scene, dependency, playblast or inspection configuration creates a new revision and invalidates prior approvals. It omits error behavior and whether the run can be long-running or needs specific auth.

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?

Front-loads the core action in the first sentence and keeps the whole thing to four compact sentences. The third and fourth sentences are information-dense but earn their place; only the enumeration of collected data is slightly run-on.

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 six-parameter inspection tool with no annotations and no output schema, the description covers the read-only nature and revision side effects well but leaves parameter meanings and any hint of return shape or failure modes undocumented. It is adequate to start 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%, so the description must compensate and it only partly does: 'Default samples: first/middle/last frame' explains the frames parameter, and 'distances from contact objects to the ground' implicitly covers contact_objects and ground_object. The collision_objects and playblast_path parameters receive no explanation, leaving meaningful 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?

Opens with a specific verb and resource: reads the saved .blend in background Blender and enumerates exactly what it collects (cameras, object scale, keyframes, evaluated transforms, intersections, ground distances). It is clearly not a mutation or audit tool, though it never explicitly distinguishes itself from siblings like audit_camera or audit_action.

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?

Implies usage via the default sampling behavior (first/middle/last frame) and warns that contact/intersection findings require human interpretation, which hints at the tool's verification role. However, there is no explicit when-to-use statement, no exclusions, and no pointer to an alternative sibling for related checks.

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

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

With no annotations, the description carries the burden and does disclose two non-obvious traits: the snapshots are immutable, and the backing Review Room is a separately started local companion that an MCP connection does not launch. It omits what happens when the room is not running (error vs empty list) and whether results are capped.

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 lines, front-loaded with what is listed and what is returned, followed by the one operational caveat an agent needs. No filler or restated schema 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?

For a zero-parameter list tool with no output schema, the description covers purpose, return shape (URLs) and the startup prerequisite. The remaining gap is failure behavior when the Review Room is down, which an agent would want before calling it in a fresh session.

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 takes zero parameters, so there is nothing for the description to disambiguate; baseline applies. The description adds no parameter-level noise, which is correct 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 uses a specific verb ("List") plus a concrete resource ("immutable 3D snapshots in the local Review Room") and even states part of the return payload (browser URLs). It is clearly distinct from the mutating sibling import_previs_review_scene, though it never names a sibling 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?

Usage is only implied: an agent can infer this is the discovery step before importing or recording review notes, but the description never says when to call it versus import_previs_review_scene or get_previs_review_notes. Its one concrete guideline is a precondition (the Review Room must already be running) rather than a use-case condition.

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 declare readOnlyHint=true, and the description is consistent, reinforcing that nothing is installed. It adds real behavioral context beyond the annotations: the consent protocol, the invalidity of silence/other-version approval, and the rule to only announce success after the plan finishes. What the plan actually contains is not 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 core no-install constraint is front-loaded, but the second sentence is a run-on packing consent conditions and the third is a post-call instruction that sits outside the tool's scope. Dense, but structure could be tightened.

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?

There is no output schema, so the description reasonably should say more about the returned plan; it instead focuses on the consent workflow and success announcement, which is the higher-risk part for a read-only preparation step. Adequate but leaves the return value opaque.

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 carry the parameters, and it does define the two that exist: approved requires human consent for the presented commit, and target_sha is the commit that consent must reference. It does not cover a null target_sha case or the default false behavior.

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 concretely that it returns a plan for the host and explicitly does not install, which separates it from a hypothetical installer. However, it never names the sibling it pairs with (e.g., check_previs_updates or get_previs_update_notes), so differentiation is inferred rather than stated.

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

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

Gives a clear, enforceable rule for setting approved=true: explicit human consent after the question 'Tem atualização, posso instalar?' for the exact target_sha presented, and it rules out silence or approval of another version. It stops short of saying when to call this versus check_previs_updates.

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

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

With no annotations, the description carries the full burden and does well: it discloses that the record is caller-attested rather than verified identity, and that replacing an earlier review invalidates dependent approvals — a real side effect an agent must know. It does not cover failure behavior, idempotency, or what the call returns.

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 sentences, front-loaded with the action and scoping rule, and each carries a distinct constraint (attestation, gate 7, ordering, invalidation, sibling role). Some phrasing is terse to the point of being cryptic, but there is 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 7-parameter mutation with no annotations, no output schema and zero schema description coverage, the description supplies good policy context but leaves the largest ambiguity — the shape and required keys of 'answers' — plus return/error behavior undocumented. Adequate to understand intent, insufficient to call correctly without guessing.

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% across 7 parameters, so the description must compensate and only partly does. It hints at revision_id ('rechecking the actual scene/playblast revision'), reviewer ('never invent a reviewer'), approval_quote ('exact human statement GREENLIGHT APROVADO') and gate_number ('Gate 7'), but says nothing about project_id, notes, or crucially the required nested 'answers' boolean map, whose keys an agent cannot infer.

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 ('Persist a review') and adds a strong qualifier ('only after rechecking the actual scene/playblast revision'). It distinguishes itself from one sibling by noting that 'Original validate_gate remains an unrecorded checklist', though it does not contrast with validate_human_greenlight or get_previs_review_notes.

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

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

Gives clear preconditions: earlier gates must be approved on this revision, Gate 7 requires a linked playblast plus the exact statement 'GREENLIGHT APROVADO', and only human statements actually received may be recorded. It stops short of naming the alternative tool for the unrecorded checklist case beyond pointing at validate_gate's role.

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 disclose the most important side effect: current approvals are invalidated while history is preserved. It says nothing about permissions, whether the change is reversible, what 'mode' controls, or what the tool returns.

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

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

One short sentence with no padding, but it leads with a usage caution rather than what the tool does, and the brevity reads as under-specification rather than efficiency for a mutation with three bare parameters.

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?

A state-changing tool with no annotations, no output schema, zero parameter documentation and an undefined 'target' leaves too much for an agent to safely invoke; the approval-invalidation note is the only substantive content.

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 all three parameters (mode, pod_id, project_id) are undocumented titles only. The description adds no parameter meaning at all, not even which values mode accepts or when pod_id should be supplied, so it fails to compensate for the coverage gap.

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

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

States a verb ('Change') and an object ('the target'), but 'target' is never defined and the tool name suggests a previs project target without ever saying what is being set. It does not distinguish itself from nearby siblings such as choose_execution_mode or verify_runpod_target, so an agent must infer the relationship.

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 clause 'only when requested' implies a usage restriction (do not do this proactively), which is real guidance, but it names no alternatives and no preconditions such as verifying the target exists or the project state required.

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

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

With no annotations, the description carries the burden and does reasonably well: it discloses scope (host/container of the MCP, not RunPod), the failure semantics ('a false ready includes missing checks and the available diagnostic details'), and the separation between verification and service state. It omits whether the run is read-only, how long it takes, or what a passing result contains.

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, front-loaded with the core action followed by the profile enumeration and two behavioral caveats. The profile list is long but genuinely informative and cannot be trimmed without losing parameter meaning.

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-optional-parameter diagnostic tool with no output schema and no annotations, the description covers scope, failure output, and parameter effects adequately. Minor gaps remain around runtime cost, whether the operation mutates anything, and what a true/'ready' result contains.

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, and it does: it enumerates the eight valid profile values (local, base, z-image, minimax-h3-reference, minimax-h3-full, ltx-cuda, previs, full) and explains require_service's effect on whether service state is checked. It still does not explain what distinguishes each profile or what 'local' means as the default.

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 target: 'Run the configured verifier on the host/container running this MCP.' The explicit 'It does not connect to RunPod' carves out a boundary against the sibling verify_runpod_target, though the vague term 'configured verifier' and the undefined 'ready' concept keep it short of a 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?

Usage is only implied: the RunPod disclaimer hints that verify_runpod_target covers remote targets, and 'service state is separate unless require_service is true' hints at when to flip that flag. There is no explicit 'use this before X' or 'do not use this to Y' guidance, so the agent must infer the 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?

No annotations are provided, so the description carries the full burden. It does disclose real behavior beyond the schema: output is localized, it will not restart or break approved blocking, and it prescribes exact F-Curve/timing values. It omits whether the submission mutates project state, whether it must follow validate_human_greenlight, or whether repeated calls are idempotent.

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 two-sentence summary is front-loaded with the core action and its key guarantee, followed by a compact args block. Given zero schema description coverage, the per-parameter lines are not padding but the only parameter documentation available, so 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?

The output schema exists, so return values need not be explained. Still, for a submission tool whose output drives downstream modification work, the description leaves out state effects, sequencing relative to validate_gate/validate_human_greenlight, and the boundary with classify_error. Adequate to call correctly, not adequate to call at the right moment.

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% – every property carries only a split title – so the description must compensate, and it does with concrete format examples for all four parameters ('Frames 45-60', 'CHAR_Hero'/'CAM_Main'/'PROP_Door', defect and corrective-action samples). It stops short of stating constraint rules, such as whether frame_range must fall inside an approved blocking range or which subject naming conventions are valid.

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?

Names a specific verb and resource: process director feedback and produce a localized 'Surgical Modification Order' with F-Curve/timing adjustments. That is far more than a restatement of the name. However, it never distinguishes itself from the sibling classify_error, which the 'Classifies error severity' clause overlaps with, so an agent cannot tell from the description alone which one owns severity classification.

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 statement of when to call this versus alternatives, no prerequisites, and no exclusions. The phrase 'without restarting or breaking approved blocking' is a behavioral constraint on the output, not guidance on when to invoke the tool. With sibling tools like classify_error and validate_gate nearby, routing guidance is genuinely needed and 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 does the heavy lifting: it discloses the gate range (1–7), the prerequisite dependency on get_gate_criteria, and the outcome shape (PASS or FAIL with remediation details). It does not say whether validation is stateless or records the result against the project, which is the main remaining 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?

Core instruction and constraint are front-loaded in the first two sentences; the example follows as supporting material. The example is long but earns its place by demonstrating the nested dict format that the schema cannot express.

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?

Covers the nested-object parameter, the sibling dependency, and the return verdicts, and an output schema exists so return values need not be detailed further. Minor gap: no statement about out-of-range gate numbers or whether a failed validation has side effects.

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 carries the burden and does so well: gate_number constrained to 1–7, answers defined as a dict of criterion_key to True/False keyed by get_gate_criteria output. The worked example makes the nested-object shape unambiguous.

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 ("Validate a gate checkpoint") and immediately scopes it to gate numbers 1–7 with a criteria-keyed boolean payload. It is clearly distinguishable from the sibling get_gate_criteria, which supplies the keys rather than validating 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?

Explicitly directs the agent to obtain keys from get_gate_criteria(gate_number) using the exact keys, which establishes the required call ordering against the sibling. It lacks an explicit "do not use when..." clause or note about whether this can be run before criteria are fetched.

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 disclose a meaningful trait: it "records the caller's report of explicit director sign-off" rather than verifying sign-off itself, which tells the agent this is attestation capture. It does not say what happens when a boolean is false (gate blocked, error raised, partial pass) or whether recorded results are idempotent.

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 lines with the gate identity front-loaded and the downstream consequence in the second sentence. Every clause carries information; slightly tighter phrasing could fold the two sentences together, but there is 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?

An output schema exists, so return values are covered by structured data. For a 7-required-boolean gate validator, the description supplies the missing pieces: which gate it is, that it captures rather than verifies sign-off, and what it gates. Ample at this complexity level.

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 7 undocumented booleans. It partially does by grouping them as "4 human review axes" plus "explicit director sign-off," but it never enumerates which parameters map to which axis, and exhibition_specs_met and surgical_orders_resolved are never mentioned at all.

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: "Execute the Gate 7 (Human Greenlight Gate) review" and names the gate explicitly. It also states the downstream effect (permitting final export or Seedance generation). It does not explicitly distinguish itself from the sibling validate_gate, which handles generic gate validation, so it falls short of a 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?

The phrase "before permitting final export or Seedance generation" implies the workflow position where this tool belongs. However, there is no explicit when-to-use/when-not guidance and no mention of validate_gate as the alternative for non-human gates, leaving the agent to infer the 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, the description must carry the full load. It usefully discloses that credentials come from Docker .env, that the operation is non-mutating on RunPod resources, and that no local fallback applies to remote projects. It does not describe what a failed verification looks like, how errors surface, or whether the SSH check is time-limited, which matters for a long-running remote probe.

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, front-loaded with the verb and the checks performed, followed by scope negatives. No padding, though the fragmentary negative sentences read as bullets and could be tightened into a single scope clause.

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 verification tool with one parameter, no output schema and no annotations, the description covers what is checked and what is not mutated, but omits the result contract (pass/fail signal, diagnostic detail on failure) and the pod_id input, leaving an agent unable to predict 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?

Schema description coverage is 0% and the single parameter pod_id is documented nowhere. The description says 'an existing Pod' but never states that pod_id is a RunPod pod identifier, what format it takes, or where to find it, so it fails to compensate for the schema gap.

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

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

States a specific verb ('Verify') and resource ('an existing Pod') and enumerates the three checks performed: RunPod API reachability, pinned SSH identity, and actual Blender availability. It does not name or contrast itself with nearby siblings such as startup_verification or choose_execution_mode, so an agent must infer the boundary.

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?

'Verify an existing Pod' implies the caller already has a pod and wants a readiness check, and 'Does not create, start, stop or change resources' rules out lifecycle operations. But there is no explicit statement of when to call this instead of startup_verification or choose_execution_mode, and no stated prerequisites.

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