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

No annotations are provided, and the description does not disclose behavioral traits such as side effects, permissions, idempotency, or error conditions. It only describes the basic action.

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 sentences, front-loading the main action, and every word earns its place. No wasted information.

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

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

Given 5 parameters, no output schema, and low schema coverage, the description is incomplete. It lacks behavior details, parameter explanations, and return value information.

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

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

With only 20% schema coverage, the description should compensate. It explains the 'mcp' parameter (optional MCP wiring) but does not clarify 'path', 'force', 'target', or 'dry_run'. Value added is minimal.

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

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

The description states the tool installs pcq agent runtime assets, listing specific files (AGENTS.md, CLAUDE.md, SKILL.md), and distinguishes it from sibling tools that deal with status, plans, experiments, etc.

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

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

The description implies usage for setting up pcq agent assets but does not explicitly state when to use vs alternatives or provide any exclusions. It is implied by the tool's nature.

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

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

With no annotations provided, the description carries full burden. It explicitly states the tool is read-only, which is critical for safety. It also lists the asset statuses it reports, but does not describe output format or any additional constraints (e.g., permissions). Adequate for a simple inspection tool.

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

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

The description is a single sentence that efficiently conveys the tool's purpose and key behavioral trait (read-only). No unnecessary words.

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

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

For a tool with two optional parameters, no output schema, and no annotations, the description covers the essential purpose and safety. It could benefit from a brief mention of parameter roles or typical usage, but it is sufficiently complete for simple status checks.

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

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

Schema description coverage is 0% and the description does not mention the two parameters (path and target) or their meanings. The description adds no value beyond the schema; agents are left to infer from parameter names alone. This is a significant gap.

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

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

The description clearly states the tool inspects pcq agent runtime asset status, listing specific statuses (installed/missing/stale/divergent/unmanaged) and emphasizing read-only. This distinguishes it from sibling tools like agent_install or apply_plan which modify state.

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 specifies 'without writing. Read-only,' which clearly indicates when to use the tool (for inspection) and when not to (for modifications). However, it does not explicitly name alternative tools for writing, leaving some inference needed from the sibling list.

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

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

With no annotations, the description fully bears transparency. It discloses that the tool modifies only cq.yaml.configs, records provenance under .pcq/plans/, and returns rejected envelopes with specific reasons on invalid input. This covers core behavioral traits, though it omits information about idempotency or whether the operation is reversible.

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

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

The description is extremely concise—two sentences covering action, scope, provenance, and error behavior. Every sentence adds value without redundancy or extraneous detail.

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

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

Given the tool's complexity (nested object, no output schema), the description covers action and error responses but lacks success output details, prerequisites (e.g., project must exist), and integration with sibling tools like init_experiment. It is minimally complete but leaves gaps for an agent.

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 67% (path parameter lacks description). The tool description does not clarify the 'path' parameter's purpose or format, nor does it add semantic information beyond the schema's detailed 'plan' parameter description. The description's mention of error responses does not compensate for missing parameter guidance.

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

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

The description clearly states the tool applies an ExperimentPlan to a project, specifies the scope (modifies cq.yaml.configs only, never train.py), and distinguishes the action from generic 'plan' operations. The verb 'apply' combined with the resource 'ExperimentPlan' and the boundary 'never train.py' provides precise purpose, though it doesn't explicitly differentiate from the sibling 'apply_planset'.

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

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

The description offers no explicit guidance on when to use this tool versus alternatives like apply_planset, run_experiment, or validate_project. It implies usage for single plan application but lacks exclusion criteria or context about prerequisites (e.g., project must be initialized).

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?

Discloses creation of directories and error behavior, but lacks details on side effects (overwriting, auth needs, destructive actions) since no annotations exist. Partial transparency.

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

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

Two sentences covering main action and error scenario. No redundant information; every word serves a 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?

Lacks description of successful return value (e.g., list of created directories) and side effect transparency. Given nested objects and no output schema, more detail is needed for full understanding.

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?

Adds meaningful descriptions for 'planset' (example, required fields), 'planset_file' (path), and 'output_pattern' (pattern format). However, 'path' and 'force' lack extra context beyond defaults.

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

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

Description uses specific verb 'Expand' and resource 'ExperimentPlanSet members', clearly stating it creates output directories with config and provenance. It also distinguishes from sibling 'apply_plan' by focusing on plan sets.

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?

Description implies usage for expanding plansets but does not explicitly state when to use this over alternatives like 'apply_plan' or under what conditions (e.g., multiple plans). No exclusions or prerequisites mentioned.

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 states read-only behavior, but lacks details on side effects, permissions, or data limits. This is adequate but not rich.

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

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

One sentence plus 'Read-only' - extremely concise, front-loaded with verb 'Diff', no wasted words.

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

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

