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

Annotations already establish that this is read-only and non-destructive, and the description is consistent with that. It adds some context by mentioning evidence policies and ledger integrity as inputs, but does not clarify what 'fresh' means or whether any implicit assumptions must hold before calling.

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

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

The description is a single sentence with no filler and the core action is front-loaded. The phrase 'fresh evidence policies' is somewhat dense and jargon-heavy, which keeps it just short of maximally clear.

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 one fully documented parameter and an output schema present, the structural burden is low. However, an agent still lacks enough context about when to invoke this tool relative to its siblings and what 'completion' means in this workflow.

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

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

The schema fully describes task_id as the identifier returned by create_task, so the description does not need to add much. The description references evidence policies and ledger integrity but does not explain how task_id relates to those concepts.

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 action, 'compute completion', and references the inputs it relies on ('fresh evidence policies and ledger integrity'). However, it does not differentiate itself from siblings like execute_verification or build_proof_report, and 'completion' is left undefined.

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

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

No guidance is given about when to call this tool versus alternatives such as prepare_verification, execute_verification, or build_proof_report. There are no preconditions, ordering hints, or exclusion criteria provided.

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

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

Annotations already indicate this is a non-read, non-destructive operation, and the description adds that the behavior is writing a Markdown report with specific content. It does not disclose whether it updates task state, requires permissions, or produces a stored artifact, but with annotations covering the safety profile, this is acceptable.

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 states the action, output format, and primary content with no filler. Every phrase earns its place.

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

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

With an output schema present, return value details are covered, but the description omits the workflow context in which this tool should be invoked. Given the large sibling set, an agent lacks enough information to know that this report should be built after verification or what task states are valid.

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 100% and the task_id parameter is already documented as 'Identifier returned by create_task.' The description adds no additional parameter-level meaning beyond the schema, so the baseline of 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 uses a specific verb ('Write') and names a concrete resource ('Markdown proof report'), and it states the report's contents ('matrix and hash-linked evidence ledger'), which makes the tool's purpose understandable. It does not explicitly distinguish this from sibling tools such as prepare_verification or execute_verification, 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?

The description gives no guidance on when to call this tool versus alternatives, and it does not state prerequisites such as whether verification or evidence recording must happen first. The only contextual hint is the task_id parameter, which is not enough to route an agent to the right point in the workflow.

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 establish that the tool is not read-only and not destructive. The description adds that the operation persists and redacts the objective, which is useful. However, it does not explain what 'bounded' means in practice, whether tasks can be overwritten, or what side effects exist beyond persistence.

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

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

The description is a single, front-loaded sentence with no wasted words. The phrasing is dense and slightly jargon-heavy, but it communicates the core action and a notable behavioral detail 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?

The tool is low-complexity, all parameters are documented in the schema, and an output schema exists. Still, the description leaves some meaning implicit, especially 'bounded task' and the exact redaction behavior, so an agent must infer parts of the contract.

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

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

The input schema already covers all three parameters with descriptions, so the baseline is 3. The description adds only the redaction nuance for the objective and does not provide additional parameter-level 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 identifies the action ('Create') and the resource ('a bounded task'), and adds useful nuance about persisting a redacted objective. It is distinct at a glance from the read/list/verification sibling tools, though it does not explicitly name a contrast.

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 when a new task object should be created, but it provides no explicit 'when to use vs alternatives' guidance and gives no exclusions. The sibling tools are discoverable by name, but the description itself does not help an agent choose between them.

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

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

Annotations already indicate a write operation that is not destructive. The description adds that it asks the host model and persists only a draft, which is useful side-effect context. It does not go deeper into what exactly is persisted or whether anything existing is overwritten, but it does not contradict the annotations.

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

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

The description is a single, front-loaded sentence with no filler. Every word contributes to the core action and constraint.

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 a simple single-parameter schema and an output schema, so the description does not need to explain return values. Still, the meaning of 'host model' and 'observable criteria' is not defined, and the relationship to set_criteria is only implicit, leaving moderate contextual gaps.

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

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

Schema coverage is 100% and the only parameter, task_id, is already documented as 'Identifier returned by create_task.' The description adds no additional meaning about the parameter, so the baseline of 3 is appropriate.

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

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

The description uses a specific action ('derive') and target ('observable criteria') and clarifies that only a draft proposal is persisted. This distinguishes it from a sibling like set_criteria, though 'host model' and 'observable criteria' are left somewhat unexplained.

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 'persist only a draft proposal' implies this tool is for producing a preliminary draft rather than final criteria, which hints at the relationship to set_criteria. However, there is no explicit statement of when to use this tool versus other siblings or what workflow position it occupies.

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 only provide readOnlyHint=false and destructiveHint=false, leaving behavioral details to the description. The description adds useful context by naming the input source and the output, but it does not disclose whether side effects occur or what state changes may happen. No contradiction with annotations.

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

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

A single sentence with no filler. The core action and source are front-loaded, and every word contributes to the tool's purpose.

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

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

