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

Descripton states returns raw JSON but does not disclose potential errors, authentication needs, or side effects. Since annotations are absent, description carries full burden but is minimally adequate.

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 concise sentences with action-verb front-loading. 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?

Given single parameter and no output schema, description is largely complete for a simple fetch operation. Could mention error behavior, but sufficient for typical use.

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

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

100% schema description coverage means schema already documents the parameter. Tool description does not add semantics beyond what schema provides. Baseline score of 3 is appropriate.

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

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

Descripton clearly states verb 'Fetch' and resource 'full AEO Protocol declaration' with specific URL path. Distinguishes from siblings like aeo_inspect or aeo_get_claim by focusing on raw document retrieval.

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 or when-not-to-use guidance. Implications from description suggest it's for fetching raw JSON, but lacks comparison with sibling tools.

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

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

With no annotations provided, the description must disclose all behavioral traits. It indicates a read operation and describes the not-found error, but lacks detail on side effects, authentication requirements, rate limits, or whether it modifies state. The bare minimum is covered.

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 front-loaded with the action. It contains no redundant words, efficiently conveying the core purpose and error handling. However, it could be expanded without losing conciseness.

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

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

Given no output schema and 0% schema coverage, the description should compensate with thorough details. It falls short: it does not describe the return value aside from 'claim object', nor does it explain the absolute necessity of origin. For a simple fetch tool, it is incomplete.

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 implies that claim_id is used for identification, but does not clarify the origin parameter (URI format) or any constraints. The schema itself has no descriptions, leaving both parameters largely undefined for the agent.

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 extracts a single AEO claim by ID, specifying the verb 'extract' and the resource 'AEO claim'. It also distinguishes itself from siblings like aeo_fetch and aeo_inspect by focusing on retrieval by ID and mentioning error behavior with available claim IDs.

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

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

No guidance on when to use this tool versus alternatives (e.g., aeo_fetch, aeo_inspect). There is no mention of prerequisites, contexts, or when not to use it. The description is purely functional.

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?

Despite no annotations, the description discloses the tool's lighter resource usage and outlines the output contents, adding meaningful behavioral context beyond the sparse schema.

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

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

Two sentences with no wasted words: first states purpose and output, second gives usage guidance. Front-loaded for quick comprehension.

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

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

For a simple tool with one parameter and no output schema, the description covers purpose, output contents, and usage guidance. Lacks mention of error handling or authentication needs, but is otherwise adequate.

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

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

Schema has 0% description coverage on the only parameter (origin). The description does not elaborate on this parameter, leaving its meaning and formatting unclear.

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

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

Description clearly states the tool returns a structured summary of an AEO declaration, listing specific fields (entity, source/verification counts, claim IDs, audit mode) and distinguishes itself from sibling aeo_fetch.

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

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

Explicitly notes it is 'cheaper than aeo_fetch for context-window-constrained agents,' providing clear context for when to use this tool over its sibling, though it does not state when not to use it.

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

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

With no annotations, the description carries the full burden. It states that no fetching occurs, indicating a non-destructive, read-only operation. However, it does not disclose potential errors, return format, or any side effects beyond the core behavior.

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

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

The description is a single 11-word sentence with no redundancy or unnecessary words. It is maximally concise while conveying the essential purpose and constraint.

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

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

For a simple one-parameter tool, the description is nearly complete: it specifies input, action, and a key constraint (no fetch). It lacks detail on the output format or structure, which could be helpful since there is no 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?

Schema description coverage is 0%, so the description must compensate. It mentions 'for an origin,' linking the parameter to the action, but does not explain what constitutes a valid origin (e.g., URI format, HTTPS required) or provide examples. The schema's format: uri is the only detail.

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 computes the canonical AEO well-known URL for an origin without fetching. It specifies the action (compute) and resource (canonical AEO well-known URL), distinguishing it from other well-known URL tools like aup_well_known_url or agent_card_well_known_url.

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 mentions 'without fetching,' implying it should be used when no network request is wanted, but it does not explicitly state when to use this tool versus alternatives like aeo_fetch or other well-known URL tools. No comparison or exclusions are provided.

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

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

No annotations are provided, so the description must cover behavioral aspects. It indicates the tool fetches a remote resource if url is given, but does not mention side effects, permissions, rate limits, or the nature of the structured summary. The description is too minimal for full transparency.

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

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

The description is two concise sentences, front-loading the purpose. Every word is necessary and there is 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?

Given the absence of an output schema and the presence of many sibling inspect tools, the description is vague about what the 'structured summary' contains. It lacks detail on output format, required fields, or how it differs from similar tools, making it incomplete.

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 adds significant meaning by explaining that 'url' is fetched by the server and 'document_json' is already-fetched content. This clarifies the intent of each parameter beyond the schema.

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

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

The description clearly states that the tool returns a 'structured summary of an Agent Card document' and specifies the two input options (url or document_json). It does not explicitly differentiate from sibling inspect tools, but the purpose is unambiguous.

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 explains the mutually exclusive parameter usage ('Pass EITHER url OR document_json'), which guides the agent on how to call the tool. However, it provides no guidance on when to use this tool versus other inspect/validate tools in the sibling list.

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

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

No annotations are present, and the description does not disclose behavioral traits such as idempotency, authentication needs, side effects, or return behavior beyond the minimal listing. The agent lacks transparency about what happens when the tool is called.

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

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

The description is a single sentence that front-loads the key information. Every word is necessary, with no fluff. It earns its place.

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

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

The tool has no output schema and 2 undocumented parameters. The description does not specify the return format or the relationship between parameters and agent identification. Given complexity and sibling tools, the description is incomplete.

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% (0% of parameters are described in the description). The description does not mention the two parameters ('url', 'document_json') nor explain how to use them. The agent has no semantic guidance beyond parameter names and types from the schema.

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

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

Description uses specific verb ('Return the list') and identifies the resource ('tools an agent declares'). It also specifies the information included (side-effect class and MCP Tool Card URI), making the purpose clear and distinct 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?

No guidance is provided on when to use this tool versus alternatives, nor any prerequisites or context for invocation. The description only states what it does, leaving the agent without hints for appropriate usage.

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 disclose behavioral traits. It states the tool validates against a schema, implying it checks conformance, but does not clarify if it is read-only, what the output is, or any side effects. Adequate but missing 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 a single sentence, concise and to the point. No unnecessary words, but could be slightly more informative without sacrificing brevity.

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

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

Given no output schema, no annotations, and only one parameter, the description omits crucial information about the return value (e.g., success/failure, validation errors) and any behavioral assumptions. It is not complete for an agent to reliably use the 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?

The single parameter 'document_json' is described only implicitly as the JSON document to validate. With 0% schema description coverage, the description adds minimal information about the parameter format or constraints beyond the schema's type string.

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 an Agent Card JSON document against a specific schema version (v0.1). The verb 'Validate' and resource are specific, distinguishing it from sibling tools that validate other card types or perform different actions.

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

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

No guidance on when to use this tool versus alternatives like tool_card_validate or tutor_card_validate. The description implies usage for agent card validation but lacks explicit context 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?

No annotations provided, so description carries burden. It discloses that the tool computes a URL without side effects, but lacks details on permissions, error behavior, or return format beyond the implied URL string.

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 concise sentence that immediately conveys the tool's purpose and the URL convention, with no redundancy or 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?

The description adequately explains the tool's function given its simplicity (2 parameters, no output schema). It implies the return value is a URL, but could explicitly state the output format for completeness.

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

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

Schema coverage is 0%, but description explains how origin and agent_id combine to form the URL, adding context beyond the schema's type definitions. However, it does not specify constraints like valid URI format for origin.

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

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

Description clearly states it computes the canonical Agent Card well-known URL for a given origin and agent_id, with the specific URL convention provided. This distinguishes it from sibling tools for other card types.

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 constructing Agent Card URLs, but does not explicitly state when to use this tool versus alternatives like tool_card_well_known_url or aup_well_known_url.

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 zero annotations, the description carries the full burden. It describes the output content but does not disclose behavioral traits: whether the tool is read-only, what happens on invalid input, error handling, or side effects. The agent must infer that it is a read operation without confirmation.

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, concise and free of fluff. However, it could be better structured with an action verb at the start and clearer separation between the output description and the listed fields.

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 single parameter and absence of output schema, the description should more fully explain input expectations and output format. It mentions fields but fails to specify the return type (e.g., JSON object) or what the structured summary looks like. For a simple tool, this is incomplete.

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 parameter 'document_json' has no description in the schema (0% coverage). The tool description does not clarify that this parameter is the input JSON representing the AI Evidence object, nor does it specify the expected format or constraints. The agent is left to guess the parameter's role.

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

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

