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

Annotations already declare readOnlyHint=true, destructiveHint=false, idempotentHint=true, and openWorldHint=false, covering safety and idempotency. The description adds behavioral context about how the tool behaves without authentication binding: it returns a structured unavailable result and discloses no thread metadata. This goes beyond the annotations without contradicting them.

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

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

Two sentences, with the core purpose stated immediately and a key limitation in the second sentence. There is no fluff or repetition. The description is front-loaded and compact, 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?

For a status-check tool with no parameters and an output schema (which likely describes the returned structure), the description is fully sufficient. It explains the purpose, the condition under which it returns an unavailable result, and the data it does not disclose. Nothing an agent needs to decide whether to call this tool 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?

There are zero parameters, so the schema coverage is 100% and the description need not explain any args. Per the guidelines, a baseline of 4 applies when there are no parameters, as the tool requires no input. The description's mention of thread binding refers to an external context, not a 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?

The description uses a specific verb ('Report') and a clear resource ('protected current-task Codex control'), and states exactly what it reports (whether it is available). This distinguishes it from the sibling tools, which are about governance, research, and memory operations, making the tool's purpose unmistakable.

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

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

The description clearly states the tool reports availability of protected current-task Codex control. It also provides a contextual detail: without a host-authenticated per-call thread binding, it returns an unavailable result. This gives a condition for use but does not explicitly name alternatives or when-not-to-use scenarios. Given the unique purpose, the guidance is clear enough.

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 adds meaningful behavioral context beyond the annotations: it discloses the fail-closed behavior and explicitly states that no proposal or host state is created, consistent with readOnly and idempotent hints. This goes beyond what annotations alone provide, though it does not describe potential side effects or failure modes in detail.

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 and front-loaded with the fail-closed condition. It contains only two sentences with no redundant phrasing. The structure is direct and avoids fluff, though the content is cryptic; still, it is appropriately sized for a tool with one parameter.

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

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

The description lacks a clear statement of the tool's primary function and does not explain the 'action' parameter's options. It also provides no information about return values or usage context. Even with annotations and an output schema, an agent would not know what this tool does or how to invoke it correctly, making the description inadequate.

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

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

The single parameter 'action' has an enum of 'disable', 'enable', 'stop_active', but the description provides no explanation of these values or their semantics. With 0% schema description coverage, the description should compensate, but it does not mention the parameter at all. The agent is left to infer meaning from the enum names alone, which is insufficient.

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

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

The description does not explicitly state that the tool enables, disables, or stops active agent control. Instead, it only mentions a fail-closed precondition and a contract gap, leaving the core action implicit. The name and the 'action' parameter hint at the purpose, but the description itself is vague and does not clearly articulate what operation is being prepared.

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 for when to use this tool versus any sibling tools. The only condition mentioned is 'Fail closed unless a protected Codex host broker is available,' which is a safety precondition rather than selection guidance. There is no discussion of alternatives, prerequisites, or appropriate 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?

There are no annotations, so the description carries the full burden of behavioral disclosure. 'Assess' hints at a read-only analysis, but the description does not state whether the tool mutates state, requires authentication, or has side effects. This is a significant gap for an unannotated tool.

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

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

The description is one compact, front-loaded sentence with no filler. It is easy to read and the criteria list is immediately visible, though its brevity comes at the cost of missing critical usage and parameter details.

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?

While the presence of an output schema reduces the need to explain return values, the tool still has an opaque nested parameter and many similar siblings. The description is too thin to be complete—it does not clarify the operation parameter shape, the expected input format, or when this assessment tool should be selected over alternatives.

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

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

The single 'operation' parameter has 0% schema description coverage and is an open object with additionalProperties: true. The description does not explain what fields the operation object should contain, how the plan or evidence is structured, or how the five assessment dimensions map to inputs. The description adds no meaningful parameter semantics.

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

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

The description uses the verb 'assess' and names five specific evaluation dimensions (necessity, bounded work, elapsed time, difficulty, cost evidence), giving a clear sense of what the tool does. However, it does not explicitly say it assesses a 'plan' or differentiate itself from sibling governance assessment tools like governance_evaluate_operation or governance_evaluate_gate.

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

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

The description provides no guidance on when to use this tool versus alternatives. It lists assessment criteria but gives no context, prerequisites, or exclusions, leaving the agent to guess when this tool is appropriate.

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

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

With no annotations, the description must carry the transparency burden. It reveals one critical behavior: the tool does not write to the canonical ledger (effectively a read-only validation). However, it does not disclose any other behavioral aspects such as return structure, error conditions, or potential side effects beyond the ledger, making the transparency only partial.

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 clearly states the action and the key constraint. It is concise and free of filler or repeated 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?