Lists return values and read-only nature. Without an output schema, this helps. But lacks usage context (e.g., when to diff vs describe). Still fairly complete for a simple diff 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 covers 100% of parameters with descriptions already matching the tool's 'path to run_record or output dir'. The description adds minimal extra insight beyond grouping them as 'two RunRecords'.

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

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

The description clearly states the tool diffs two RunRecords, listing specific return values (metric deltas, config changes, lineage relation, decision_facts). This distinguishes it from siblings like describe_run or lineage_chain.

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

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

No guidance on when to use this tool versus alternatives (e.g., describe_run for single runs, lineage_chain for lineage). The description only states 'Read-only' without excluding contexts.

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 states 'Read-only' which covers safety, but it does not disclose whether the tool works on any run, requires a specific run state, or has performance considerations. The listed contents add some value.

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 sentences, front-loads the core purpose, and avoids unnecessary words. Every sentence contributes 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?

Given the minimal input schema (1 optional param) and no output schema, the description covers the output contents but misses contextual details like how the run is identified or the role of output_dir. It is adequate but not comprehensive.

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

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

The only parameter, output_dir, is not mentioned in the description. Schema description coverage is 0%, and the description adds no meaning beyond the schema's default value. The agent must guess the parameter's purpose.

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

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

The description clearly states the tool returns a compact, decision-facts oriented summary of a RunRecord with specific contents (metrics, validation status, lineage, artifact counts, decision_facts). It identifies the resource and the nature of the output, distinguishing it from mutation tools like run_experiment.

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

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

The description implies the tool is used to get a summary, but it does not provide explicit guidance on when to use this tool versus alternatives like compare_runs or validate_run. No exclusions or prerequisites are mentioned.

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

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

With no annotations, the description bears full weight for behavioral disclosure. It mentions ancestor walking and writing to output_dir, but lacks details on overwrite behavior, directory creation, permissions, or side effects on run state.

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 sentences, front-loading the primary action and adding a behavioral detail in the second. No wasted words.

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

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

Given no output schema and no annotations, the description is incomplete. It does not explain what the generated files contain, the impact on the run state, or any prerequisites, leaving significant gaps for a tool that finalizes a run.

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 has 0% coverage; the description explains output_dir and implicitly project_root, but does not address the status parameter (enum with default). It adds meaning beyond the schema for two parameters but not for all three.

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

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

The description clearly specifies the tool's action: generating run_record.json and validation_report.json into an output directory. It distinguishes from siblings by stating its specific output and behavior of walking ancestors to find project root.

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

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

The description does not provide guidance on when to use this tool versus siblings like validate_run or describe_run. It states what it does but not when it is appropriate or when it is not.

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, and the description does not disclose side effects such as whether existing files are overwritten, required directory state, or permission needs. The `force` parameter hints at destructive behavior but is not explained.

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

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

The description is a single sentence that efficiently conveys the tool's purpose and optional elements. It is front-loaded and contains no redundant information, though slightly more structure could improve readability.

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 5 parameters and no output schema, the description covers the main action and output files but lacks details like behavior when directory exists, overwrite rules, or post-creation steps. This is adequate for a simple scaffold tool but incomplete for complex use.

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

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

Schema coverage is 60%, with descriptions for name, force, output, and with_pyproject. The description adds context about scaffolding files, but the `agent` parameter lacks description both in schema and description, limiting added value.

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

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

The description clearly states it scaffolds a CQ-runnable experiment, listing specific files (cq.yaml, train.py, optionally pyproject.toml and agent runtime assets). This specific verb+resource combination distinguishes it from siblings like run_experiment or validate_project.

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

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

The description implies use for initial setup, but provides no explicit when-to-use or when-not-to-use guidance compared to siblings. For example, it does not mention prerequisites or scenarios where validate_project might be more appropriate.

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

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

With no annotations provided, the description carries full burden. It discloses the read-only nature but does not mention error conditions, performance implications, or required permissions.

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

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

A single sentence that front-loads the return values ('Return project structure...') followed by 'Read-only.' No wasted words.

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

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

The description lists what is returned but does not explain the output structure (e.g., format or fields), which would be helpful given no output schema. It is adequate for a simple tool but lacks depth.

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 100%; the parameter 'path' is adequately described in the schema as 'Project root to inspect'. The tool description adds no additional meaning beyond schema, so baseline 3 applies.

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

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

The description clearly states it returns 'project structure, entrypoint kind, contract state, and output evidence' and specifies 'Read-only'. This distinguishes it from sibling tools like validate_project (validation) and resolve_project (resolution).

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 'Read-only', suggesting safe exploration without side effects, but does not explicitly state when to prefer this tool over siblings or when not to use it.

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

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

No annotations are provided, so the description carries the full burden. It mentions 'Read-only' but does not disclose other behavioral traits such as behavior when max_depth is exceeded, performance characteristics, or error handling.

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

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