The description clearly states it returns a structured summary of an AI Evidence object and lists key fields (claim text, source metadata, etc.), which helps distinguish it from sibling tools like ai_evidence_validate or ai_evidence_verify_hash. However, it uses a noun phrase ('Structured summary...') instead of an active verb ('Returns...'), which slightly reduces clarity for an AI agent.

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 (e.g., ai_evidence_validate for validation or ai_evidence_verify_hash for hash verification). There is no mention of prerequisites, typical use cases, or when not to use it.

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

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

With no annotations, the description carries full burden for behavioral disclosure. It only states 'validate', implying a read-only check, but does not clarify whether the tool modifies data, requires special permissions, or has side effects. The behavioral transparency is insufficient.

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

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

The description is a single sentence, which is concise in length but under-specified. It fails to convey essential information, making it insufficiently informative. Conciseness should not come at the cost 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 the lack of annotations, output schema, and parameter descriptions, the description is severely incomplete. It does not explain what validation entails, what results to expect, or how to use the parameter correctly. The tool definition leaves the agent with minimal guidance.

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

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

The sole parameter 'document_json' has no description in the schema (0% coverage). The tool description adds no meaning beyond the parameter name. The agent cannot infer the expected format, constraints, or purpose of the JSON string.

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 (validate), the resource (AI Evidence object), and the specific schema version (v0.1). This provides a specific, unambiguous purpose that distinguishes it from sibling tools like ai_evidence_inspect or ai_evidence_verify_hash.

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 about when to use this tool versus alternatives. There is no mention of prerequisites, common scenarios, or exclusions. The description lacks context for decision-making.

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 explains the hashing algorithm (SHA-256, canonical UTF-8 form) and the comparison logic. It does not contradict annotations (none provided). It lacks explicit statements about side effects or permissions, but for a read-only verification tool, the transparency is good.

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 fluff. It directly states the operation, canonical form requirements, and return values. Highly concise and well-structured.

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

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

For a simple hash verification tool with two parameters and no output schema, the description covers the main logic and return format. It does not fully document the document_json parameter or error cases beyond hash mismatch. Minor gaps, but generally complete.

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

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

Schema coverage is 50% (only candidate_text has a description). The tool description adds value by specifying how candidate_text is used (hash computation) and implying that document_json contains evidence, but it does not explain document_json's role or structure. Thus, description partially compensates but leaves a 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 action: compute SHA-256 over candidate_text and compare to evidence's content_hash. It returns ok=true or an error object with details. This is specific and distinct from sibling tools like disclosure_verify_artifact_hash.

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 verifying hash integrity of evidence text, but it does not explicitly state when to use this tool versus alternatives like disclosure_verify_artifact_hash or attestation_verify. No guidance on prerequisites or conditions is provided.

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

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

With no annotations, the description must disclose behavior fully. It explains the canonical JSON normalization (sorted keys, no whitespace) and that identical values yield identical hashes, but does not specify the output format (e.g., hex string) or any side effects.

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

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

The description is two sentences, front-loading the action and algorithm. Every sentence adds value: first defines operation, second provides context and property of the hash. No wasted words.

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

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

Given a single parameter and no output schema, the description adequately covers purpose, input processing, and usage context. However, it omits the return format (e.g., hex string), which an agent may need for downstream tasks.

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 covers the single parameter 'body' with a description. The tool description adds valuable context about canonical JSON processing (sorted keys, no whitespace) that enriches the schema's minimal description.

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 computes a SHA-256 canonical-JSON hash, specifying the algorithm and input type. It distinguishes itself from sibling hash-verification tools like ai_evidence_verify_hash by focusing on computation rather than verification.

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 by naming specific services, but lacks explicit guidance on when to choose this tool over siblings. No when-to-use or when-not-to-use instructions are provided for an agent selecting among hash-related tools.

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

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

With no annotations, the description carries full burden. It discloses the tool's behavior: structural validation, reporting signature length, and surfacing fields. However, it does not state whether it is read-only, what errors occur if validation fails, or any authorization requirements. The behavior is largely transparent but could be more explicit.

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 zero wasted words. It front-loads the core action (pretty-print with structural validation) and then lists key outputs. Every sentence earns its place.

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

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

For a simple inspect tool with one parameter and no output schema, the description covers purpose, validation details, and surfaced fields. It could mention error handling or read-only nature, but overall it is sufficiently complete 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?

Schema description coverage is 0% (no param description in schema). The description adds value by naming the parameter as 'attestation envelope' and specifying that it surfaces 'key_url + signed_at' fields, implying the object's structure. However, it does not detail the expected internal fields or validation requirements, leaving some 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 states the verb (pretty-print, validate) and resource (Attestation envelope). It specifies three concrete outputs: confirming required fields, reporting signature byte-length, and surfacing key_url/signed_at. This differentiates it from sibling inspect tools for other envelope types like prompt_provenance_inspect or disclosure_inspect.

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 inspecting and validating an attestation envelope, but does not explicitly state when to use this tool over alternatives or provide exclusions. The context is clear enough for an agent familiar with the domain to select it appropriately.

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

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

With no annotations, the description carries the full burden and mostly succeeds: it discloses the internal step order (canonical hash recompute, then signature check) and, critically, an explicit negative - it does not bind the supplied key to the claimed key_url or signer. That caveat is a real security-relevant trait. It stops short of top marks because it never says what happens on failure (exception vs. false result) and gives no guarantee about the hash algorithm convention.

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

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

Three tight sentences, each doing distinct work: what it verifies, how it verifies, and what it deliberately does not verify. The limitation is placed immediately after the mechanism, so the most decision-relevant caveat is front-loaded rather than buried.

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 nested-object, three-required-parameter verification tool with no annotations and no output schema, the description covers the verification semantics well but leaves the result contract unspecified - an agent cannot tell whether a failed signature check returns a boolean, an error, or a structured report. The absence of an output schema makes that gap more costly than it would otherwise 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 67%, so the baseline is around 3. The description restates the public_key format (64-char hex or base64) that the schema already documents, and clarifies that the key is caller-supplied rather than resolved, but adds nothing about the nested attestation fields or what 'body' must be (raw bytes, JSON, canonical form?).

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

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

States a specific verb (verify) and resource (ed25519 Attestation envelope) plus the exact mechanism: recompute the canonical hash, then verify the signature over the hash string. It does not name the sibling tools attestation_canonical_hash or attestation_inspect to distinguish itself, so it falls just short of the top tier.

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

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

Usage is implied by the verb - an agent can infer this is the tool to run when it holds an envelope, a body, and a trusted key. The 'Does not verify that the supplied key belongs to the claimed key_url or signer' sentence functions as a partial scope exclusion, warning the agent not to use this for trust-chain validation, but no alternative tool is named for that case.

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

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

With no annotations, the description fully bears responsibility for behavioral disclosure. It describes the verification steps and return shape, clarifying it is a read-only analysis. However, it does not explicitly state it is non-destructive or mention authorization requirements.

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 efficiently convey the action, verification details, and return shape. No redundant information, front-loaded with the core operation.

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 covers the return shape and core action, but omits parameter structure and does not provide examples or edge case behavior. For a verification tool, more detail on the expected input format would improve completeness.

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

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

The sole parameter 'events' is an array of objects, but the description provides no additional details about expected structure (e.g., required fields like event_id, prev_hash, hash). With 0% schema coverage, the lack of parameter description forces the AI to guess or rely on external 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 clearly states the tool's action: walk an array of GovernanceEvents top-to-bottom and verify the hash chain, including specific checks (monotonic event_id, prev_hash linkage, self-consistency). It also specifies the return shape, making the purpose distinct and actionable.

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

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

No explicit guidance on when to use this tool versus alternatives like audit_chain_verify_live. The description implies use cases by detailing the verification logic but omits when/not-to-use or prerequisites.

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

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

With no annotations, the description carries the full burden and does so well: it discloses the remote-service dependency, the required credentials, the structured-error failure mode, and named return fields (valid, checked, first_break_at, reason) in the absence of an output schema. It also bounds the claim explicitly (chain continuity only, not truthfulness/authorization/completeness/legal compliance), which prevents over-reading of results.

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

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

Three tight sentences, front-loaded with what is checked, immediately followed by what is not checked, then return shape and prerequisites. No filler and no repeated schema content.

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

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

For a zero-parameter tool with no output schema, the description supplies everything an agent needs: the remote dependency, required configuration, failure behavior, and the names/meaning of the return values. The explicit scope limitation is a valuable addition that no structured field conveys.

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

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

The tool takes zero parameters, so the baseline is 4. The description does add useful non-schema context by naming the two environment variables that must be configured, though these are configuration rather than call arguments.

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

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