The tool has two complex nested object parameters with no schema descriptions, no annotations, and a description that only covers a single behavioral aspect. The agent has no context on what constitutes a 'packet' or 'decision' in this governance domain, nor how validation results are returned. Given the large set of sibling governance tools, this description is insufficient for correct invocation and requires significant external knowledge.

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 two required object parameters (packet and decision), both with additionalProperties true and no descriptions. The tool description provides no information about what these parameters mean, how they should be structured, or what content they expect. With 0% schema coverage and no compensation in the description, parameter semantics are entirely absent.

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 explicitly states the tool's purpose: validate a host decision without writing to the canonical ledger. It uses a specific verb ('validate') and resource ('host decision'), and the 'without writing' clause differentiates it from capture/write operations and other governance 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 a dry-run validation use case, but it does not explicitly state when to use this tool instead of similar siblings like governance_validate_decision or other governance validation/preparation tools. No alternatives or exclusions are named, leaving usage guidance only implied.

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 transparency burden. It adds a meaningful behavioral guarantee ('never grants user approval'), but omits other traits like side effects, permissions, or state changes. The single disclosed trait is useful but incomplete for a governance 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 brief and front-loaded, with two sentences that each add value. No fluff or repetition, though it could pack more useful info into the same space.

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?

Although an output schema exists (reducing need to explain return values), the description lacks parameter semantics and usage context. For a governance tool with minimal complexity, this basic info is insufficient to select and invoke 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%, so the description must compensate. It provides no explanation of the 'decisions' array or 'claim_type' parameter, leaving the agent without semantic understanding beyond variable names.

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 evaluates deterministic claim gates, with a specific verb and resource. The caveat 'never grants user approval' distinguishes it from approval-granting tools, though the term 'claim gates' is not fully defined.

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 when-to-use guidance or alternative tool references. The only guidance is a negative constraint ('never grants user approval'), which tells when not to use it but not when to use it.

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

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

With no annotations, the description carries full burden. It discloses that the tool is a read-only evaluation and explicitly states it does not authorize or execute, indicating no side effects. This is transparent for a preflight check, though it could mention other behaviors like statelessness 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 a single concise sentence that front-loads the core purpose and adds a critical constraint. Every word earns its place with no redundancy or filler.

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

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

Given the tool has two required opaque object parameters with no schema descriptions and the context of governance evaluation, the description is too minimal. It fails to explain what constitutes a valid operation or packet, leaving the agent with insufficient information to use the tool correctly despite an output schema existing.

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

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

Schema description coverage is 0%, meaning neither 'packet' nor 'operation' have descriptions. The overall description mentions 'declarative preflight' but does not explain the structure or purpose of these parameters. The agent is left guessing what fields belong inside these objects.

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 specific verb 'evaluate' and resource 'declarative preflight', giving a clear purpose. It explicitly states what it does not do ('never authorize or execute'), which helps scope. However, it does not differentiate from sibling tools like governance_evaluate_gate or governance_validate_task_packet.

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 preflight evaluation and provides a negative constraint ('never authorize or execute'), offering some usage guidance. However, it does not explicitly state when to use this tool versus alternative sibling tools, nor does it describe prerequisites or context.

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

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

With no annotations, the description carries the burden. It adds some behavioral context via 'fixed' and 'non-executing', implying a read-only, static operation. However, it does not explicitly state side effects, permissions, or failure behavior, leaving a partial gap.

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 uses precise language without any filler. Every word contributes to identifying 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 zero-parameter getter with an output schema present, the description sufficiently identifies the returned data. No additional context is necessary for an agent to invoke the tool correctly.

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

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

The tool has zero parameters, and schema coverage is 100%. The description does not need to explain parameters, so the baseline score of 4 applies.

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

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

The description clearly identifies a specific action ('Return') and specific resources ('fixed governance roster' and 'non-executing host contract'). This distinguishes it from sibling tools like governance_get_role_manifest and governance_get_role_prompt_contract by naming unique data.

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

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

No guidance is provided on when to use this tool versus alternatives. There is no mention of prerequisites, exclusions, or scenarios where another governance tool would 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, the description carries the transparency burden. It discloses that the manifest is immutable and that a hash is returned, implying a read-only operation. However, it does not explicitly state the absence of side effects, potential errors, or permission requirements, which would be useful for a getter 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 concise, single sentence that front-loads the verb and resource. It contains no unnecessary words and is easy to parse.

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

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

For a simple lookup tool with an output schema, the core purpose is conveyed. However, the lack of usage context and the ambiguous agent_id relationship make the description less complete than it could be, especially given absent annotations and zero schema parameter descriptions.

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

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

The schema has 0% description coverage for agent_id, and the description does not explain how agent_id relates to the role manifest. While the parameter name is somewhat self-explanatory, the description fails to specify that agent_id selects which role manifest to return, leaving ambiguity.

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 a specific action ('Return') and a distinct resource ('one immutable registered role manifest' plus its 'canonical hash'). This differentiates it from sibling tools like governance_get_capabilities or governance_get_role_prompt_contract.

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

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