For a simple one-parameter tool with an output schema, the description covers the essential purpose and source. It lacks explicit workflow placement or side-effect disclosure, but these are secondary given the low complexity and rich schema signals.

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 100%, and the single task_id parameter is already documented as the identifier returned by create_task. The tool description adds no additional parameter-level meaning, but the schema already covers it adequately.

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 ('derive') with a specific resource ('verifier argv and working directories') and a clear source ('live project manifests'). This clearly distinguishes the tool from execution- or attestation-focused siblings.

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

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

The description implies a use case: derive verification arguments and directories from manifests. However, it does not explicitly say when to prefer this tool over alternatives like prepare_verification or derive_criteria, nor does it state 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?

Annotations already declare readOnlyHint=false and destructiveHint=true, which lowers the burden. The description adds useful concrete side effects: it consumes a one-time token and appends command evidence. However, it does not explain the nature or extent of destructive behavior beyond token consumption, such as whether prior verification evidence is replaced or modified.

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

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

The description is a single concise sentence with three clear ordered actions: consume token, run verifier, append evidence. It contains no filler and front-loads the key behavior, making it easy for an agent to parse quickly.

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

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

With a 100%-covered schema, an output schema, and annotations indicating a destructive mutation, the description is mostly sufficient for invoking the tool. However, it lacks explicit workflow context around when to call this after prepare_verification and does not fully spell out the destructive side effects, so the agent must infer some context from parameter descriptions and annotations.

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 100%, so the baseline is 3. The description does not add parameter-level meaning beyond what the schema already states; it reinforces the token-consumption and evidence-appending flow but provides no additional constraints, formats, or relationships.

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

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

The description states a clear action chain: consume an approval token, run the candidate verifier, and append observed command evidence. It identifies the tool's resource and behavior well. It is not a full 5 because 'candidate verifier' is somewhat vague and it does not explicitly differentiate itself from sibling tools like assess_completion or record_attestation.

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 guidance on when to use this tool versus alternatives, and no mention of required prerequisites like first calling prepare_verification or create_task. The workflow is only implied through schema parameter descriptions ('Identifier returned by prepare_verification'). No exclusions or alternative routing are provided.

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

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

Annotations already declare readOnlyHint=true and destructiveHint=false, so the safety profile is covered. The description adds value by specifying what data is returned, but it does not disclose additional behavioral aspects such as error handling, authorization requirements, or performance characteristics.

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

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

The description is one concise, front-loaded sentence that lists the return contents without filler. Every word earns its place and the structure makes the purpose immediately clear.

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 single-parameter read operation with annotations covering safety and an output schema present, the description is complete enough. It tells the agent what will be returned, and the schema explains how to identify the task. 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?

The input schema has 100% description coverage, and the task_id parameter is documented as 'Identifier returned by create_task.' The tool description itself adds no additional parameter semantics, but the schema already carries the necessary meaning, so the baseline score is appropriate.

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

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

The description uses the specific verb 'Return' with the resource 'task' and enumerates the payload components: active criteria, verifier profile, evidence, and current assessment. This clearly states what the tool does, though it does not explicitly differentiate itself from the sibling list_tasks tool.

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

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

The read-oriented description implies use when a specific task's full details are needed, and the required task_id parameter reinforces this. However, there is no explicit guidance about when to choose this over list_tasks or other siblings, and no exclusions 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?

Annotations already declare readOnlyHint=true and destructiveHint=false, so the safety profile is covered. The description adds useful context by stating that projects are not read, which conveys an efficiency/scoping trait not present in the annotations.

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 wastes no words. It front-loads the core action ('List persisted proof tasks') and appends the key scoping 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?

With no parameters, safety annotations present, and an output schema available, the description provides all essential context for invoking this tool. Nothing critical 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?

The tool has zero parameters, so there is no parameter detail to document. The description correctly focuses on behavior rather than input semantics, which is the appropriate baseline for a parameterless tool.

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

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

The description clearly states the tool's function: listing persisted proof tasks. The qualifier 'without reading their projects' sharply distinguishes it from task-specific tools like get_task or project-related 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?

The description gives clear context that this is a lightweight list operation that avoids loading project data. It does not explicitly name sibling alternatives, but the behavior and scope are clear enough for an agent to select it appropriately.

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 establish that this is a write operation (readOnlyHint=false) that is non-destructive (destructiveHint=false). The description adds a meaningful behavioral trait: the token is 'one-time', implying it cannot be reused, and the plan is 'evidence-linked', indicating a relationship to evidence data. This goes beyond the annotations and helps the agent understand side effects and 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 a single, front-loaded sentence that states the action and the produced artifacts with no filler. Every word contributes to meaning, and it is easy to scan quickly.

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

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