States a specific verb (verify) and resource (server-side hash chain) plus the target (the configured audit-stream service), which distinguishes it from the local sibling audit_chain_verify. An agent can tell immediately that this performs a live remote verification rather than verifying a supplied chain.

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

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

The description implies the usage context ('ask the configured audit-stream service') and states the configuration prerequisite (AUDIT_STREAM_URL/AUDIT_STREAM_TOKEN), but never explicitly contrasts this with audit_chain_verify or says when to prefer one over the other. Usage is inferable rather than stated.

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

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

Describes computation of hash and default behavior for prev_hash and timestamp, but no annotations are present. Missing details on side effects, permissions, idempotency, or error handling. Provides moderate transparency.

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

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

Two concise sentences, front-loaded with purpose, no wasted words. Second sentence provides critical constraints. Efficient and well-structured.

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

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

No output schema or annotations; 6 parameters with low schema coverage. Description misses source and payload semantics, return value format, validation behavior, and error conditions. Incomplete 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?

With only 33% schema coverage, description adds meaning to event_id (assigned), kind (enum list), prev_hash (default), timestamp (ISO-8601 default), but source and payload remain unexplained. Partially compensates for gaps.

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

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

The description clearly states the tool builds a ready-to-POST audit-stream-py GovernanceEvent, with specific operations: assigns event_id, computes hash, links prev_hash. It lists the 19 allowed kinds, distinguishing it from sibling audit and decision 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?

Implied usage for preparing an audit event before posting, but no explicit guidance on when to use vs alternatives (e.g., audit_event_emit, audit_event_inspect). No exclusions or prerequisites mentioned.

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

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

With annotations already covering the safety profile, the description adds substantial non-obvious behavior: the bearer token authenticates the MCP process rather than the claimed producer/tenant, the server assigns event_id/timestamp/prev_hash/hash, and the returned receipt does not prove durable storage or completeness. These are exactly the caveats an agent needs before emitting a governance event.

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

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

The core action and endpoint are front-loaded in the first sentence, and each following sentence carries a distinct caveat (auth scope, approval/privacy, server-assigned fields, receipt limits). It is dense but earns its length; only the closing receipt caveat could be trimmed without much loss.

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 non-idempotent, open-world mutation with no output schema and a nested payload object, the description covers the essential ground: where it POSTs, what is sent, what auth means, safety/privacy constraints, server-assigned fields, and the return shape. An agent has enough to call 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 100%, so kind, source, and payload are already fully documented in the schema, including the caller-asserted source warning and the 'other' kind fallback. The description only restates 'kind, caller-asserted source, and payload' without adding format or validation detail beyond the schema, so the baseline 3 applies.

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

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

The description states a precise verb+resource: 'POSTs a governance event to the audit-stream-py instance configured by AUDIT_STREAM_URL and AUDIT_STREAM_TOKEN.' That clearly separates it from read-side siblings like audit_events_query or audit_event_inspect. However, it never names the closest alternative, audit_event_compose, so sibling selection still requires inference.

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

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

It gives concrete preconditions: obtain user approval before recording, and omit secrets/personal data unless the service is approved for them. This is clear operational context, but it stops short of an explicit when-to-use-this-vs-a-sibling statement (e.g., compose vs emit, or when the token is not configured).

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 burden falls on the description. It discloses behavioral traits: structural validation (required fields, kind check, payload key list) and a self-consistency check (hash match). This goes beyond a simple 'inspect' and gives the agent clear expectations. No contradictions.

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 sentence with multiple clauses, but it efficiently conveys the main action and key validations. It is front-loaded ('Pretty-print...') and contains no unnecessary words. Could be slightly clearer by breaking into bullet points.

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 (single param, no output schema, but multiple validation steps), the description covers the input and checks but does not mention the return value format (e.g., pretty-printed string, validation result, or error). This leaves some ambiguity about the output.

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 'event' is an object with 0% schema description coverage. The description mentions fields like hash, kind, payload but does not specify the expected structure or constraints. Some meaning is added, but it is insufficient for full parameter understanding.

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

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

The description clearly states the tool's purpose: 'Pretty-print one GovernanceEvent with structural validation' and lists specific checks (required fields, known/unknown kind, payload key list, self-consistency check). It is specific to GovernanceEvent and distinguishable from sibling tools like ai_evidence_inspect or disclosure_inspect.

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 inspecting and validating a single GovernanceEvent but does not explicitly state when to use this tool versus alternatives (e.g., audit_event_compose, audit_chain_verify, or other inspect tools). No when-not-to-use guidance is provided.

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

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

With no annotations, the description carries the full burden and does well: it discloses the required environment configuration (AUDIT_STREAM_URL, AUDIT_STREAM_TOKEN), the mutual-exclusivity of the filters, the return shape (events array plus count), the caveat that source labels are caller-asserted, and the structured-error behavior when unconfigured.

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

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

Three front-loaded sentences with no filler: the core action comes first, then the filter constraint and return shape, then the error/config caveat. Every sentence carries information an agent needs.

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 3-optional-parameter read tool with no output schema and no annotations, the description covers config prerequisites, filtering semantics, return structure, and error handling. It stops short of naming sibling alternatives or pagination behavior, but nothing critical to invoking it correctly is missing.

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

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

Schema coverage is 100%, so the schema already documents each parameter and a baseline of 3 would be defensible. The description adds real value beyond the schema by stating that kind and source filters cannot be combined, a parameter-interaction rule the schema does not encode.

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

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

States a specific verb (GET) and resource (recent governance events from a running audit-stream-py instance), so the agent knows it is a read/query operation. It implicitly distinguishes itself from siblings like audit_event_emit, audit_event_compose and audit_event_inspect, though it never names an alternative explicitly.

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

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

The phrase 'optionally filtered by kind or source' implies how to call it, and 'The service does not combine both filters' hints at the constraint. However, there is no explicit statement of when to reach for this tool versus audit_event_inspect or the chain-verify siblings, 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?

No annotations are provided, so the description carries the full behavioral burden and does so well: it discloses the return shape { allowed, policy_id, disclosure_id, violations[] } and clarifies the critical semantics that allowed=true means only these eight checks passed, not general compliance. It omits operational traits such as auth requirements or fetch failures when aup_url is unreachable.

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 dense sentences that are front-loaded with the core action and the check list; the return contract and exclusions follow. Every clause carries information, though the check enumeration is long enough that density borders on crowding.

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

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

There is no output schema, so the description correctly compensates by naming the return fields and the exact meaning of allowed=true. Combined with the explicit non-coverage list, an agent can call this correctly; only operand-provision details (URL vs inline JSON behavior, error cases) are left to the 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?

Schema description coverage is 100%, so the schema already documents aup_url (server-fetched), aup_json, and disclosure_json. The description adds no syntax or format guidance beyond the schema, which is the expected baseline when the schema does the heavy lifting.

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

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

States a specific verb (compare), two specific resources (AUP and Student AI Disclosure), and enumerates the eight checks performed, so the agent knows exactly what the tool does. The one gap is sibling differentiation: the sibling list contains a near-twin named 'disclosure_aup_check' plus 'aup_validate'/'aup_inspect', and the description never says how this differs from them.

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

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

The description gives a clear when-not scope: it explicitly lists what it does NOT verify (policy scope, tool/vendor requirements, parent consent, Tutor Cards, legal compliance) and states 'is not an enforcement decision', which tells the agent this is advisory only. It stops short of naming an alternative tool to use for the excluded concerns, so routing is left partly to inference.

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

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

No annotations provided, so description carries full burden. Only states it returns validated JSON; no details on error handling, authentication, rate limits, or side effects. Minimal beyond basic function.

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?

Extremely concise, one sentence with no redundant information. Front-loaded with verb and resource.

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?

Basic fetch tool with one parameter and no output schema. Description covers core purpose but lacks completeness on error cases or expected output structure. Adequate for a simple tool.

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

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

Schema coverage 0% and description does not add meaning beyond the schema. The parameter 'url' is only mentioned as 'from a URL', no additional format, validation, or constraints explained.

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

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

Clearly states the verb 'fetch', the resource 'Classroom AI AUP', and the input (URL) and output (parsed validated JSON). Differentiates from siblings like aup_validate and aup_inspect by specifying source from URL.

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?

Indicates the basic purpose but lacks explicit guidance on when to use vs alternatives or when not to use. For a simple fetch tool, usage is implied, but no direct comparisons 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?

No annotations provided; description states it returns a structured summary, suggesting a read operation. However, it does not explicitly disclose side effects, error behavior, or whether authentication is needed. The output content is described, but behavioral context is incomplete.

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

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