No guidance is provided on when to use this tool versus alternatives. The description is purely functional and does not mention any conditions, exclusions, or alternative tools, leaving the agent to infer applicability.

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 must carry the full burden. It notes the result is 'internal' and 'versioned', but it does not disclose possible errors (e.g., role not registered), authentication requirements, or confirm it is read-only beyond the verb 'Return'.

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, short sentence with no filler. It front-loads the action and resource, making it immediately scannable.

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

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

The tool is simple with one parameter and an output schema, so the description minimally covers the core behavior. However, it lacks usage guidance and behavioral details, making it merely adequate rather than fully self-sufficient 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?

The single parameter agent_id has no schema description, and schema coverage is 0%. The description adds minimal context by implying a 'registered role', but it does not explain how agent_id maps to a role, its format, or how to obtain a valid value.

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

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

The description uses a specific verb ('Return') and resource ('internal versioned prompt contract') plus a clear scope ('for one registered role'). It distinguishes this tool from siblings like governance_get_role_manifest and governance_get_capabilities by focusing on the prompt contract specifically.

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 use this tool versus alternatives such as governance_get_role_manifest or governance_get_capabilities. The description only states what it returns, without exclusions, prerequisites, or alternative recommendations.

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

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

With no annotations, the description carries the burden of disclosing behavior. It explicitly notes that no agents, models, or network are started, which is a key safety trait. However, it does not describe what validation checks are performed or whether any side effects like logging occur.

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, earning its place. It is concise while conveying the core purpose and key limitation.

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

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

Despite the existence of an output schema, the input parameters are unexplained and the nature of the validation is vague. The tool's overall behavior and configuration are not sufficiently described for an agent to invoke it correctly.

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

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

Schema description coverage is 0%, and the description adds no meaning for the four parameters (packets, max_workers, declared_costs_usd, aggregate_cost_ceiling_usd). The agent must infer their semantics solely from names, which is insufficient.

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

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

The description clearly states a specific verb 'validate' with a specific resource 'a parallel batch', and the qualifier 'without starting agents, models, or network' distinguishes it from dispatch or execution tools. It is immediately clear this is a dry-run validation 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 description implies usage for preflight validation without side effects, but it does not explicitly state when to use this over sibling tools like governance_validate_task_packet or governance_prepare_codex_dispatch, nor does it list exclusions.

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

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

With no annotations provided, the description carries the full burden of disclosing behavioral traits. It only mentions 'prepare' and batch characteristics, but does not state whether this mutates state, requires permissions, has side effects, or what 'isolated fixed four-reviewer' concretely means. This is a significant transparency gap for a tool that appears to perform a preparation 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 a single short sentence, but it is under-specified rather than efficiently informative. It lacks the front-loaded useful details that would make it concise in a valuable way.

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 no annotations, 0% parameter description coverage, and a terse description. Even though an output schema exists, the input semantics, behavioral effect, and intended usage context are almost entirely absent, making the description inadequate for reliable invocation.

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

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

Schema description coverage is 0%, so the description must compensate for the unexplained parameters. It does not mention 'packets' or 'governor_receipt' at all, leaving the required and optional parameters completely undefined beyond their names and types.

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

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

The description names a specific resource ('the isolated fixed four-reviewer critical batch') and uses the verb 'prepare,' which distinguishes it from sibling tools like governance_prepare_codex_dispatch and governance_preflight_parallel_batch. However, 'prepare' remains somewhat generic and does not clarify what preparation entails, 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 guidance on when to use this tool versus alternatives. Sibling tools such as governance_prepare_codex_dispatch and governance_preflight_parallel_batch suggest related workflows, but the description provides no context, prerequisites, or exclusions.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It only states that the tool does not execute, but gives no insight into side effects, state changes, permissions, or what 'prepare' actually entails. This is minimal and insufficient for a governance 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 single sentence is front-loaded with the core purpose and contains no wasted words. It is concise, though the extreme brevity leaves out necessary details, preventing a 5.

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

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

Despite the presence of an output schema, the description is grossly incomplete for a tool with two complex parameters (one required object with arbitrary properties). It does not explain what a 'host-owned agent dispatch' is, what the parameters mean, or any prerequisites. This is fundamentally inadequate.

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 provides no explanation of the 'packet' or 'governor_receipt' parameters. It adds zero meaning beyond the plain schema structure, failing to compensate for the lack of schema descriptions.

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

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

The description clearly states the tool's specific verb ('Prepare') and resource ('host-owned agent dispatch'), and explicitly distinguishes it from execution tools with 'do not execute'. This differentiates it from sibling tools like prepare_scope_governor_receipt or prepare_codex_critical_batch.

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

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