With an output schema present, return values do not need to be described. The main gap is the missing workflow context: the description does not connect this tool to execute_verification or mention prerequisites such as criteria and verifier discovery, though the sibling list and parameter names offer indirect hints. It is adequate for a single-step creation tool but leaves workflow sequencing 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 description coverage is 100%, so the parameter semantics are already fully documented in the schema. The description does not add any extra meaning or context about parameters, which is acceptable given the schema coverage. Baseline of 3 is appropriate.

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

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

The description uses a specific verb ('Create') and names two concrete artifacts ('evidence-linked verifier plan' and 'one-time execution token'). This distinguishes it from siblings like execute_verification (which would run rather than prepare) and record_attestation. However, it does not explicitly name or contrast siblings, and the term 'verifier plan' is somewhat abstract without further context.

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 context is implied by the name 'prepare_verification' and the production of an 'execution token', suggesting this should be called before execute_verification. However, there is no explicit statement of when to use it, when not to use it, or how it relates to sibling tools. The guidance is left to inference.

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

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

Annotations already establish this is a mutating (readOnlyHint=false) but non-destructive operation. The description adds useful semantic context beyond annotations — that records are categorized as attested and human-reviewed — but does not disclose side effects, immutability of records, or downstream consequences on criteria satisfaction. No contradiction with annotations.

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 12-word sentence with the verb and resource front-loaded, and every clause earns its place — 'human-reviewed' clarifies the evidence source and 'attested rather than observed' performs critical sibling differentiation. Zero filler or repetition of 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 6-parameter write operation, the context signals are strong: all parameters are documented in the schema, an output schema exists, and annotations convey the safety profile. The description supplies the key semantic positioning. The only notable gap is that explicit routing between attestation and observational evidence tools is implied rather than stated.

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 100%, so the baseline of 3 applies. The description's attested/observed distinction is already reflected in the schema's result parameter description ('Attested or observed outcome; unknown never satisfies a criterion'), so it adds no parameter-level meaning beyond the schema.

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

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

The description uses a specific verb+resource pair ('Record a human-reviewed claim') and immediately differentiates this tool from observational evidence recording with 'explicitly labelled as attested rather than observed.' This cleanly distinguishes it from the sibling record_file_evidence, which presumably handles observed/file-based evidence.

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

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

The description gives clear context: use this tool when a claim has undergone human review and should be categorized as an attestation. The 'rather than observed' contrast implies the alternative category of evidence, but it stops short of explicitly naming the sibling tool (record_file_evidence) or stating when-not-to-use conditions.

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 annotations indicate the tool is not read-only and not destructive, but say little else. The description adds the key behavioral rule that pass/fail only occurs with an explicit expected hash. However, it does not clarify what side effects occur when evidence is recorded or what happens in the absence of an expected hash beyond what the schema already states.

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

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

The description is a single, front-loaded sentence with no wasted words. It communicates the core operation and the critical conditional behavior 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?

With an output schema and fully documented parameters, the tool is largely invocable from the description. However, it lacks contextual guidance about its role in the verification workflow or alternatives like record_attestation, and the phrase 'observed pass or fail' is left somewhat ambiguous without additional context.

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%, so the baseline is 3. The description adds meaning by tying expected_sha256 to the pass/fail outcome, reinforcing the conditional behavior. This goes slightly beyond the schema's documentation and helps the agent understand parameter intent.

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

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

The description states a specific verb and resource: 'Hash a project file'. It also clarifies the verification semantics with the pass/fail condition, which distinguishes it from generic hashing. However, it does not explicitly mention 'record evidence' or differentiate itself from sibling tools like record_attestation.

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 by explaining when pass/fail is observed, but it provides no explicit guidance on when to choose this tool over alternatives such as record_attestation or assess_completion. There are no when-to-use or when-not-to-use statements.

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 indicate this is a write operation (readOnlyHint=false) and not destructive (destructiveHint=false). The description adds the key behavioral detail that existing active criteria are replaced, and that the incoming criteria are user-reviewed. However, it does not clarify what happens to the old criteria or any other side effects, leaving some ambiguity.

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

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

The description is a single, focused sentence that front-loads the core action ('Replace') and contains no redundant words. It is concise and easy to parse.

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

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

Together with a fully documented schema and an output schema, the description gives an agent sufficient understanding to call the tool: it replaces current criteria for a given task with reviewed statements and evidence policies. Minor gaps include whether the replacement is atomic or what happens to old criteria, but these are not critical given the annotations and schema.

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

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

The schema has 100% description coverage for both task_id and the criteria array, including fields like required_evidence_kinds and rationale. The description's mention of 'statements and evidence policies' provides a high-level summary but does not add meaningful detail beyond the schema. Baseline 3 is appropriate.

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

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

The description states a specific action ('Replace') on a clear resource ('active criteria') and describes what the replacement consists of ('user-reviewed statements and evidence policies'). It distinguishes this from sibling derive_criteria, which would generate criteria rather than replace them with reviewed ones.

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 'user-reviewed' implies this tool should be used after criteria have been reviewed and are ready to be activated. However, the description does not explicitly state when to use this tool over derive_criteria or other alternatives, nor any prerequisites or exclusions.

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