Single sentence is clear and lists output components concisely. However, it is not structured into sections for usage or parameters, and could benefit from front-loading the action more directly.

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?

Describes output fields in detail, which is useful given no output schema. However, it fails to explain input parameters or default behavior, leaving gaps for a tool with no required parameters.

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

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

Schema has two optional parameters (url, document_json) with 0% description coverage. The description does not mention these parameters, leaving the agent without guidance on how to specify the AUP source or that both are optional.

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

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

Description clearly states it provides a structured summary of a Classroom AI AUP, listing specific fields like policy identity and use counts. This distinguishes it from sibling tools such as aup_fetch (raw retrieval) and aup_check_compliance (compliance checking).

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

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

Implies usage for obtaining a structured summary, but lacks explicit guidance on when to use versus alternatives like aup_fetch or aup_validate. No indications of prerequisites or when not to use the 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?

With no annotations, the description carries full burden. It discloses validation rules (e.g., 'course scope requires non-empty course_ids'), but omits error behavior or return format. Adequate but incomplete.

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 paragraph of three sentences, front-loaded with the primary action. Contains no redundant 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?

As a validation tool with one parameter and no output schema, the description fails to explain the return value (e.g., pass/fail, error list). It also lacks examples or details on how validation results are communicated.

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?

Only parameter is document_json (string) with no schema description. The description implies the parameter is a JSON string of the AUP document but does not explicitly state its format or requirements.

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 'Validate a Classroom AI AUP JSON document against the v0.1 schema,' using a specific verb and resource. It distinguishes itself from sibling validation tools by focusing on AUP documents and listing specific conditional rules.

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 like tool_card_validate or disclosure_validate. The description lacks usage context or prerequisites.

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

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

The description implies a safe, read-only computation with no side effects. However, without annotations, it lacks details on error behavior, idempotency, or any special requirements.

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?

Extremely short, which is good for conciseness, but it omits crucial information about the parameter and return value. It could be improved with minimal additions.

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 for a simple tool, the description lacks completeness by not explaining the parameter's role or what the output looks like. With no output schema, the description should at least hint at the return format.

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

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

The only parameter 'origin' is not described at all. With 0% schema coverage, the description should explain how origin affects the result, but it only gives the static URL path.

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

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

Clearly states the tool computes a specific well-known URL and provides the exact path. However, it does not differentiate from sibling tools like aup_fetch or aup_validate, which could be confusing.

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

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

No guidance on when to use this tool vs alternatives such as aup_fetch or aup_validate. The description does not specify context 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?

No annotations provided, so description must cover behavior. It explains validation conditions but does not disclose side effects, persistence, or permissions. Adequate for a non-destructive linking operation.

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

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

Three sentences, front-loaded with purpose, no superfluous words. Every sentence earns its place.

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

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

Describes workflow and validation but does not mention return value or whether the card is mutated in-place or returned. Given no output schema, more detail on output would be helpful.

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

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

Schema coverage is 100%, but description adds value by specifying validation criteria for prev_card_hash (64-char hex) and prev_chain_index (non-negative integer), which are not in 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?

Clearly states the tool links a new card to its predecessor by setting chain_index and prev_card_hash, with validation. Explicitly tells to call claims_card_sign next, differentiating from sibling tools like claims_card_sign.

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?

Provides a clear next step ('Call claims_card_sign next') and describes validations, but lacks explicit when-not-to-use or alternative tools. However, the context of chaining cards 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 must fully disclose behavior. It states it's a summary and cheaper, but does not mention that it is read-only, whether it validates input, or error handling. Lack of side-effect disclosure is a 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?

Two concise sentences. First introduces the tool's output and lists key fields. Second provides a cost comparison. No wasted words.

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

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

Given only one parameter and no annotations or output schema, the description covers the tool's purpose and output sufficiently. It lists the output fields, which compensates for the missing output schema. Minor gaps in error/validation behavior.

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

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

Schema coverage is 100% with a brief description of the 'document' parameter. The tool description adds that it expects a 'Claims Decision Card JSON', which clarifies the schema's 'parsed object'. No additional semantic value beyond schema.

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

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

The description clearly states the tool provides a structured summary of an AI Claims Decision Card, listing specific fields. It differentiates from full card reading, but does not explicitly differentiate from sibling tools like decision_card_inspect.

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

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

No explicit guidance on when to use this tool vs. alternatives like claims_card_validate or claims_card_chain. The phrase 'cheaper than reading the full card' implies a use case, but lacks when-not-to-use 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 fully covers behavioral traits: recursive key sorting, field exclusion, and output format. It is transparent about the pure computational nature, though it omits authorization or error handling 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?

Two concise sentences, front-loaded with the core purpose, and no extraneous information. Every sentence adds value.

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 complex nested input and lack of output schema, the description adequately explains the output format (64-char hex) and key hash behavior. It could mention validation or errors but remains functional.

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

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

Schema coverage is 100%, and the description adds meaning by explaining the document is a Claims Decision Card and which fields are stripped before hashing, complementing the schema's brief description.

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 computes a canonical SHA-256 hash for ed25519 signing, specifying key behaviors like recursive key sorting and exclusion of specific fields. It clearly distinguishes itself from sibling tools like decision_card_signature_check.

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 indicates the tool is a preprocessing step before offline signing, which sets usage context. However, it does not explicitly state when not to use it or provide alternative tools for similar tasks.

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

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

With no annotations, the description carries the full burden and does well: it discloses the return shape (first schema issue or { valid, claims_card_id, version }) and precisely bounds validation scope. It omits error/idempotency behavior, but the scope 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?

Three tight sentences, front-loaded with the core action and return contract, with the limitation sentence last. Every sentence earns its place.

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

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

No output schema exists, yet the description explains the return value (first issue or the success object) and gives explicit scope boundaries. For a single-parameter validator with no annotations, nothing an agent needs to call it correctly 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?

Only one parameter (document) with 100% schema coverage; the schema already documents it as the parsed Claims Decision Card JSON object. The description adds no syntax or format detail beyond the schema, so the baseline 3 is appropriate.

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

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

States a specific verb (validate) and resource (AI Claims Decision Card) and scopes it precisely to the bundled v0.1 structural schema, covering required fields, enums, ranges, and attestation shapes. Clearly distinguishable from siblings like claims_card_inspect, claims_card_chain, and claims_card_sign.

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

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

Explicitly lists what the tool does NOT do (signatures, evidence authenticity, coverage decision, legal compliance), which implicitly routes the agent to sibling validators/verifiers. No positive when-to-use clause or named alternative, but the exclusions provide strong contextual boundaries.

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 full behavioral disclosure. It states the tool returns a parsed, schema-validated JSON document, which is helpful, but omits details like error handling, idempotency, or whether it's read-only. Acceptable but not thorough.

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, no fluff, front-loaded with verb and resource. Every word serves a purpose.

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

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

Given the low complexity (1 required param, no output schema), the description covers basic functionality. However, it lacks details on error scenarios (e.g., invalid URL, unparseable card) and does not leverage sibling context to set expectations. Sufficient but not comprehensive.

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

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

Schema coverage is 0% (no descriptions on parameters). The only parameter 'url' has a format constraint but the description adds no beyond that. It mentions 'from a URL' but doesn't specify allowed schemes or structure. Parameter semantics are weak.

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

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

Clearly states the action (fetch), the resource (Clinical AI Card), and the return value (parsed, schema-validated JSON). This differentiates it from sibling tools focused on other card types (e.g., tutor_card_fetch, decision_card_fetch).

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

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

No explicit guidance on when to use this tool vs. alternatives like tutor_card_fetch or decision_card_fetch. The context implies it's for Clinical AI Cards, but the agent isn't directed to choose this over siblings. Adequate but minimal.

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

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

No annotations exist, so the description bears full responsibility for disclosing behavioral traits. It does not mention whether the tool is read-only, what happens on invalid inputs, authentication needs, rate limits, or any side effects. The listed content categories hint at output but not behavior.

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

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

The description is a single run-on sentence that packs many categories with slashes and parentheses. While it front-loads the core purpose, the structure is dense and could be clearer (e.g., using bullet points). It is not excessively long but lacks readability.

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

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

Given the lack of annotations and output schema, the description should cover input usage, output format, and behavioral context. It only describes the summary content, leaving the agent without critical information about how to invoke the tool and what to expect.

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 2 parameters (url, document_json) with 0% description coverage, and the tool description does not mention these parameters at all. The agent receives no guidance on how to use url versus document_json or what formats are expected.

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 produces a 'Structured summary of a Clinical AI Card' and enumerates the specific categories covered (system identity, clinical context, regulatory posture, etc.). This is a specific verb+resource combination that distinguishes it from siblings like clinical_ai_fetch (fetch raw card) or clinical_ai_validate (validate).

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 does not mention that clinical_ai_fetch retrieves raw data or that clinical_ai_validate checks validity. The agent must infer usage without any explicit context about tool selection.

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

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