The description provides clear context: the tool is for preparing an agent dispatch without executing it. The 'but do not execute' phrase is an explicit when-not. However, it does not mention alternative tools or provide a full comparison, so it falls short of a 5.

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

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

With no annotations, the description carries the full burden. It discloses one useful trait: 'storage remains host-owned', signaling the tool does not persist data itself. However, it neither explains what 'prepare' entails, side effects, permissions, nor the nature of the tombstone, leaving most behavioral aspects undisclosed.

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

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

The description is a single concise sentence with two clauses, containing no redundant wording. It is efficiently structured, although its brevity sacrifices 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?

Despite the existence of an output schema, the description lacks usage context, parameter guidance, and sufficient behavioral detail for a tool with three parameters and a governance-specific purpose. The cryptic 'tombstone' and optional parameters create significant gaps in 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?

Schema description coverage is 0%, and the description mentions none of the three parameters (task, failure, profile). It adds no meaning beyond the bare schema, offering the agent no insight into what values to provide or how the parameters relate to the tombstone preparation.

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 uses 'prepare' with a specific resource, 'mandatory minimum tombstone', indicating a failure record marker. The tool name reinforces the purpose. It does not explicitly contrast with sibling prepare tools, but the resource is distinct enough to separate it from similar tools like governance_prepare_codex_dispatch.

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

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

The description provides no guidance on when to use this tool versus alternatives such as governance_resolve_failure_policy or governance_prepare_scope_governor_receipt. The phrase 'mandatory minimum' hints at a required step, but there is no explicit context, exclusions, or alternative selection criteria.

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 of disclosing behavioral traits. It only states that the tool 'binds' a decision, implying a write operation, but does not mention side effects, permissions, reversibility, or failure behavior. This is a significant gap.

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, direct sentence with no redundant information. It is front-loaded and every word contributes meaning, making it 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?

Given the tool has three complex object parameters with nested properties and no schema descriptions, this one-sentence description is inadequate. It does not explain the full process, the relationships between parameters, or the context of the receipt. The output schema covers return values, but the overall tool usage remains unclear.

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 hints that 'governor_decision' maps to the scope decision and 'governed_packets' to task hashes, but it does not explain the role of 'governor_packet' or the structure of these objects. With 0% schema description coverage, this is insufficient for understanding all three required 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 action: 'Bind a validated passing scope decision to exact governed task hashes.' It uses a specific verb and identifies the resource, which distinguishes it from sibling tools focused on other governance operations. However, it does not explicitly mention the 'receipt' concept from the tool name, so it is not a perfect 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 provides no guidance on when to use this tool versus alternatives like governance_prepare_codex_dispatch. The phrase 'validated passing' implies a prerequisite, but there is no explicit context, exclusions, or alternative tools 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 carries the full burden of behavioral disclosure. It only states a negative constraint ('without accepting an off/unrecorded mode') but does not reveal whether the tool mutates state, what triggers success/failure, or any side effects. This is insufficient for a governance tool that likely writes policy.

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 fluff, but the brevity sacrifices essential information. It is not a pointless word waste, but it is under-specified to the point of harming 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?

Even though an output schema exists, the description omits critical context about the tool's purpose, parameter roles, and behavioral outcomes. For a tool with optional open-object parameters and zero schema coverage, the description should clarify how the tool resolves failure handling and what 'off/unrecorded mode' means, but it does not.

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 two parameters (task and profile) with no descriptions and 0% coverage, yet the description does not mention them at all. The agent is left completely uninformed about what values these parameters take or how they influence the resolution process.

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

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

The description uses the verb 'resolve' with 'failure handling' as a resource, indicating an action, but it does not specify what 'resolve' entails or how it differs from sibling tools like governance_prepare_failure_record. The additional constraint 'without accepting an off/unrecorded mode' provides some specificity but leaves the core functionality vague.

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

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

There is no guidance on when to use this tool versus alternatives. The description does not mention prerequisites, context, or exclusions, leaving the agent without a basis for selecting this tool among the many governance_* siblings.

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

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

With no annotations provided, the description must fully disclose behavior. It states that validation is 'exact' but does not explain what validation entails, whether it has side effects, what a successful/failed result looks like, or any required permissions. This leaves significant behavioral ambiguity.

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

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

The description is a single, front-loaded sentence with no wasted words. Every word contributes meaning, making it appropriately concise for the limited detail it provides.

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 (two nested objects, exact validation semantics, no annotations), the description is too sparse. It omits validation criteria, return behavior, and edge cases. Even though an output schema exists, the description still fails to convey the tool's operational context and constraints.

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 identifies 'decision' as the returned decision and 'packet' as the exact task packet, providing minimal linkage, but it does not explain the structure, required fields, or how the matching is performed.

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 ('Validate') and its specific object ('a returned decision against its exact task packet'). It distinguishes from the sibling 'governance_validate_task_packet' by focusing on the decision rather than the packet, though it doesn't explicitly call out that alternative.

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

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