The description is concise with two short sentences and no extraneous information. However, it could benefit from more structured formatting or bullet points for clarity.

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

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

Given the lack of output schema, annotations, and parameter documentation, the description does not fully inform the agent about tool behavior or constraints. For example, it does not address potential cycles in the parent chain or the significance of the output directory.

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

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

Schema description coverage is 0% and the description does not mention any parameters (max_depth, output_dir) or explain their meaning beyond what the schema provides. This is a significant gap for a tool with 2 parameters.

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

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

The description clearly states the tool's action ('Walk a RunRecord's parent chain') and output ('Returns ordered nodes from this run back to its earliest reachable ancestor'), distinguishing it from sibling tools that handle other run operations.

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

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

No explicit guidance on when to use this tool versus alternatives (e.g., describe_run or compare_runs). The description only states it is read-only but does not provide context for appropriate use cases or prerequisites.

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

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

No annotations are provided, but the description explicitly states the tool is read-only and does not create directories or mutate state. It also lists the return fields, providing full behavioral transparency.

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

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

The description is two sentences, front-loading the purpose and listing outputs and safety in a concise, efficient manner without unnecessary information.

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

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

For a simple config resolution tool with no output schema and no annotations, the description covers all necessary aspects: purpose, inputs, returns, and behavioral safety. No critical information is missing.

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

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

Schema coverage is 100%, and the description adds context by explaining the overall function (resolving cq.yaml and environment) but does not add per-parameter insights beyond what the schema already provides.

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 'Resolve' and identifies the key resources ('cq.yaml + CQ_CONFIG_JSON env'), clearly distinguishing this tool from sibling tools like inspect_project or validate_project by focusing on config resolution.

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 explicitly states the tool is read-only and does not mutate state, providing clear context for safe usage. However, it does not mention when to prefer this tool over alternatives like inspect_project or validate_project.

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

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

With no annotations, the description carries full burden; it discloses log capture and environment injection but omits return behavior, success/failure signals, and potential side effects like log overwrites.

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

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

Three sentences, no fluff, front-loads the main action and alternative guidance efficiently.

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

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

Adequate for a simple tool but lacks explanation of how to retrieve results post-execution and full behavior of 'config_only' mode, which reduces completeness for an AI agent.

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

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

The description adds no detail about the 'path' parameter (default '.') beyond the schema, and only one parameter has schema description; minimal extra guidance for correct usage.

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

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

The description clearly states the tool executes a command from cq.yaml.cmd with an auto-wired environment variable and captures logs, distinguishing it from sibling tools like 'agent_install' or 'apply_plan'.

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 advises against using for long-running GPU training, instead recommending the CQ service queue, providing clear when-to-use 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 provided, so description must carry burden. It states 'Read-only', which is good for a validation tool, but does not describe return format, error behavior, or effects on the project state. Moderate transparency.

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

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

Two sentences, front-loaded with action and resource. Every sentence adds value with no redundancy. Highly concise.

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

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

Complex tool with 6 params and no output schema, yet the description lacks details on return values, error handling, or comparison with sibling 'validate_run'. Incomplete for effective agent invocation.

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

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

Schema description coverage is 83%, so baseline is 3. The description adds context that inline plans are optional and that validation can be applied to ExperimentPlan/ExperimentPlanSet, but does not add significant new meaning beyond what schema already provides.

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?

Clearly states it runs 'static and contract validation before execution' with optional inline plans. The verb 'validate' and resource 'project' are clear, and 'Read-only' clarifies it's non-mutating. However, it does not explicitly distinguish from sibling 'validate_run' beyond naming.

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?

Only implies usage 'before execution' but provides no explicit guidance on when to use this tool versus alternatives like 'inspect_project' or 'validate_run'. No exclusions or context for selection among siblings.

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

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

The description declares the tool as read-only, which is valuable behavioral information given no annotations. However, it lacks details on validation behavior (e.g., output format, error handling, consequences of rescan_manifest) and relies partially on the schema for the rescan_manifest description.

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

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

The description is extremely concise: two sentences that convey the core purpose and read-only nature. No extraneous words.

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

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

For a validation tool with three parameters and no output schema, the description is incomplete. It omits what the tool returns (e.g., success/failure, error details) and does not elaborate on the validation gates or 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?

With only 33% schema description coverage, the description does not explain any parameters. It adds no meaning beyond the schema, which already has reasonable defaults and one parameter description. The low coverage demands more compensation than provided.

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

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

The description clearly states it runs post-run validation gates on a completed output directory. It lists the gates (manifest, metrics, run_summary) and implies its role after a run. However, it does not explicitly differentiate from sibling tools like validate_project.

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

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

No guidance on when to use this tool versus alternatives. It mentions 'post-run' but does not specify prerequisites, when not to use, or how it compares to other validation tools in the sibling list.

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