No annotations provided, so the description carries the full burden. It discloses that the tool enforces specific headline rules (autonomy, SaMD, FDA, PHI, bias_audit). This gives good behavioral context beyond a simple 'validate' statement. It does not mention side effects, but validation is typically read-only.

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: the first states the main action, the second lists the enforced rules. No redundant or wasted words. It is front-loaded and efficient.

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 single parameter and no output schema, the description explains the validation logic well. However, it does not describe what the output looks like (e.g., success/failure, error details). This is a minor gap for a validation 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?

The schema already describes the parameter as 'Clinical AI Card as inline JSON.' The tool description adds meaning by specifying the schema version (v0.1) and the headline rules enforced, which goes beyond the schema definition.

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 validates a Clinical AI Card JSON document against a v0.1 schema and lists specific enforced rules. It distinguishes from sibling tools like clinical_ai_fetch or clinical_ai_inspect by focusing on validation.

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 indicates the tool is for validation against a schema, but does not explicitly state when not to use it or mention alternatives. Given the sibling tools for other card types, it provides clear context for its use case.

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

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

No annotations are provided, so the description carries the full burden. It only states the computation without disclosing any behavioral traits (e.g., side effects, error handling, or that it is a pure string operation).

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

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

The description is a single concise sentence that communicates the essential purpose efficiently. It is front-loaded but could be slightly more informative without becoming verbose.

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 URL computation tool, the description is mostly adequate, but it does not explicitly state the return value (the URL string). Given no output schema, a brief note on output would improve completeness.

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

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

The description adds context to system_id via the URL pattern, but origin is not elaborated. With 50% schema description coverage, the description partially compensates but does not fully explain both parameters.

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

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

The description clearly states the tool computes a specific well-known URL for Clinical AI Card, providing the URL pattern. It distinguishes from sibling well-known URL tools (e.g., agent_card_well_known_url) by specifying the Clinical AI Card context.

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

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

The description implies the tool is for computing this URL but does not explicitly state when to use it versus alternatives. No guidance on when not to use or prerequisites, leaving the agent to infer usage.

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

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

No annotations are provided, so the description carries the burden. It mentions parsing and schema validation, which gives some behavioral insight. However, it does not disclose error handling, side effects, or whether the operation is read-only. The description is adequate but not rich.

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

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

The description is two short sentences, front-loaded with action and resource. Every sentence adds value: first sentence states what it does, second describes the result. No fluff or 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?

Given the tool has only one parameter and no output schema, the description covers the essential: action and return format. However, it lacks information about error behavior (e.g., invalid URL) and assumes the reader understands 'Decision Card'. Still, it is reasonably complete for a simple fetch 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?

The only parameter 'url' is a URI string. Schema description coverage is 0%, so the description must compensate. It only loosely ties to the parameter by stating 'from a URL' but does not specify URL format, accepted schemes, or that the parameter is required (which is in the schema). Minimal added value beyond the schema.

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

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

The description clearly states the action ('Fetch'), the resource ('AI Procurement Decision Card'), and the source ('from a URL'). It also specifies the output ('parsed, schema-validated JSON document'). Among sibling tools, this distinguishes itself by being specific to decision cards and highlighting validation behavior.

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 context (fetching a card by URL) but does not provide explicit guidance on when to use this tool versus alternatives like decision_card_inspect or decision_card_validate. No when-not-to scenarios are mentioned.

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

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

No annotations are provided, so the description carries full behavioral burden. It discloses the complete mapping rules from rubric results to status and states that an unsupported result returns an error, never an approval. It does not state whether the operation is read-only or has side effects, but the term 'preview' implies non-persistence.

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

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

The description is three tightly written sentences that are front-loaded with the core action, followed by the detailed mapping logic and an edge-case rule. Every sentence contributes essential information with no wasted words.

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

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

Given the tool's complexity (inference from an enum-based rubric), no output schema, and no annotations, the description provides the critical mapping rules and error behavior. It is nearly complete, though it omits details on the input structure (e.g., the 'id' field) and the exact return shape beyond 'decision.status'.

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

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

Schema description coverage is 0%, so the description must compensate. It explains the semantics of the 'result' enum values in terms of their effect on the inferred status, which adds partial value. However, it never mentions the required 'id' field or the array-of-objects structure of the 'rubric' parameter, leaving 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 uses specific verbs ('Validate', 'infer') and names the resource ('each rubric row', 'decision.status'), making the core purpose clear. However, it does not explicitly differentiate itself from the sibling 'decision_card_validate', leaving some ambiguity about when this inference tool is preferred over the 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 by describing the inference logic, but it provides no explicit when-to-use guidance or alternatives. With a close sibling ('decision_card_validate'), an agent must infer that this tool is for computing a preview status from raw rubric rows rather than validating a card structure.

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 should disclose behavioral traits like read-only nature, error conditions, or auth requirements. It merely lists output fields and omits such 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 a single sentence listing fields, which is concise but not front-loaded with key usage information. It gets the point across but could be better structured.

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

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

Given no output schema, no annotations, and two undefined parameters, the description lacks input guidance, error handling context, and output format details beyond field names.

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

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

Schema description coverage is 0%, and the description does not explain the two parameters (url, document_json) or their relationship, leaving the agent clueless about how to provide input.

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

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

The description clearly identifies the resource ('AI Procurement Decision Card') and the action ('inspect'), and lists specific output fields, distinguishing it from sibling inspect tools for other card types.

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 outlines what the tool returns but does not provide guidance on when to use it versus alternatives like decision_card_fetch or decision_card_validate, nor does it explain input options.

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. It discloses the main outputs (count, method/key/timestamp, hash) but lacks details on side effects (likely read-only), error conditions, or permissions. The description is adequate but not exhaustive.

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 packs essential information, but it could be improved by breaking it into shorter phrases or using bullet points for readability. Nonetheless, it is efficient and contains no superfluous words.

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

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

Given no output schema and no annotations, the description covers the main outputs and purpose but lacks details on return format, error handling, and how to choose between url and document_json. It is sufficient for basic understanding but not 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 coverage is 0%, and the description does not explain the parameters url and document_json. It only mentions the card's signatures block without clarifying how each parameter is used or that they are alternatives. This leaves the agent to infer parameter semantics from the schema alone.

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

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

The description clearly states the tool performs a structural check on the signatures block of a Decision Card, specifically counting signers and showing method/key/timestamp. It also explicitly mentions returning the canonical-JSON hash and pairing with attestation_verify, differentiating it from sibling tools like decision_card_inspect or attestation_verify.

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 as a precursor to cryptographic verification via attestation_verify, providing clear context. However, it does not explicitly state when not to use this tool or compare with alternatives like decision_card_validate.

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 present, the description carries the full behavioral burden and does well: it declares read-only semantics, the exact output flags (preview_only=true, enforceable=false), the error behavior for approved cards, and the security warning about not using output as a grant. It does not explain how inputs are resolved or what other failure modes exist.

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

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

The core purpose and the preview_only/enforceable flags are front-loaded, and every clause carries information. The middle clause is long and dense, but nothing is redundant padding.

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

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

For a two-parameter tool with no annotations and no output schema, the description covers the safety and status semantics well but is silent on the inputs and on the shape of the returned bundle beyond two booleans. An agent could still invoke it, but with avoidable ambiguity about what to pass.

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 neither of the two parameters (url, document_json) is mentioned anywhere in the description. The agent must infer that url points at a Decision Card document and document_json is its inline content; that inference is plausible from context but never stated, so the description fails to compensate for the coverage gap.

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

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

The description states a specific action and scope: producing a read-only deny preview bundle for Decision Cards in rejected, withdrawn, expired, or pending states. This meaningfully distinguishes it from siblings like decision_card_inspect or decision_card_validate, though the name itself is opaque enough that it relies heavily on the description.

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

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

It gives an explicit when (non-approved card statuses), an explicit when-not (approved statuses error out), and names the alternative authority (the live policy engine) that must be used instead for enforceable bundles. The closing prohibition on treating output as an access grant leaves nothing to inference.

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

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

No annotations provided, so description carries full burden. It discloses that it 'enforces conditional rules', which is behavioral. However, it does not explain return behavior on validation failure/success, side effects, or performance characteristics. Adequate but not comprehensive.

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

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

Two sentences, front-loaded with purpose, then lists specific rules. No fluff or repetition. Every sentence provides necessary information.

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

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

Given no output schema and one parameter, description covers validation rules well. It lacks explicit mention of return format (e.g., success/failure, error details), which would be helpful for completeness. Still, the core behavior is clear.

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

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