The phrase 'returned decision' implies the tool is used after a decision has been produced, giving some context. However, it provides no explicit guidance on when to use this tool versus alternatives like governance_validate_task_packet or governance_evaluate_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 provided, the description carries the full burden of behavioral disclosure. It does disclose that the tool is non-mutating ('without dispatching or approving'), which is helpful. However, it does not explain what validation entails (e.g., criteria, side effects) or what the response contains. The output schema likely covers return format, but the description alone leaves key behavioral traits unspecified.

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 of eleven words that gets straight to the point. It front-loads the action and adds a critical qualifier ('without dispatching or approving it') without any fluff. Every word earns its place.

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

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

For a straightforward validation tool with a single parameter and an output schema, the description is minimally sufficient but has clear gaps. It does not explain the structure or purpose of the 'packet' parameter, nor the nature of the validation (e.g., what is checked, what a valid result looks like). The tool is simple, but the lack of parameter semantics makes it less complete than it could be.

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 sole parameter 'packet' is an untyped object with no description, and the tool description never mentions it. While 'Validate a proposed agent task' might imply that 'packet' is the task, this is not explicit, and there is no guidance on its structure, required fields, or accepted formats. The description fails to compensate for the schema's lack of parameter details.

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 verb 'validate' and the resource 'a proposed agent task', and explicitly distinguishes this tool from those that dispatch or approve by adding 'without dispatching or approving it'. This makes the tool's purpose unambiguous and differentiates it from sibling tools.

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

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

The phrase 'without dispatching or approving it' establishes a clear usage context, implying this tool is for pre-decision validation before any commitment. It does not name specific alternative tools, but it implies the boundary of when to use it. This is clear context without explicit exclusions.

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 supply readOnlyHint=true, idempotentHint=true, and destructiveHint=false. The description adds context about returning policy and integrity findings but does not disclose further behavioral details such as how results are scoped, what 'canonical JSONL' implies, or any edge cases. It is consistent with annotations, adding moderate value beyond them.

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 conveys the purpose efficiently. Every word earns its place – no fluff, no redundancy. It is optimally concise while remaining 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 zero parameters, comprehensive annotations, and an output schema present, the description covers the core purpose. It does not explain what constitutes 'policy' or 'record-integrity findings' in detail, but the output schema likely fills that gap. The description is sufficiently complete for a parameterless read-only 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?

There are zero parameters, so schema description coverage is 100%. With no parameters, the description need not add parameter-level semantics. The baseline score of 4 is appropriate as the description provides no extra parameter info, but none is needed.

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

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

The description uses a specific verb 'Return' and identifies the resource as 'read-only policy and record-integrity findings' with a clear context 'for canonical JSONL.' This distinguishes it from sibling tools like memory_fetch_evidence (which fetches evidence) and memory_check_evidence_eligibility (checks eligibility).

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

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

No guidance is provided on when to use this tool versus alternatives among the many memory and governance siblings. The description does not mention exclusions, prerequisites, or recommended scenarios, leaving the agent without decision criteria.

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 cover read-only, idempotent, and non-destructive behavior. The description adds useful behavioral context beyond that: the gate activates based on claim consequence, and omitting claim_type would silently produce an inactive default. This is a meaningful non-obvious behavior disclosure.

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

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

The description is short, front-loaded with the core scope, and every sentence earns its place. The second paragraph adds a specific design caveat rather than repeating schema information or filling space.

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 no output schema, and the description does not describe the result shape, what 'count' or 'integrity' operationally returns, how null evidence is handled, or how materiality affects behavior. It also does not route the agent relative to the many sibling tools, leaving an incomplete invocation picture.

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

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

With 0% schema description coverage, the description must compensate for undocumented parameters, but it only explains claim_type's requiredness. Claim, evidence, and materiality receive no semantic guidance, so an agent cannot confidently know how to populate or interpret those parameters beyond their bare names and enums.

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 concrete operation: checking exact evidence integrity and count, and explicitly negates semantic claim support. This gives an agent a specific verb, resource, and boundary without needing to infer from the name or schema.

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

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

It communicates a clear non-goal ('never semantic claim support') and explains why claim_type is mandatory, but it does not name sibling alternatives or give explicit conditions for when to choose this tool over memory_fetch_evidence, governance_evaluate_gate, or similar operations. Usage context is implied rather than explicitly 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?

Beyond the readOnly/idempotent annotations, the description discloses meaningful behavioral constraints: event-less fetches are diagnostics only and cannot satisfy evidence eligibility, and changed-source diagnostics retain the registered reference even when the current file is shorter. This is genuine behavioral nuance, though the wording is somewhat cryptic.

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

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