Schema description coverage is 100%, but the description adds value by detailing the conditional rules that govern validation (e.g., status-specific requirements, publication rules). This context goes beyond the schema's parameter description.

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

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

Description clearly states it validates 'AI Procurement Decision Card JSON document against the v0.1 schema', specifying the exact resource and action. It lists conditional rules, distinguishing it from sibling tools like decision_card_inspect or other card validation 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?

Description implies use for validation but does not explicitly state when to use vs alternatives like decision_card_inspect or decision_card_fetch. No 'when not' guidance is provided, though the purpose 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?

No annotations are provided, so the description bears full responsibility. It only states the function without explaining whether it is a pure computation, validates inputs, or makes network calls. No disclosure of return type or error behavior.

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

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

The description is a single, clear sentence with no extraneous words. It efficiently conveys the tool's core 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?

Given no output schema, the description should explain the return value (e.g., it returns the URL as a string). It also lacks details on input validation or error cases. For a simple URL construction, the description is incomplete.

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 50% (only decision_id has a description). The description partially adds context by showing where decision_id fits in the URL but does not describe the 'origin' parameter or its format beyond the schema.

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

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

The description clearly states the specific verb 'Compute' and the resource 'AI Procurement Decision Card well-known URL', providing a template with placeholders. It distinguishes from sibling tools like 'agent_card_well_known_url' and 'tool_card_well_known_url' by specifying the card type.

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

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

The description implies usage for computing the URL but provides no explicit when-to-use or when-not-to-use guidance. No alternatives are mentioned, though the sibling tools suggest different operations (fetch, validate, inspect).

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

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

With no annotations, the description carries the full burden and does well: it declares the checks are deterministic, discloses the return shape (ok + errors + passed), and explicitly bounds the tool as 'not a legal compliance determination.' It stops short of saying what happens on missing/invalid input or whether any auth is required.

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

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

Three tight sentences, front-loaded with the action and the three checks, then the field caveat, then the return/disclaimer. Every sentence earns its place with no filler.

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

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

For a nested-object input with zero schema documentation and no output schema, the description covers the return shape and one required field but leaves the structure of the event object largely unexplained. An agent still cannot determine which other event fields feed the CUI and ITAR checks, a notable gap given the 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 coverage is 0% and the single 'event' parameter is an unspecified nested object, so the description must compensate. It adds genuine field-level meaning by naming event.discovered_at as required and clarifying event.timestamp is not a substitute, but it documents only one field of an otherwise opaque nested object containing CUI/ITAR/interval data.

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

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

States a specific action (run checks) and enumerates exactly the three deterministic checks performed, each of which maps to a sibling tool (defensetech_check_cui_distribution_statement, defensetech_check_itar_us_person, defensetech_check_dfars_72h_clock). An agent can tell this is the composite bundle versus the individual check tools without opening any 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?

The enumeration of all three sub-checks implicitly signals that this is the bundled entry point, but the description never states when to use this tool versus calling the three individual sibling checks, nor any prerequisites or exclusions. Usage is inferable but not spelled out.

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 disclose behavioral traits. It only says 'check' and 'reports applicable=false' without explaining side effects, return format, or error conditions. This is insufficient for a tool that may affect state or require specific permissions.

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

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

The description is two sentences, both front-loaded with essential information. There is no redundant text, and every sentence adds value.

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 2 parameters, no output schema, and no annotations, the description is too brief. It omits parameter semantics, return values, error handling, and prerequisites, making it incomplete for an agent to use confidently.

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

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

The schema has 0% description coverage, and the description does not explain the parameters 'cui_categorization' or 'distribution_statement'. It references the tier concept but does not map to the required parameter, leaving the agent to infer the connection.

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 checks for required distribution statement on CUI-Specified+ tier events and mentions behavior for other tiers. The verb 'check' + resource 'distribution_statement' is specific and distinguishes from sibling tools targeting different compliance aspects.

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 when to use (for CUI-Specified+ tier) and when not (PUBLIC/CUI-BASIC report applicable=false). However, it does not explicitly state when to avoid this tool or suggest alternatives, leaving some ambiguity about its role relative to other validation tools.

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

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

With no annotations, the description carries the full burden and does disclose concrete behavior: invalid or pre-discovery filing timestamps return valid=false and within_window=false, and the tool is framed as an arithmetic preview without legal effect. It does not describe the shape of the successful return or the exact fields of the interval result.

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

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

Four tight sentences, front-loaded with the computation, then the input constraint, then negative-case behavior, then the disclaimer. Every sentence carries information and nothing is padded, though the final disclaimer could be folded in.

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

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

There is no output schema and no annotations, so the description is the only source of behavioral truth. It covers negative-case returns and legal scope but omits the success-case return payload and leaves one of two required parameters undocumented, so it is only partially complete for a computation tool of this importance.

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 50%: discovered_at is documented in the schema, but filed_at only carries a date-time format. The description partly compensates by emphasizing 'timezone-qualified timestamps' and distinguishing discovered_at from occurred_at, but leaves filed_at semantics to inference, so this sits at the baseline.

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

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

States a specific verb ('Calculate') and resource ('the DFARS 252.204-7012 discovery-to-filing 72-hour interval'), so the operation is unambiguous. No sibling tool overlaps this computation, and the domain-specific reference (DFARS 252.204-7012) makes the scope precise.

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

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

Gives a real input-routing rule ('Requires discovered_at, not occurred_at') and a scope disclaimer ('does not establish a reporting duty or prove filing'), which implies when it is and isn't the right call. But it never states when to use this versus alternatives or prerequisite conditions in an explicit when/when-not form.

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

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

No annotations provided, so description must carry full burden. Description lacks details on side effects (read-only vs write), authorization needs, return format, error behavior, or rate limits.

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

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

Single sentence with regulatory reference, no wasted words. Front-loaded with core condition. Efficient but could benefit from slight structure to highlight parameter mapping.

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 compliance check tool with 3 parameters and no output schema, description lacks return value specification (boolean? success/error?), does not clarify optional vs required params, and omits error conditions. Significant gaps given tool's purpose.

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

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

Schema has 0% description coverage. Description mentions condition involving US-PERSON-VERIFIED and AUTHORIZED-FOREIGN-PERSON-WITH-LICENSE, which maps to likely parameter roles, but does not explicitly define each parameter's meaning or valid values.

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

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

Description clearly states the tool checks ITAR resource event for US-PERSON-VERIFIED or AUTHORIZED-FOREIGN-PERSON-WITH-LICENSE + DDTC license number. Cites specific regulations. Unique verb-resource combination distinguishes it from siblings.

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

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

Implied usage for verifying ITAR compliance, but no explicit when-to-use vs alternatives or exclusions. Does not mention sibling tools or when not to use.

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

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

No annotations provided; description only mentions returning top 3 with token-match scoring, but lacks details on failure modes, confidence thresholds, or side effects.

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

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

Two sentences, front-loaded with verb and resource, no wasted words.

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

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

Adequate for a simple classification tool with one parameter and no output schema; could mention edge cases but 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?

Schema has 0% coverage, but description explains the 'description' parameter as a freeform incident description, adding meaningful context beyond the schema's empty string type.

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

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

Clearly states it classifies a freeform description into 22 event types, provides examples, and distinguishes from siblings like defensetech_check_itar_us_person.

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

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

Explicitly says when to use (classify defense-AI incident descriptions), but does not mention when not to use or provide alternative tools for similar tasks.

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 tool performs summarization and includes invariant checks, which is transparent for a read-only analysis tool. However, it does not detail the exact invariants or any potential edge cases.

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, information-dense sentence that front-loads key details. While it efficiently conveys many specifics, it could benefit from structural improvements like bullet points for readability.

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

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

Given the tool's specialized domain and the lack of input schema details or output schema, the description covers the output aspects well but fails to specify the input bundle structure, which is a significant gap for an agent trying 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 sole parameter 'bundle' is an object with no schema description and no additional explanation in the description. Schema description coverage is 0%, and the description does not clarify what fields or format the bundle should have, leaving the agent to guess.

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 ('summarize') and resource ('CMMC L2/L3 readiness evidence bundle'), and lists concrete output elements (target level, assessment mode, evidence count, etc.), clearly distinguishing it from sibling tools that deal with other aspects of defense technology compliance.

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 summarizing a CMMC evidence bundle, but does not provide explicit guidance on when to use this tool versus alternatives, nor does it mention any prerequisites or exclusions.

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

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