The description is short and avoids restating the schema, but the densely packed jargon ('display context', 'reference', 'changed-source diagnostics') makes it less accessible. It is concise in length but not in clarity, and the second sentence introduces complex domain concepts without setup.

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 seven parameters, no output schema, and no sibling differentiation, the description is far too thin. It does not explain the expected inputs, the return value, or the matching/eligibility semantics well enough for an agent to invoke this tool reliably in novel situations.

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

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

Schema description coverage is 0%, and the description compensates with no parameter-specific explanation. None of the seven parameters (path, start_line, end_line, event_id, context_lines, expected_sha256, allow_mismatched_content) are described or even referenced clearly, leaving the agent without enough semantic grounding to choose values correctly.

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

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

The first sentence 'Fetch an exact event locator' conveys a specific action and resource, but 'event locator' is undefined and the phrase 'keep display context outside its reference' is unclear. It does not meaningfully differentiate from siblings like memory_search_candidates beyond the word 'exact'.

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 a conditional note about event-less fetches being 'registered-file diagnostics only', but it never says when to prefer this tool over memory_search_candidates or memory_latest, nor does it provide exclusions. An agent is left to infer usage context from the tool name and schema.

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 readOnly, idempotent, and non-destructive behavior. The description adds useful behavioral context by scoping to non-reference records and specifying ordering by event time, but it does not explain what makes a record 'non-reference' or how top_k limits the result set.

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 with no filler; the main action, record scope, and ordering are all front-loaded. Every word earns its place.

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

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

For a one-parameter read-only tool this is nearly sufficient, but the undefined term 'non-reference records' and the lack of an output schema leave some ambiguity about what the agent will receive. The safe annotations reduce the risk, but a definition of the record scope would make it fully complete.

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

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

Schema description coverage is 0%, and the description never mentions the only parameter, top_k. The parameter name and default imply it is a count, but the description does not compensate for the missing schema descriptions by explaining valid values, behavior, or interaction with the ordering.

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 ('Return') and identifies a clearly scoped resource ('latest non-reference records') with an explicit ordering criterion ('recorded event time'). It stops short of contrasting with siblings like memory_search_candidates, so it is clear but not fully differentiated.

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

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

The phrasing implies use when the agent needs the most recent non-reference memory records, and the read-only annotations signal safe retrieval. However, it gives no explicit when-to-use or when-not-to-use guidance and does not mention alternative tools such as memory_search_candidates or memory_audit_ledger.

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 readOnly, idempotent, and non-destructive behavior, so the description only needs to add context beyond that. It does add that results are provenance-bound candidates and that they are not sufficient for conclusions. However, it does not disclose ranking behavior, empty-result handling, mode effects, or how candidates relate to original evidence.

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 with no filler. The first sentence states the core return behavior, and the second adds an actionable workflow warning. Every word earns its place, making it appropriately concise and front-loaded.

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

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

Given five parameters, two enums, no schema descriptions, and no output schema, the description is too sparse for reliable invocation. It does not explain what a 'candidate' contains, how modes differ, what status accepts, what candidate_backend controls, or how top_k behaves. The one useful workflow hint about fetching original evidence is insufficient for the tool's complexity.

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

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

Schema description coverage is 0%, and the description provides no information about the five parameters: query, mode, top_k, status, or candidate_backend. The phrase 'provenance-bound candidates' does not help an agent understand parameter meaning, required inputs, enums, or defaults. 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 returns 'provenance-bound candidates', which is a specific verb and resource, and distinguishes it from evidence retrieval by instructing to 'Fetch original evidence before concluding'. It does not explicitly name a sibling tool, but the candidate-versus-evidence distinction makes the purpose understandable.

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

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

The description provides a clear usage directive: after getting candidates, the agent should fetch original evidence before drawing conclusions. This implies the tool is for preliminary retrieval rather than final evidence. It does not explicitly state when to avoid the tool or name alternatives, but the workflow guidance is clear.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true, destructiveHint=false, and openWorldHint=false, which comprehensively cover the tool's safety and idempotency. The description adds minimal behavioral insight beyond 'return a receipt' – it doesn't clarify what 'path-free' means or how the receipt is constructed. With such strong annotations, the bar is lower, and the description meets the minimum by not contradicting them.

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

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

The description is a single, concise sentence with no filler. Every word is necessary, and it front-loads the action ('Return') and the object ('path-free publication receipt'). Perfect example of minimalism without loss of 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 that there is an output schema (which explains the return structure), the description doesn't need to duplicate that. However, the tool has no parameters and strong annotations, so the description is the main source of behavioral intent. It explains the what but not the 'why' – why an agent might want a 'path-free publication receipt' or what triggers its availability. This leaves a gap for an agent trying to decide if this is the right tool for a status-checking or workflow-progress scenario.

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

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