With no annotations, the description carries the full burden. It explicitly states the tool does NOT fetch remotely, highlighting the purely syntactic nature. However, it could elaborate on side effects (none) or authorization requirements.

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 with two sentences. The first sentence states the purpose and key constraint (HTTPS URLs), and the second clarifies scope. 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 syntactic check with one parameter and no output schema, the description is largely complete. It covers the action, constraint, return info, and what it does not do. However, it lacks details on error messages or edge cases.

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

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

The sole parameter 'contract' is an object with schema description coverage at 0%. The description mentions it is a 'DefenseTech vault contract' but provides no details on its structure or required fields. This adds minimal value beyond the schema.

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

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

The description clearly states the tool's purpose: verifying the syntactic validity of the 'cross_binding_refs' block on a DefenseTech vault contract, specifically that all referenced repos are HTTPS URLs. It also mentions the return structure (valid_refs + errors) and distinguishes itself from sibling tools that have different functionalities.

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 syntactic checks but does not explicitly state when to use this tool versus alternatives or when not to use it. No comparison is made with sibling tools that might offer similar or complementary validation.

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

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

With no annotations, the description carries the full behavioral burden and does meaningfully shoulder it: it declares the operation deterministic, specifies the ok=false outcome for unknown/incomparable human-user requirements, and states a negative scope ('does not verify identity, classification, licenses, or enforce access'). That limitation disclaimer is genuinely valuable for a security-sensitive tool. It omits permission/auth prerequisites and return-shape detail, keeping it short of a 5.

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

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

Two sentences, front-loaded with the core action and immediately followed by the failure semantics and disclaimers. Dense with domain jargon but every clause carries information; nothing is padding.

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 a fully opaque nested 'contract' object, zero parameter coverage, no annotations, and no output schema, the description leaves the single hardest question unanswered: what actually goes into 'contract'. Behavioral semantics are covered, but the input contract structure is a black box, which is a substantial completeness gap.

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%: 'contract' is an undocumented free-form object and the tuple's cui/export_control/foreign_person fields have no descriptions. The description offers domain vocabulary (allowed_actions, requires_* flags) but never maps it to the 'contract' vs 'tuple' parameters or explains the tuple axes, so an agent still cannot tell what to supply.

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

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

Names a specific verb ('resolve') and a specific resource ('DefenseTech 3-axis vault contract') and even describes the internal mechanics ('intersect allowed_actions and OR requires_* flags'), which is more than a tautology. It does not, however, explicitly differentiate itself from the nearby sibling defensetech_vault_contract_cross_binding_check, so the exact boundary is left to inference.

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

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

The word 'preview' implies a dry-run/non-enforcing call, and the ok=false condition hints at when resolution is deferred to an owner. But there is no explicit when-to-use/when-not guidance and no routing to the closely-related vault/cross-binding sibling, so the agent must guess its place in the workflow.

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

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

With no annotations, the description carries the full burden and does disclose the key behavioral trait: this is a read-only surfacing of declared posture, not a verification, plus the exact set of possible status outcomes. It does not describe the input format or error behavior, but the non-verification limitation is the critical 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?

Three tight sentences: what it returns, the enumerated outcomes, then the limitation and alternative. Front-loaded and every sentence earns its place.

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

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

With no output schema, enumerating the four status strings is exactly the return-value context an agent needs, and the non-verification boundary is stated. The gap is the undocumented required input parameter, which leaves the call contract incomplete.

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

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

Schema coverage is 0% and the single parameter document_json has no type detail, format, or example in either the schema or the description. The description describes outputs (status values) but contributes nothing about what document_json must contain, so the agent must guess the expected input shape.

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

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