The tool has zero parameters and schema description coverage is 100% (trivially). The description adds no parameter details because none exist. However, it does explain what the tool returns (a receipt), which adds meaning beyond the empty schema. Baseline for 0 params is 4, and the description achieves this by providing return context.

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

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

The description explicitly states the tool returns a 'path-free publication receipt' for the current MCP process. The verb 'Return' and the specific object 'publication receipt' provide clear purpose. However, the term 'path-free' is somewhat technical and may not immediately convey what this receipt represents or why an agent would need it.

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 use this tool versus alternatives. Among siblings like governance_prepare_codex_dispatch or governance_get_capabilities, which also deal with receipts or status, there is no differentiation. The description does not state whether this is a status check, a setup requirement, or a diagnostic tool.

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

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

Annotations declare readOnlyHint: false, idempotentHint: false. The description explicitly confirms it is mutating and non-idempotent, adds that it is host-approved, accepts no record body, reports success separately for append vs. index refresh, and refuses replay. This fully compensates for the lack of annotations-driven behavioral details.

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

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

The description is compact (four sentences) and front-loaded with the core action. Every sentence adds important behavioral or usage constraints. It is efficient but could be slightly more structured (e.g., bulleted constraints), but remains clear and uncluttered.

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 mutation nature and the presence of an output schema, the description covers the main behavioral aspects: what it does, what it refuses, and how results are reported. It lacks explicit mention of error scenarios or return values, but the output schema reduces the need for that detail.

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

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

Schema description coverage is 0%, so the description must add meaning. It explains that draft_id, draft_sha256, and approval_receipt_id correspond to an approved pending draft and its approval receipt—tying them together contextually. It does not describe each parameter's format or constraints, but enough context is given for correct invocation.

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

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

The description clearly states it appends exactly one approved pending draft and refreshes derived indexes—a specific verb and resource. This distinctively separates it from siblings like research_prepare_ingest or research_pending_ingest_status, which handle draft preparation or status queries.

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 mentions constraints: it requires an approved pending draft, refuses replays, invalid approval, or modifications to the canonical ledger. It does not pair with any sibling tool, but the context of when-not-to-use (replay, invalid approval) is clear.

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

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

With no annotations, the description carries the full burden of behavioral disclosure. It explicitly states the tool does not modify canonical records, which is valuable for a health-report tool. It does not discuss return payloads or potential failure modes, but the output schema partially covers return structure.

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 is front-loaded with the verb and clearly communicates purpose and safety. Every word earns its place with no redundancy.

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 status tool with an output schema, the description is complete: it states what is reported and guarantees no modification. The phrase 'derived-index health' is slightly specific but adequate given the tool's simplicity and the presence of an output 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 tool takes zero parameters, so the schema already fully defines the input contract. Baseline of 4 applies; no parameter descriptions are needed.

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

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

The description uses a specific verb ('Report') and a clear resource ('derived-index health'), and the qualifier 'without modifying canonical research records' distinguishes it as a read-only diagnostic tool. Sibling tools are primarily governance and memory operations, so this stands apart clearly.

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 checking index health without side effects, but it does not explicitly state when to prefer this over alternatives or mention any exclusions. No alternative tools are named, so guidance is only implied.

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 provide readOnlyHint, idempotentHint, destructiveHint. The description adds value by clarifying that this tool returns metadata only (no content) and that it targets 'pending' drafts, which is a behavioral constraint. It does not contradict 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 clear sentence that front-loads the core action. It is appropriately concise, though it could be slightly more structured (e.g., separating purpose from parameters). 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 simple status-check tool with one parameter and an existing output schema, the description adequately conveys the core functionality. However, the complete lack of parameter explanation and missing guidance on error cases or usage context leaves gaps. The output schema may cover return format but not parameter semantics.

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

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

Schema description coverage is 0%, meaning the schema provides no description for the single parameter draft_id. The tool description does not elaborate on what the draft_id represents, how to obtain it, or any constraints (e.g., UUID format). This leaves the agent without critical information to correctly invoke the 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 uses a specific verb ('Return') and resource ('metadata for one pending immutable ingest draft') and clearly states what is excluded ('without its content'). It distinguishes from siblings like research_prepare_ingest (creates drafts) and research_commit_ingest (commits them) by focusing on status of pending drafts.

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 use this tool versus alternatives, no prerequisites (e.g., how to get a draft_id), nor any exclusions. The context of 'pending' is implied but not explicitly stated as a condition. There is no mention of alternative tools for committed drafts or for retrieving content.

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 provide no behavioral hints (all false), so the description carries the full burden. It discloses that the tool creates an immutable draft, validates input, and hash-binds paths. However, it does not specify error behavior, side effects of calling repeatedly, or the impact of missing prerequisites, leaving important behavioral gaps.

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 sentences with the core purpose front-loaded. It efficiently conveys validation, creation, immutability, and the prerequisite constraint. Minor inefficiency: the second sentence about source registration format could be more tightly integrated, but overall it avoids unnecessary detail.

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

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