States a specific verb ('Surface') and resource (the disclosure's declared policy posture and aup_uri reference), and enumerates the resulting status values, so the agent knows exactly what is produced. It also names the sibling it is not (aup_check_compliance), making it distinguishable without opening schemas.

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 explicitly says what it does not do ('does not verify compliance') and points to the alternative that does, aup_check_compliance. It lacks a positive when-to-use statement (e.g. 'use before compliance evaluation to read declared posture'), but the exclusion effectively routes the agent.

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

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

No annotations exist, so the description carries full burden. It describes the output but does not state whether the tool has side effects, requires authentication, or is read-only. For an inspection tool, the read-only nature is implicit but not explicit. Additionally, no information about errors, rate limits, or performance traits is given.

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

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

The description is a single sentence that efficiently lists all major output components. It is concise and front-loaded with the core purpose. However, it could be better structured (e.g., bullet points) for clarity, and it omits input 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?

Given that there is no output schema and only one input parameter, the description does a reasonable job of explaining the output contents. However, it fails to document the input parameter or the tool's behavior beyond the output. It covers the 'what' but not the 'how' or 'when', leaving gaps for an agent to use 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 schema has 0% description coverage, and the tool's description does not explain the single parameter 'document_json'. There is no indication of what format the JSON should be, what keys are expected, or how to construct the input. The description only mentions the output, leaving the parameter entirely opaque.

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

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

The description clearly specifies the tool's purpose: returning a structured summary of a Student AI Disclosure. It lists the specific elements included (assignment identity, AI usage facts, etc.), making the resource and output unambiguous. The name 'disclosure_inspect' and the verb 'Structured summary' align well, and among sibling tools like 'disclosure_validate' and 'disclosure_verify_artifact_hash', the inspect function is distinct enough.

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 usage guidelines are provided. The description does not indicate when to use this tool over siblings like 'disclosure_validate' or 'disclosure_verify_artifact_hash'. There is no mention of prerequisites, input format expectations, or context for 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?

Discloses that it enforces conditional validation rules, which adds value beyond schema. However, with no annotations, it lacks details on error reporting, side effects (read-only implied), and response format.

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 concise sentences: first defines purpose, second details conditional rules. No extraneous content, 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?

Covers validation logic well but omits important context: no output schema means result format is unknown, no mention of synchronous/asynchronous behavior, and no prerequisites stated.

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

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

Schema has one parameter with 0% description coverage. The description adds that it is a 'Student AI Disclosure JSON document' but fails to specify expected format, encoding, or constraints, which is insufficient for correct usage.

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

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

Clearly states the tool validates a Student AI Disclosure JSON document against a specific schema (v0.1). This distinguishes it from sibling tools that validate other document types (e.g., agent_card_validate, tutor_card_validate).

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?

Describes the conditional rules enforced, which guides when to use this tool (disclosures with those rules). No explicit when-not or alternatives, but the specific context makes usage 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?

The description explains the computation and comparison logic, and details the return format on mismatch. However, it does not explicitly state that the tool is non-destructive or clarify any authorization needs, rate limits, or side effects. Given the lack of annotations, this is a moderate 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 two sentences, front-loaded with the main purpose, and every sentence adds value. No redundant or ambiguous wording; it is efficient and well-structured.

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

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

The description covers the core functionality and parameter usage, but it fails to explain the required parameter document_json, which is only described in the schema. Without a clear description of what document_json is, the tool's completeness is diminished. Additionally, no output schema is provided, though the description partially covers return structure.

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

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

The description adds meaningful context beyond the schema, such as specifying that candidate_text uses canonical SHA-256 with LF and no trailing newline, and that candidate_bytes_base64 is for binaries like PDFs/images. This compensates for missing schema descriptions on some 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 it recomputes SHA-256 and compares to a stored hash, specifying two modes for text and binary artifacts. However, it does not distinguish itself from sibling tools like disclosure_verify_prompt_hash or ai_evidence_verify_hash, which might have similar purposes.

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 guidance on which parameter to use based on artifact type (candidate_text for text, candidate_bytes_base64 for binary) and explains the canonical text mode. It does not explicitly state when not to use the tool or mention alternatives, but the context is sufficient for basic decision-making.

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

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

No annotations provided, so description carries full burden. Discloses lookup by prompt_id, SHA-256 computation, return format (ok=true or error with expected/recomputed), and error condition for wrong mode. Missing explicit read-only statement, but verification is inherently non-destructive.

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

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

Two sentences: first for purpose, second for returns and errors. No redundancy, every sentence adds value.

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

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

Covers main behavior and errors, but lacks detail on document_json format and expected prompt_id schema. Adequate for a simple verification tool, but could be more thorough.

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

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

Schema has 0% property descriptions. Description explains prompt_id and candidate_text roles but does not define document_json structure or format. Incomplete compensation for low schema coverage.

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

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

Clearly states it verifies a single prompt hash in hashed-mode disclosure. Verb 'verify' and resource 'prompt hash' are specific, distinguishing it from sibling 'disclosure_verify_artifact_hash' which verifies artifact hashes.

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

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

Implies usage context ('hashed-mode disclosure') and error when not in that mode, but does not explicitly contrast with alternatives like disclosure_verify_artifact_hash or other validation tools. No when-not guidance.

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

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

The description explains the tool's behavior: it walks the affected block and returns every referenced Suite document. It implies a read-only operation with no side effects, but does not cover error cases or what happens when no affected block exists. With no annotations, this is decent but not exhaustive.

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

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

The description is two sentences, front-loaded with the core functionality, and each sentence adds value without redundancy. It is appropriately sized.

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 description covers the output and use cases, it omits parameter explanations, which are crucial for correct invocation. Given the absence of an output schema, more detail on input usage would be expected.

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 does not explain the parameters 'url' or 'document_json'. It only describes the output, leaving the input semantics entirely to the schema, which provides no 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 walks an Incident Card's `affected` block and returns referenced Suite documents as { uri, kind }, giving a specific verb and resource. It distinguishes from sibling tools like incident_fetch by focusing on walking the affected block.

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 explicit use cases: 'useful as the seed list for incident-correlation-rs or fan-out validation via aeo-validator-service.' While it gives context, it does not explicitly state when not to use this tool or mention alternatives.

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

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

With no annotations, the description carries full burden. It states it fetches and returns parsed JSON, which suggests read-only behavior, but it does not disclose error handling, authentication, or side effects. Adequate but minimal.

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

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

The description is two concise clauses, front-loading the action. Every word adds value with no wasted text.

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 no output schema. The description covers the core purpose and return type, but could be more complete by mentioning the expected structure or error cases. Still sufficient for low 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?

The schema has 0% description coverage for the url parameter. The tool description adds no additional meaning beyond the parameter name and schema type, failing to compensate for the lack of schema description.

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 (Fetch), the resource (AI Incident Card), and the source (from a URL). It also specifies the return type. This distinguishes it from sibling tools like tutor_card_fetch or decision_card_fetch.

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

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

The description implies usage when needing to fetch an incident card by URL, but it does not explicitly state when to use this tool versus alternatives (e.g., incident_inspect) or any prerequisites/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?

No annotations are provided, so the description must stand alone. It describes the fetch operation and the summary output but does not disclose side effects, error handling, or safety characteristics (e.g., read-only, destructive potential). The transparency is adequate but incomplete.

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 only two sentences long, with no wasted words. The first sentence states the action and output, while the second adds audience and value. It is front-loaded and efficient.

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 simple one-parameter tool and no output schema, the description covers the main purpose, output structure (total count, breakdowns, sorted IDs), and target users. It is mostly complete but could benefit from mentioning error cases or prerequisites.

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 covers 100% of the single parameter 'origin' with a description and format. The description adds context that the origin is the vendor's base URL for the index, which aligns with the schema. It adds minimal new meaning beyond the schema, so a baseline score of 3 is appropriate.

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

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

The description clearly states the tool fetches a vendor's .well-known/ai-incidents.json index and returns a procurement-friendly summary. It distinguishes itself from sibling tools like 'incident_fetch' by calling itself the 'HEADLINE TOOL' and the 'cheapest way' for scanning incident history.

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 identifies the target audience (CISO or procurement reviewer) and the high-level use case (scanning a vendor's incident history). It implies a lightweight overview but does not explicitly contrast with alternatives or state when not to use it.

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

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

No annotations provided; description does not disclose whether the tool is read-only, its safety profile, or any side effects. The verb 'inspect' implies read but not explicitly stated.

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

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

Single sentence listing many fields; information dense but somewhat run-on. Could be more structured (e.g., bullets) for readability, but not overly verbose.

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

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

No output schema exists; description compensates by listing return fields. However, it omits crucial usage context for parameters and behavioral traits, making it incomplete for correct invocation.

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

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

Schema description coverage is 0% and description fails to explain the purpose of parameters 'url' and 'document_json'. Does not indicate how they are used or which is needed, leaving agents uninformed.

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

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

States "Structured summary of an AI Incident Card" and enumerates specific fields (id, title, severity, etc.). Clearly identifies the resource and action, distinguishing from sibling tools like incident_fetch or incident_validate.

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

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

No guidance on when to use this tool versus alternatives such as incident_fetch or incident_affected_walk. Missing context about prerequisites or suitable scenarios.

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

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

No annotations are provided, so the description carries full burden. It discloses the output format (Action+Urgency mapping) and mentions 'Urgency follows severity', which gives behavioral insight. However, it does not mention side effects, error conditions, or assumptions about input format.

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, consisting of two sentences with no redundant words. Every sentence adds value.

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

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

Given the lack of output schema and parameter explanations, the description is incomplete. For a tool with two unannotated parameters, failing to describe them leaves the agent without critical information needed for correct invocation.

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

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

With 0% schema description coverage, the description must explain parameters, but it makes no mention of 'url' or 'document_json'. The agent cannot infer what these parameters represent or how they relate to the tool's operation.

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 it maps affected URIs to recommended Action+Urgency, and provides examples of mappings. It hints at a preview of a correlation function, which distinguishes it from other incident tools, but assumes knowledge of 'incident-correlation-rs.correlate()' and doesn't explicitly differentiate from siblings like incident_fetch or incident_inspect.

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

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

No explicit guidance on when to use this tool versus alternatives. It says 'Map each affected URI in an Incident Card', which implies usage context, but no when-not or comparison to other incident tools.

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

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

No annotations are provided, so the description carries the full burden. It discloses the enforced conditional rules, which is good, but omits behavioral details such as side effects (none expected), authentication requirements, or the format of validation results (e.g., pass/fail, error messages).

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 highly concise with two sentences: one for the primary purpose and one enumerating the conditional rules. Every sentence adds essential information, and there is no redundancy or fluff.

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

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

Given the tool's simplicity (single parameter, no output schema, no annotations), the description covers the validation logic in sufficient detail. However, it could be improved by briefly noting the return value (e.g., success/error object), though this is often inferred for validation tools.

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

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

With 100% schema coverage, the description adds minimal value beyond the schema. The parameter 'document_json' is described as 'Incident Card as inline JSON,' which clarifies the format but does not elaborate on constraints like encoding or size limits.

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 an AI Incident Card JSON against a specific schema (v0.1) and lists conditional rules. The verb-resource pairing is precise, and it distinguishes itself from sibling validators for other card types (e.g., agent_card_validate, tool_card_validate).

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

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

The description implies usage for validating incident cards but fails to provide explicit when-to-use or when-not-to-use guidance. It does not mention alternatives like incident_fetch or incident_inspect, leaving the agent to infer context from sibling names.

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

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

No annotations provided, so description carries full burden. It clearly indicates a safe read-only computation (constructing a URL) with no side effects. Lacks details about error handling or validation, but behavior is straightforward and predictable.

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

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

Single sentence, front-loaded with purpose. Very concise, but could benefit from explaining the origin parameter's role. Still, it is efficient and clear.

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

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

For a simple URL builder, the description is mostly adequate but lacks explanation of the origin parameter and output format. Given no output schema, the description should ideally clarify what the tool returns. It is incomplete for a tool that requires two parameters.

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 50% (only incident_id has description). The tool description does not explain the origin parameter or how it is used in URL construction. It adds no semantic value beyond the schema, missing crucial information about a required 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?

Description clearly states it computes the canonical well-known URL for an AI Incident Card, with the exact path template. This distinguishes it from sibling tools like incident_fetch or other well-known URL builders.

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

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

No explicit guidance on when to use this tool versus alternatives like incident_fetch or other well-known URL tools. The context implies it is for URL generation before fetching, but no exclusions or prerequisites are provided.

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

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

No annotations are provided, so the description bears full responsibility for behavioral disclosure. It does not mention whether the operation is read-only, if permissions are needed, or what side effects (none expected) occur. The verb 'extract' implies a read but is not explicitly stated.

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, direct and without unnecessary words. It is appropriately front-loaded and efficient for the tool's simplicity.

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

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

Given the lack of output schema and minimal schema coverage, the description does not provide enough context about what the extracted result looks like or how the document_json should be structured. Sibling tool names hint at domain but do not compensate.

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 50% description coverage: suite_name has a basic description ('Name of the evaluation suite to extract.') which adds some value, but document_json lacks any description. The description does not clarify the expected format (JSON string) or relationship between 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 verb 'extract' and the resource 'evaluation suite's result', and specifies the source 'from a Prompt Provenance document'. However, it does not differentiate from sibling tools like prompt_provenance_validate or prompt_provenance_inspect, which may have overlapping purposes.

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 lacks context on prerequisites, when it should not be used, or what conditions make it appropriate. Sibling tool names imply a broader suite but no explicit direction.

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

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

No annotations exist, so the description must disclose behavior. It mentions the tool returns a summary but does not state whether it is read-only, requires permissions, or handles errors. Minimal behavioral 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 a single sentence that efficiently lists the output components. It is not verbose, but could be slightly more structured.