For a tool with three parameters and a prerequisite, the description covers the main behavioral contract and a key constraint. However, it omits explanation of the required 'record' parameter and the return value (output schema is not shown but context indicates it exists). This leaves gaps for an agent to fully understand invocation expectations.

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 parameters. It only partially describes source_registrations by listing expected fields (path, source_id, source_type) and hints that approval_ref references the prerequisite approval. The required 'record' parameter is completely unexplained, and no details are given about optional source_registrations structure beyond the three fields.

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

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

The description clearly states the tool validates input and creates an immutable pending draft, distinguishing it from final record creation. It explicitly notes 'never a canonical record', differentiating from siblings like research_commit_ingest which likely finalizes the draft.

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 this tool is used before a commit step by mentioning the draft is pending. It specifies a prerequisite ('canonical human approval record must already exist') but does not provide explicit when-to-use or when-not-to-use guidance or mention alternatives beyond the context of 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?

The description clearly states 'without executing any route', disclosing the key behavioral trait of being read-only and non-destructive. Since no annotations are provided, this adds essential transparency. It could further detail what 'research profile' entails or authentication requirements, but the current disclosure is solid.

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 immediately states the purpose and key behavioral trait. Every word earns its place with no filler or redundancy. This is exemplary conciseness.

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

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

Given the tool's simplicity (no parameters, output schema present), the description covers the core action and safety profile adequately. A small addition about when to use this check (e.g., before ingestion or semantic setup) would make it fully complete, but current level is sufficient.

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

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

With zero parameters and 100% schema coverage (trivially), the baseline is 4 according to the rubric. The description does not add parameter information (there are none), which is acceptable given no parameters exist.

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 'Inspect' and identifies the resource as 'declared research profile', making the action clear. However, it does not explicitly distinguish this tool from sibling tools like research_index_status or research_semantic_models, which could also be inspection-oriented. A more explicit contrast would elevate it to 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 for non-destructive inspection, but provides no guidance on when to use this tool instead of alternatives, nor any exclusions or prerequisites. For a zero-parameter tool, the usage context is straightforward, but the lack of explicit guidance keeps it at a 3.

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 that the operation is read-only ('List') and that it avoids network calls ('without contacting a registry'). However, it does not mention potential side effects, performance characteristics, or what happens if no models are reviewed.

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 is front-loaded with the action and resource. Every word adds value, and there is no fluff or repetition. It is as concise as possible while still being informative.

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

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

Given the tool's simplicity (no parameters, output schema exists), the description covers the essential purpose and behavioral constraint. It tells what the tool lists and that it is local/offline. The presence of an output schema means the return format is handled elsewhere, so the description is sufficiently complete.

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

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

The input schema has zero parameters, so the description does not need to add meaning beyond the schema. The baseline for no parameters is 4. The description does not introduce any additional parameter understanding, which is acceptable.

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') and clearly identifies the resource ('reviewed local SentenceTransformer models'). It also adds a distinguishing constraint ('without contacting a registry'), which helps differentiate it from sibling tools that might involve registry or network calls.

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

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

The description provides some context about when to use this tool (listing models without a registry call), but it does not explicitly state when not to use it or mention alternative tools. No guidance is given for scenarios where models might need to be fetched from a registry or filtered.

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

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

Since annotations are absent, the description carries the burden. It discloses two behavioral traits: the tool performs no network or execution, and revision must be a full immutable commit SHA. These are useful, but it does not explain what the plan contains, whether it validates inputs, or what side effects (if any) it has. 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?

The description is extremely concise (one sentence) with no wasted words, but it is under-specified. While conciseness is good, the structure lacks necessary detail, making it less useful. It is not a tautology, but it does not earn a high score for structure because it omits key 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 6-parameter tool with no parameter descriptions in the schema and no annotations, the description is severely incomplete. It does not explain the nature of a semantic setup plan, the purpose of model_id, device choices, or the relationship to sibling research tools. Even though an output schema exists, the description alone leaves an agent without enough context to call the tool correctly.

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

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

Schema description coverage is 0%, so the description must compensate. It adds meaning to 'revision' by requiring a full immutable commit SHA, but it says nothing about model_id, device, auto_refresh, reuse_existing, or environment_manager. Since only one of six parameters is clarified, the description provides marginal value but is largely insufficient.

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 says 'Plan' but does not specify what is being planned. The name suggests 'semantic setup', but the description never mentions a resource or objective. It does not distinguish the tool from siblings like research_prepare_ingest or research_semantic_models. The purpose is vague and inferable only from the tool name.

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

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

No guidance is given on when to use this tool versus alternatives. It does not state use cases, prerequisites, or exclusions. The only mention is a constraint on the revision parameter, which is a parameter detail, not usage guidance. No sibling tools are referenced.

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