ScrubMyText + Agent Infrastructure

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

The description adds behavioral traits beyond annotations: it explicitly states 'No context content is stored' (privacy guarantee) and 'immutable' (data integrity). Annotations already indicate idempotentHint=true and destructiveHint=false, which are consistent. The description does not contradict annotations and adds meaningful context about side effects and data retention policies.

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 totaling 20 words, front-loading the main purpose and then adding critical context. Every sentence earns its place: the first sentence defines the operation and inputs, the second clarifies data handling and production constraints. There is no extra fluff or repetition of what the schema already shows.

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 5 parameters, no output schema, and no parameter descriptions. The description explains the high-level purpose and a few parameters, but it omits what the tool returns (e.g., for 'check' operation) and the role of control_id. For a provenance tool with only two sentences of documentation, an agent lacks sufficient information to invoke it correctly without external knowledge. More behavioral details (e.g., response format, error states) are needed.

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 carries the burden of parameter explanation. It covers three of five parameters: context_digest, parent_digests, and stage by naming them in the use case. The operation parameter is implied by 'Create or inspect' (anchor vs check). However, control_id is not explained at all, leaving its purpose ambiguous. The description adds moderate value but is incomplete for a schema with 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 creates or inspects an immutable provenance anchor using specific inputs: context digest, parent digests, and processing stage. This action is distinct from all sibling tools, which cover approvals, actions, quality, etc. The verb-resource pair is precise and leaves no ambiguity about the tool's core function.

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

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

The description provides no guidance on when to use this tool versus alternatives like record_action_receipt or other provenance-related siblings. It mentions 'Production' and a subscription API key as prerequisites, but does not explain scenarios for choosing 'anchor' vs 'check' operations. The lack of when-to-use or when-not-to-use instructions makes it hard for an agent to select the correct tool among 47 siblings.

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

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

Annotations already declare destructiveHint and idempotentHint. The description adds valuable context that the approval link becomes invalid, which is the key side effect. It does not cover authorization or error states, but with annotations present, this is sufficient.

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, well-structured sentence that leads with the action verb. The 'Paid:' prefix is terse and may be a label, but there is 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?

For a simple, single-parameter destructive action, the description explains the function and effect, and the annotations cover idempotency and destructiveness. It omits error scenarios and return values, but with no output schema this is acceptable.

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

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

Schema description coverage is 0%, and the description does not mention the single required parameter approval_id. The parameter name is self-explanatory, but the description does not compensate for the lack of field-specific guidance.

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

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

The description uses a specific verb and resource: 'cancel a pending human approval request' and explicitly states the effect 'so its link can no longer approve the action.' This clearly distinguishes it from sibling tools like request_approval and check_approval.

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 makes the context clear: use when you need to cancel a pending human approval request. It does not explicitly mention alternatives or exclusions, but the intended use is unambiguous given the pending-approval context.

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

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

Annotations already declare readOnlyHint, idempotentHint, and destructiveHint=false, covering the safety profile. The description adds the behavioral requirement of a subscription API key, which is new information not present in annotations. 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 two short sentences, front-loaded with the main purpose and followed by a key requirement. No fluff, every word earns its place.

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

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

Given the tool's simplicity (one parameter, no output schema) and strong annotations, the description is largely complete. It covers what the tool does, when to use it, and a key prerequisite. Could elaborate on return values, but that is not essential for a read-only inspection 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 provides 0% description coverage for the 'key' parameter. The description compensates by clarifying that the key is an 'idempotency key,' giving essential meaning to the parameter beyond its raw 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 the verb 'inspect' applied to an 'idempotency key' with timing context ('before or after an agent action'). This distinguishes it from sibling tools like lock_action or release_action, which perform different operations.

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

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

It gives clear contextual guidance on when to use it ('before or after an agent action'), but does not explicitly mention alternatives or exclusions. The subscription API key requirement is also mentioned as a prerequisite, which helps the agent decide if it can invoke this tool.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true, and destructiveHint=false, so the safety profile is clear from structured data. The description adds value by explicitly stating it is 'deterministic' and by disclosing negative behaviors ('does not fetch arbitrary URLs and does not certify security or correctness'), providing behavioral context beyond the annotations.

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

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

The description is two sentences, concise with no filler, and front-loads the main action. Every sentence provides distinct value: the first defines the deterministic check, the second clarifies what it does not do. It could be slightly improved by explicitly listing key parameters.

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

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

Given the tool has 4 parameters (1 required, nested objects), no output schema, and 0% schema description coverage, the description provides enough context for a basic understanding but lacks detail on return format (e.g., what the check yields) and the meaning of optional parameters. The rich annotations compensate somewhat, but the description should cover these gaps 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 description coverage is 0%, so the description must compensate for documenting parameters. The description names 'server_card' (the object parameter) and implies the purpose of the tool, but the other three parameters (required_tools, expected_version, require_streamable_http) are not mentioned, leaving their meaning unclear. However, the schema types and names provide some clues, and the description's mention of 'published integration contract' gives context for the expected 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 checks an MCP server card against a published integration contract, using the verb 'check' and specifying the resource as a 'supplied MCP server card'. It distinguishes itself from siblings by mentioning 'integration readiness' and not certifying security, though it doesn't explicitly contrast with siblings like 'check_action' or 'check_approval'.

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 a server card against a contract, and explicitly states what the tool does not do ('does not fetch arbitrary URLs and does not certify security or correctness'), which provides some guidance. However, it does not say when to use this tool vs alternatives like 'check_action' or 'validate_output', nor does it explain prerequisites or typical 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?

Annotations already declare readOnly, idempotent, and non-destructive. The description adds behavioral context by listing the possible statuses and the 'Paid:' prefix, indicating a cost implication. This goes beyond what annotations provide, though the return format or error handling is not disclosed.

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

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

The description is a single sentence, front-loaded with the status enumeration. The 'Paid:' prefix is concise but somewhat cryptic, slightly impacting clarity. Overall, 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?

For a simple one-parameter query tool, the description covers the main statuses but does not describe the return format or behavior for invalid/unknown IDs. Since there is no output schema, additional detail would enhance completeness, but the tool is relatively simple.

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 approval_id parameter beyond its obvious name. It lacks context about how to obtain the ID or any validation rules, placing the burden on the agent to infer from the parameter name 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's function: checking the status of a human approval request, enumerating all possible statuses (pending, approved, rejected, expired, cancelled). This specific verb+resource combination distinguishes it from sibling tools like cancel_approval or request_approval.

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 querying approval status but does not explicitly state when to use this tool versus alternatives. No exclusions or alternative tool references are provided, only the inherent context that this is a status-check operation.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true, and destructiveHint=false, establishing safety. The description adds value by explaining the output reveals evidence and uncertainty and explicitly states no paid ranking or universal winner is produced, which goes beyond the annotations and clarifies behavioral outcomes.

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 exceptionally concise at two sentences, front-loads the primary action and constraints, and contains no extraneous words. Every sentence adds distinct 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 6 parameters and no output schema, the description is far from complete. It lacks parameter explanations, does not define 'contextual quality cards', omits constraints like region or latency, and provides no guidance on the output format. While annotations cover safety, the agent lacks enough information to construct valid inputs.

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, but it only vaguely references 'two to ten exact targets' without explaining any of the six parameters. The nested target object fields (e.g., target_type, provider_domain) and other parameters like task_category, region, max_latency_ms, max_price_micros, minimum_evidence_class are entirely undefined, making correct invocation difficult.

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 ('Return contextual quality cards'), the exact resource type, the quantity constraint ('two to ten exact targets'), and the ordering ('caller-provided order'). It also distinguishes from siblings by mentioning it does not produce a paid ranking or universal winner, contrasting with other tools that might rank or list singly.

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 comparing multiple targets but does not explicitly state when to use this tool versus alternatives like get_quality_card or list_quality_cards. No when-not conditions or prerequisite expectations are provided, leaving the agent to infer from context.

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

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

Annotations already indicate readOnlyHint=true, idempotentHint=true, and destructiveHint=false, establishing safety. The description adds billing constraints ('Trial, subscription, or x402 pay-per-call') and the specific behavioral focus on scrub/format artifacts, which goes beyond the annotations. It does not contradict annotations.

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

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

The description is extremely concise: two sentences that front-load the purpose and then add billing info. Every word earns its place with no redundancy or filler.

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

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

The tool is simple with no output schema, but the description does not explain the return value (e.g., diff, boolean, structured result). While annotations cover safety, the lack of output description leaves a gap. It is adequate 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?

With 0% schema description coverage, the description must compensate, but it only mentions 'two text versions' without clarifying which parameter is 'original' vs 'modified' or adding constraints beyond the schema's maxLength. The schema names are self-explanatory, but the description adds minimal extra meaning.

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: 'verify what changed between two text versions and whether differences are only scrub/format artifacts.' This is a specific verb+resource combination that distinguishes it from sibling tools like scrub_text, redact_sensitive_text, or inspect_text, which serve different 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 gives a clear context for use (comparing two text versions for scrub/format artifacts) but does not explicitly state when to avoid this tool or name alternatives. It implies the use case but lacks direct guidance on tool selection among the 32 siblings.

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

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

Annotations already indicate idempotent and non-destructive behavior. The description adds valuable context about the side effect of preserving an idempotency record for a retention period and notes the paid nature. This goes beyond the annotations, though it does not describe failure behavior or return values.

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 core action ('mark the current lock completed') and includes the paid status and retention detail without unnecessary words. It is highly 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?

The description gives a clear purpose and some behavioral context, but it lacks parameter explanation and does not situate the tool within the lock lifecycle (e.g., when to use vs. release_action). With 2 required params and no output schema, the description is minimally adequate but has notable gaps.

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

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

Schema description coverage is 0%, so the description must compensate by explaining the parameters. It does not mention 'key' or 'lock_id' at all. The only indirect hint is 'current lock,' which could relate to lock_id but is ambiguous. This is a significant gap given both parameters are required.

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

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

The description clearly states the tool's function with a specific verb ('mark the current lock completed') and resource ('current lock'), and it adds a distinguishing detail ('preserve the idempotency record for its configured retention period') that differentiates it from siblings like release_action or check_action. The 'Paid:' prefix also adds a clear qualifier.

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 'current lock' implies the tool is used on an existing lock, providing clear context for when to call it. The 'Paid:' indicator signals a cost consideration. However, it does not explicitly mention alternatives or exclusions, so it stops short of a 5.

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

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

With annotations already indicating non-read-only, non-idempotent, and non-destructive behavior, the description adds the auth requirement ('Subscription API key required') as useful behavioral context. It does not explain what is created or what happens on repeated calls, but annotations cover the broad safety profile. The description adds limited but valuable context beyond annotations.

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

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

The description is two sentences: one for the use case and one for the auth requirement. Every word earns its place, and the information is front-loaded with the primary usage condition. No fluff or redundant phrasing.

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, so the description should explain what the tool returns (e.g., a signal ID). It also lacks any explanation of parameter semantics or how the created signal is subsequently used. While the use case is clear, the description is incomplete for an agent to correctly invoke and handle 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?

Schema description coverage is 0%, so the description must compensate for explaining parameters. It does not mention any of the three parameters (label, max_events, expires_in_seconds) or provide any hints about their meaning. The only additional information is about an API key, which is not a parameter. This is a complete failure to add parameter semantics.

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

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

The description clearly states the tool's purpose by describing when to use it ('when an agent must wait for an external callback, webhook, job completion, or asynchronous event'), which implies creating a signal inbox. However, it does not explicitly use a verb like 'creates' in the description text, relying on the title and tool name for that. It distinguishes itself from siblings by focusing on creation for waiting, but this is implied rather than explicit.

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 context for use: 'Use when an agent must wait for an external callback, webhook, job completion, or asynchronous event.' It also mentions a prerequisite ('Subscription API key required'). However, it does not state when not to use it or explicitly name alternative tools (e.g., delete_signal or get_signal_events).

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 explicitly discloses what gets destroyed (inbox and all stored event bodies) and the immediacy of the action, which complements the destructiveHint and idempotentHint annotations. The 'Paid' note adds non-obvious cost context. It does not mention permissions or reversibility, but annotations cover the safety profile.

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

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

A single, well-structured sentence that front-loads the 'Paid' caveat and delivers the core action and scope concisely. Every word contributes 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?

For a simple one-parameter destructive tool, the description covers the action, the specific resource affected, and important qualifiers (paid, immediate). It lacks mention of return values or error conditions, but without an output schema and given the simple operation, this is sufficient.

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

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

With 0% schema description coverage, the description helps by explaining that inbox_id refers to a 'signal inbox', providing context beyond the raw parameter name. However, it does not elaborate on format, constraints, or any other parameter details beyond what the schema already shows.

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 ('delete'), the target ('signal inbox'), and the full scope ('all stored event bodies'), with 'immediately' adding specificity. It distinguishes itself from sibling tools as the sole deletion operation.

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 is provided on when to use this tool versus alternatives. The 'Paid:' prefix implies a cost consideration but does not mention when not to use the tool or suggest alternative approaches.

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

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

The annotations already declare the tool as read-only, idempotent, and non-destructive, so the safety profile is covered. The description adds valuable behavioral detail by stating 'without echoing values,' which clarifies a non-obvious privacy guarantee beyond what annotations imply. This is meaningful extra context about the tool's output 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 three sentences, each serving a distinct purpose: usage timing, detection scope and non-echoing behavior, and payment model. It is front-loaded with the actionable 'Use before...' instruction, and no word is wasted. It is an ideal length for a simple tool.

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 (one parameter, no output schema), the description covers the essential context: when to use, what it detects, and its non-echoing guarantee. The only minor gap is that it does not describe the return format or type, but since the tool is a detector, the agent's main need is to know when to call it, which is well covered.

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 only one parameter ('text') with no property description (0% schema description coverage). The description compensates by specifying that the parameter is 'text that may contain credentials,' giving semantic meaning to the input. Since this is the only parameter, this level of explanation is sufficient for invocation.

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

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

The description clearly states the tool's function with a specific verb ('Finds') and resource ('likely API keys, private keys, JWTs, cloud credentials, and secret patterns'), making its purpose unmistakable. It also specifies that it detects without echoing values, which adds scope. This distinguishes it from sibling tools like redact_sensitive_text or scrub_text, even though no explicit sibling comparison is made.

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 an explicit usage context: 'Use before an agent logs, stores, or forwards text that may contain credentials.' This tells the agent when to invoke the tool. However, it does not explicitly mention when not to use it or name alternative tools for cases where redaction or other processing is needed, so it falls short of a full 5.

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

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

The description adds significant behavioral detail beyond the annotations: it states that object key order does not affect the result (normalization), returns no input values (privacy), and stores nothing (no side effects). Since annotations already cover read-only and idempotent hints, the description enriches the agent's understanding with deterministic and privacy-relevant 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 three crisp sentences, front-loaded with the core purpose and followed by critical behavioral properties. Every sentence contributes value with no redundancy or fluff, making it highly scannable.

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

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

The description covers when to use, what it produces (SHA-256 fingerprint and idempotency key), key normalization, and privacy guarantees. With an output schema present and annotations providing safety hints, nothing critical is missing. It fully contextualizes the tool for an agent.

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

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

Schema description coverage is 100%, so the schema thoroughly documents each parameter. The description merely paraphrases that it uses action, optional scope, and JSON arguments, and adds the idempotency-relevant detail that arguments define sameness, which is helpful but not essential. Baseline 3 is appropriate because the schema already provides 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?

The description clearly states the tool's purpose: to derive a stable SHA-256 fingerprint and idempotency key from an action name, scope, and JSON arguments. It uses specific verbs and resources, and the mention of 'fingerprint' and 'idempotency key' distinguishes it from sibling tools like lock_action or check_action.

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

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

The description explicitly says 'Use before retryable work,' which gives clear guidance on when to apply the tool. However, it does not mention alternatives or when not to use it, such as 'use lock_action for actual locking,' so it lacks exclusions but still provides clear context.

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

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

Annotations already declare readOnlyHint=true, destructiveHint=false, and idempotentHint=true, so the safety profile is clear. The description adds value by noting that scores depend on minimum three contributors and that the tool is free. It does not detail pagination, error states, or response structure, but for a read-only tool the annotations carry the main burden.

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 action and resource. The second sentence adds essential behavioral context without fluff. Every word earns its place.

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

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

Given the tool's complexity (10 parameters, no output schema, no schema descriptions), the description is too sparse. It explains the purpose well but leaves the agent uninformed about required parameter values, expected return format, or how to handle missing scores. It does not compensate for the missing schema descriptions.

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

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

The input schema has 10 parameters with 0% description coverage, and the tool description does not explain any parameter semantics. The agent receives no guidance on what 'canonical_endpoint', 'provider_domain', 'task_category', etc. mean or how to construct the request. This is a critical failure for 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 verb 'Retrieve' and the resource 'quality card' for a specific version. It adds context about score availability and cost. However, it does not explicitly differentiate from the sibling tool 'list_quality_cards', which likely returns multiple cards, leaving a minor ambiguity.

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 vs. alternatives like list_quality_cards, compare_quality_targets, or record_quality_observation. No prerequisites, scenarios, or exclusions are mentioned, which is a significant gap given the 48 siblings.

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

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

Annotations already declare the tool read-only, idempotent, and non-destructive. The description adds value by noting the 'Paid:' caveat (potential cost) and the 'arrival order' ordering guarantee, which are not present in the annotations. No contradiction with annotations is present.

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

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

The description is a single, concise sentence that front-loads the key 'Paid:' caveat and immediately states the action and target. Every word contributes meaning, 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?

The tool is simple and the annotations provide safety context, but the description fails to explain parameters or return format. Since there is no output schema, the description is the only source for these details, leaving gaps that require inference. It is minimally viable 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?

With 0% schema description coverage, the description should compensate by explaining the parameters, but it does not. It only hints at ordering, leaving 'after_ms' and 'limit' ambiguous. An agent receives no clear guidance on how to set these parameters correctly.

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

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

The description states a specific verb ('retrieve') and a clear resource ('events received by a temporary signal inbox'), and adds a distinguishing behavior ('in arrival order'). This clearly separates it from sibling tools like create_signal and delete_signal.

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 that this tool is used to fetch events from a temporary signal inbox, but it does not explicitly state when to use it over alternatives, mention prerequisites (e.g., needing an inbox_id), or provide exclusions. The context is clear but the guidance is implied rather than explicit.

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

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

Annotations already declare readOnlyHint, idempotentHint, and destructiveHint, establishing safety. The description adds value by specifying what is inspected (Unicode details, invisible characters, normalization, mixed-script anomalies). However, it doesn't disclose output format, potential side effects (though none expected), or how results are returned.

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

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

The description is short (two sentences). The first sentence is front-loaded with purpose. The second sentence 'Free or paid' is tangential and does not aid tool selection or invocation, reducing conciseness. It could be trimmed without 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 single-parameter, annotated tool, the description covers the core functionality. However, it lacks details on return value or output format (no output schema), and does not mention limitations (e.g., max length handling, performance hints). It is minimally adequate but not comprehensive.

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

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

Schema description coverage is 0% for the single parameter 'text'. The description adds no additional meaning beyond the schema's maxLength constraint. It doesn't clarify expected encoding, whether empty strings are valid, or any special requirements. Baseline requires compensation for low coverage, which is not provided.

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

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

The description clearly states the tool inspects Unicode details (exact Unicode, invisible characters, normalization, mixed-script anomalies). It uses a specific verb 'inspect' and identifies the resource. While it doesn't explicitly distinguish from sibling tools like 'compare_text' or 'scan_untrusted_text', the purpose is specific enough to guide selection.

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 phrase 'Free or paid' is irrelevant for invocation decisions. Sibling tools exist for related text operations (e.g., 'redact_sensitive_text', 'validate_output'), but the description offers no context for choosing this tool.

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

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

Annotations already declare read safety and idempotency. The description adds value by noting ordering by 'recent evidence, not quality, payment, or sponsorship' and the 'free' cost. However, it does not disclose pagination behavior, response format, or what happens if no results are found. Given the strong annotation coverage, this is adequate but not rich.

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

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

The description is two sentences (40 words), front-loads the main action, and contains no fluff. Every phrase earns its place, conveying purpose, threshold, ordering, and cost efficiently.

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

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

The tool has 3 optional parameters with no output schema. The description explains what is listed and ordering, but omits details on parameters, response format, pagination, and the meaning of 'quality cards.' For a listing tool without output schema, this is incomplete—the agent would need to infer too much.

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, but it does not mention 'limit', 'target_type', or 'task_category' at all. While the parameter names are somewhat self-explanatory, the agent lacks guidance on valid values (except from enums), formatting, and purpose. The description fails to compensate for the lack of schema descriptions.

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

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

The description clearly states the tool lists 'quality cards' with specific criteria ('public three-verified-contributor evidence threshold'). This distinguishes it from sibling tools like 'get_quality_card' (single card) and 'compare_quality_targets', though it does not explicitly name these alternatives. The verb 'list' and resource are 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?

No guidance is provided on when to use this tool versus siblings such as 'get_quality_card' or 'compare_quality_targets'. The description mentions ordering (by recent evidence) and cost ('Free'), but does not explain use cases, prerequisites, or when to avoid this 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?

The description adds behavioral context beyond annotations: it states the operation is atomic, requires a subscription API key, and ensures retries cannot execute twice. Annotations already provide mutating (readOnlyHint false) and idempotent (idempotentHint true) hints, so the description supplements rather than repeats them. However, it does not disclose TTL behavior or conflict handling, leaving some gaps.

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

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

Exactly two sentences, front-loaded with purpose, and every word adds value. It efficiently conveys when to use, what it does, and a prerequisite (API key) without bloated prose.

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 purpose and usage timing well, but given the tool's moderate complexity and no output schema, it needs to explain TTL parameters, conflict behavior, or return values. The absence of these details leaves the description incomplete for an agent to fully anticipate tool 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?

With 0% schema description coverage, the description fails to compensate. It only implies the 'key' parameter via 'idempotency key' but never mentions lock_ttl_seconds or completion_ttl_seconds, leaving two parameters completely unexplained. This is a significant deficiency for a 3-parameter tool.

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

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

The description clearly states the tool's function: atomically claim an idempotency key to prevent retries from executing an action twice. It uses specific verbs and resource ('claim an idempotency key') and differentiates from sibling tools like release_action and lock_action_intent by focusing on atomic idempotency semantics.

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

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

The description explicitly says 'Use immediately before a consequential agent action,' giving a clear timing context. It also explains the retry-prevention purpose. While it does not name alternative tools or explicit exclusions, the usage context is strong enough for most agents to decide when to invoke 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?

Beyond the annotations, the description discloses atomic claim behavior, deterministic fingerprinting, the inability to acquire a second active lock on repeat calls, and the subscription API key requirement. These add significant behavioral context without contradicting the idempotentHint annotation.

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 dense, front-loaded sentences each earn their place. The description starts with an actionable directive, then explains the mechanism and constraints, with no fluff or repetition.

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 purpose, timing, behavior, uniqueness constraints, and authentication. It does not enumerate TTL semantics, but the schema provides numeric bounds and the output schema likely document the return values. Overall a well-rounded description.

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 meaning for arguments by explaining that equivalent object-key ordering produces the same fingerprint, which is not fully captured in the schema. However, the TTL parameters (lock_ttl_seconds, completion_ttl_seconds) are left unexplained, and the schema itself lacks descriptions for them.

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 tool's function: it fingerprints the action and arguments, atomically claims that key, and returns safe_to_execute. It distinguishes itself from siblings like fingerprint_action and lock_action by combining both operations in a single pre-action lock.

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?

Explicit usage guidance is provided: 'Use immediately before a consequential retryable action when no stable idempotency key exists.' This states the condition clearly, but it does not explicitly name alternative tools 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?

Annotations (readOnlyHint=false, destructiveHint=false, idempotentHint=false) already signal mutation and non-destructive behavior. The description adds context about the veto mechanism and atomic consumption, but leaves gaps such as what happens on cancellation or consumption failure, and the exact state transitions remain unclear.

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

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

The description is three sentences long, front-loading the operations and core flow, then adding a clarifying remark. Every sentence is relevant and there is no extraneous 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 multi-operation tool with no output schema and many siblings (e.g., manage_action_reconciliation, request_approval), the description lacks detail about operation constraints, failure modes, the meaning of 'digest-bound', and how it differs precisely from related tools. The short hint about exception handling helps but does not provide complete 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?

With 0% schema description coverage, the description should compensate, but it only mentions 'digest-bound' and 'bearer challenger' without mapping to any parameters (control_id, action_fingerprint, veto_window_seconds, execution_window_seconds). The schema enums and patterns are self-documenting, yet the description adds no extra semantic value.

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

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

The description clearly states the tool creates, inspects, consumes, or cancels a digest-bound cooling-off window. It explains the two-phase flow (challenger vetoes, owner consumes) and distinguishes itself as exception handling rather than affirmative consent or legal approval, which differentiates it from sibling tools like request_approval or cancel_approval.

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 context by labeling the tool as exception handling and requiring a Subscription API key, implying it should be used for veto-based windows instead of standard approvals. However, it does not explicitly mention alternative tools (e.g., request_approval) or clearly 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?

The description discloses a critical behavioral trait beyond the annotations: 'Stores digests only and does not perform either action.' This clarifies the tool is non-destructive despite the lack of annotations indicating such. It also mentions atomicity ('atomically mark compensation once') and a prerequisite ('Subscriptive API key required'). However, it does not disclose failure modes, concurrency behavior, or side effects on other system state.

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

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

The description is concise at three sentences, front-loading the core action. Each sentence adds value: the first explains the binding process, the second clarifies it only stores digests, and the third notes the API key requirement. However, the structure could be improved by grouping operational details (e.g., the five operations) more explicitly, and the last sentence feels slightly tacked on.

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

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

Given the tool has 5 parameters, no output schema, and no parameter descriptions, the description is incomplete. It does not explain the return value or state changes after each operation (e.g., what happens when 'bind' succeeds vs fails). The agent is left without guidance on error handling, status codes, or expected responses. The description covers only the high-level purpose, not the detailed usage context needed for a tool with multiple operations and complex constraints.

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

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

The schema description coverage is 0%, meaning the description adds no explanation for any of the 5 parameters (operation, control_id, action_fingerprint, expires_in_seconds, compensation_fingerprint). The description does not mention parameters, their purpose, or how they relate to the operations. The tool is complex with an enum of operations, yet the description provides zero parameter-level guidance, forcing the agent to infer solely from schema names and types.

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

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

The description clearly states the tool's purpose: managing compensating actions by binding a digest, recording primary execution, and atomically marking compensation. It specifies that it only stores digests, not performs actions, which distinguishes it from siblings like 'complete_action' or 'lock_action' that actually execute or lock actions. The verb 'manage' combined with 'compensating action' is specific and 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 does not provide guidance on when to use this tool versus alternatives. It mentions a 'Subscription API key required' but does not explain when compensation management is appropriate, what prerequisites are needed before using it, or when to prefer other tools (e.g., 'manage_action_challenge' or 'fingerprint_action'). No explicit when-not-to-use or alternative references are given.

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

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

The annotations already indicate non-read-only, non-idempotent, non-destructive behavior. The description adds critical context: the mutating consume operation is one-time, bearers are unique per control_id, and the quorum must succeed for a grant. This supplements the annotations well, though it could mention error states (e.g., duplicate vote cancellation) or lifecycle imitations like max 20 members.

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 action verb and resource, and every phrase adds value. No word is wasted; the N-of-M pattern, one-time consume, and API key requirement are all concisely conveyed.

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 6 parameters, no output schema, and annotations that are present but minimal, the description covers the tool's essence well. It explains the quorum lifecycle but omits details like return value structure (e.g., what check returns) or parameter constraints beyond what the schema provides. Still, it is substantially complete for an experienced agent.

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

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

Schema description coverage is 0%, so the description must compensate. It explains the roles of some parameters implicitly: 'N-of-M' maps to member_count and required_votes, 'bearer' links to control_id, and 'consume' relates to the consume operation. However, it does not explicitly detail action_fingerprint, expires_in_seconds, or how control_id differentiates quorums, leaving some burden on 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 begins with a specific verb and resource: 'Create, inspect, consume, or cancel an N-of-M bearer authorization quorum'. It clearly defines what the tool does (manage quorum state machines) and distinguishes it from siblings like 'manage_authority_delegation' or 'manage_action_challenge' by focusing on bearer authorization quorums with N-of-M semantics.

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 states the core usage scenario: 'each unique bearer can decide once; only a successful one-time consume grants an execution right', which implies it is for multi-party authorization. It also warns 'Subscription API key required' for authentication. However, it does not explicitly say when not to use this tool versus alternatives like 'request_approval' or 'check_approval', missing some comparative 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?

Annotations declare readOnlyHint=false, destructiveHint=false, so the tool modifies state but is not destructive. The description confirms it is not read-only by listing write operations like 'append' and 'resolve'. It adds minimal behavioral context beyond the annotations, such as the production environment note, but does not explain side effects (e.g., whether appending evidence finalizes a reconciliation, or what happens when resolve is called with an invalid control_id). No contradiction with annotations.

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

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

The description is a single sentence listing the key operations and a short note on environment and auth. It is front-loaded and avoids unnecessary words, earning its place. However, the sentence is slightly clunky with the comma-separated list of operations.

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 7 parameters, 0% schema coverage, no output schema, and no sibling differentiation, the description is incomplete. It fails to explain how the operation parameter controls the workflow, which parameters are required per operation, what the return value looks like, or what error conditions exist. The tool is moderately complex (enum-driven operations), so much more context is needed.

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. The description mentions 'digest-only evidence' and 'discrepancy,' which hints at the evidence_digest and expected_digest/observed_digest parameters, but it does not explain which parameters are required for each operation, how they interconnect, or what values like 'reconciled' vs 'dismissed' mean. With 7 parameters and no structured documentation, this is insufficient.

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

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

The description lists four operations (open, inspect, append, resolve) but does not clearly state what the tool's core purpose is—it is a composite tool for managing reconciliation workflows. The phrase 'discrepancy between expected and observed action outcomes' gives some context, but it is not a crisp verb+resource statement. Among 48 sibling tools, this one stands out for reconciliation management, but the description does not explicitly differentiate it from related tools like manage_action_challenge or manage_action_quorum.

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., when to choose 'manage_action_challenge' instead). The description does not outline prerequisites or exclusions, such as whether reconciliation must be opened before appending. The only usage hint is 'Production; subscription API key required,' which is too generic to help an agent decide.

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

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

Annotations already indicate the tool is not read-only, not idempotent, and not destructive, which is consistent with the description's mention of creating/inspecting/cancelling. The description adds valuable behavioral context: 'Link delivery remains the caller’s responsibility' (clarifying caller obligation) and 'Subscription API key required' (a prerequisite). However, it lacks details like whether cancellation is always reversible, what happens on SLA state inspection, or potential 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, with the key action set front-loaded. Each sentence contributes unique information: the first describes core behavior, the second clarifies caller responsibilities and prerequisites. No wasted words.

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

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

The tool has 6 parameters, 0% schema coverage, and no output schema. The description does not explain what the output of 'check' looks like, what values for 'severity' or 'operation' mean, or how SLA seconds are interpreted. This leaves the agent unable to correctly invoke the tool without additional knowledge.

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

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

Schema description coverage is 0%, so the description must compensate for explaining parameters. It does not. Only 'severity', 'operation', 'control_id', 'incident_fingerprint', 'response_sla_seconds', and 'resolution_sla_seconds' appear in the schema, but the description offers no insight into how they relate to 'create, inspect, or cancel' or their formats. For example, 'control_id' and 'incident_fingerprint' are completely unaddressed.

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 ('Create, inspect, or cancel') and identifies the resource ('digest-only incident with a private bearer operator link and deterministic response and resolution SLA state'). This clearly distinguishes it from the many siblings, which are about locks, approvals, tasks, or text operations.

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

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

There is no guidance on when to use this tool versus alternatives. The description implies calling this when you need operator escalation, but does not mention when not to use it (e.g., if you don't have a subscription key) or compare it to siblings like 'manage_action_challenge' or 'manage_task_handoff'.

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

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

Annotations already indicate idempotentHint=true and destructiveHint=false. The description adds value by stating the signal is 'durable' (persistent) and instructing callers to 'fail closed whenever stopped is true' — a behavioral trait not captured by annotations. It also mentions 'subscription API key required' as an access constraint. No contradiction with annotations.

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

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

The description is two sentences, front-loaded with the core purpose. The second sentence adds critical behavioral and production context. No unnecessary 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?

Given the tool has 3 parameters, no output schema, and sibling tools with similar scope, the description is largely complete. It explains the three operations, the key concept, and the fail-closed behavior. However, it omits details about the return value when inspecting (check) and does not explain the reason_code parameter, which would be useful for a complete understanding.

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

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

Schema description coverage is 0%, so the description must explain parameters. The description covers operation (set, inspect, clear) and subject_key (hashed agent or workflow key) implicitly, but does not explain reason_code or its enum values. The agent must infer that operation corresponds to the enum actions. The description adds partial meaning but leaves gaps for a 0% coverage scenario.

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: 'Set, inspect, or clear a durable stop signal for a hashed agent or workflow key.' This uses a specific verb-resource combination and immediately distinguishes the tool from siblings like manage_agent_escalation or manage_attention_budget by focusing on the stop signal concept.

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

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

The description provides clear context: 'Callers should fail closed whenever stopped is true' and 'Production; subscription API key required.' It implicitly tells the agent when to use the tool (to manage a stop signal) but does not explicitly state when not to use it or provide alternatives. The guidance is sufficient for basic usage decisions.

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

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

Annotations give no hints (all false), so the description bears full responsibility. It discloses key behavioral traits: the pool is finite, supports per-subject caps, retry-safe reservations, and protected priority capacity. It also notes the authentication requirement. While it does not detail side effects of closing or failure modes, it covers the essential behaviors for a budget tool.

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

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

The description is a single, well-structured sentence that front-loads the key operations and features. It is concise with no redundant or off-topic information. Every part 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's complexity (10 parameters, no output schema, no parameter descriptions), the description is somewhat lacking. It does not explain return values, error conditions, or how operations interact (e.g., create must precede reserve). For a tool with such a wide parameter set, more context is needed for an agent to use 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?

With 0% schema coverage, the description must compensate. It mentions 'per-subject caps' (hinting at max_units_per_subject), 'retry-safe reservations' (reservation_key), and 'protected priority capacity' (protected_priority_units). However, it does not explain the purpose of other parameters like units, total_units, period_seconds, control_id, or priority. The description adds meaningful domain context but is insufficient for a 10-parameter tool.

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

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

The description clearly states the tool's purpose: managing a 'finite review-capacity pool' with specific operations (create, inspect, reserve, release, close). It lists key features (per-subject caps, retry-safe, priority capacity) that distinguish it from siblings like 'reserve_action_budget'. The resource and actions are 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 mentions that a 'Subscription API key required' and enumerates the operations, implying when to use them. However, it does not explicitly state when to prefer this tool over alternatives, nor does it provide guidance on which operation to choose in different scenarios. No exclusion criteria 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?

The annotations (readOnlyHint: false, destructiveHint: false) indicate the tool can mutate and is not read-only nor destructive, which aligns with the described operations (issue, revoke are mutations). The description adds clarity by specifying the bearer capability is 'narrow,' 'bound to one action fingerprint and a maximum use count,' and that it's not identity proof. However, it doesn't explicitly state whether operations require specific permissions beyond the API key, or details about rate limits or side effects beyond revocation.

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

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

The description is concise with three sentences: purpose, distinction, and availability. It front-loads the core action and constraints. However, the second sentence ('This is a technical capability...') could be integrated into the first without losing clarity, making it slightly redundant but not wasteful.

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

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

Given the tool has 6 parameters, no output schema, and annotations only covering read/destructive hints, the description provides essential context to understand the tool's role. It explains the binding to action_fingerprint and max_uses, which clarifies the input schema. However, it lacks explanation of the return structure for each operation (e.g., what 'use' returns), which would be needed due to the missing output schema.

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

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

The schema has 0% coverage, meaning parameter descriptions are missing. The description compensates by explaining the context for parameters like 'action_fingerprint' (bound to one action) and 'max_uses' (maximum use count). However, it doesn't elaborate on 'token' (what it represents beyond a string), 'control_id' (purpose), or 'expires_in_seconds' (interpretation). The enum for 'operation' is well-covered by the description's explicit mention of the operations.

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: to 'Issue, consume, inspect, or revoke a narrow bearer capability' bound to specific constraints. It differentiates itself from other tools by specifying it's a 'technical capability, not identity proof or a legal delegation,' which distinguishes it from potential related tools like manage_authority_delegation or manage_context_rights. The mapping of the 'operation' enum is explicitly covered, making it highly specific.

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 strong usage guidance by stating 'Production; subscription API key required,' which indicates when the tool is available. However, it lacks explicit guidance on when to use this tool versus alternatives (e.g., other delegation or approval tools) or scenarios where it should not be used. It implies usage for technical capability management but doesn't cover exclusions or comparisons with siblings.

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

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

Annotations indicate readOnlyHint=false and destructiveHint=false, but the description adds useful context: the tool issues a technical policy signal (not legal advice) and requires a subscription key. However, it does not detail the behavioral differences between the four operations (e.g., revoke effects, evaluation guarantees).

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, immediately front-loading the core action and resource. The second sentence adds an essential caveat without redundancy. Every word earns its place.

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

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

Despite a complex schema (7 parameters, 0% description coverage, no output schema), the description omits parameter details, operation-specific behavior, return values, and error conditions. It provides high-level purpose but lacks the depth needed for reliable invocation.

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

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

With 0% schema description coverage and 7 parameters (including enums and patterns), the description fails to explain any parameter beyond listing operations in the text. It does not describe 'rights', 'control_id', 'policy_digest', 'context_digest', 'requested_right', or 'expires_in_seconds', leaving the agent to infer meaning from names 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 uses specific verbs ('Issue, inspect, evaluate, or revoke') and identifies the resource as a 'digest-bound machine-readable context-rights envelope,' clearly distinguishing it from sibling tools like 'manage_context_status' or 'manage_action_challenge'.

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

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

The description does not provide any guidance on when to use this tool versus alternatives among the 45 sibling tools. It mentions a subscription API key requirement but offers no context for selection or exclusion.

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

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

The description adds significant behavioral context beyond the annotations: it clarifies that the tool stores no context body, does not invalidate copies outside the service, and requires a subscription API key. These details are not present in the annotations (which only provide generic hints) and help the agent understand side effects and constraints.

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

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

The description is three sentences long, immediately states the core purpose and operations, then adds two critical behavioral constraints. Every sentence is essential, with no redundancy or fluff. The title is also descriptive.

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

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

Despite having no output schema and 6 parameters with 0% description coverage, the description fails to explain parameter relationships (e.g., which parameters are required for which operation). It covers high-level purpose and limitations but leaves critical invocation details unclear, making it incomplete for correct agent usage.

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

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

Schema description coverage is 0%, meaning the input schema provides no explanatory text for any of the 6 parameters. The description does not compensate: it lists operations but does not explain which parameters are needed for each operation (e.g., context_digest, successor_digest, expires_in_seconds). The agent has no guidance on parameter semantics beyond their types/enums.

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

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

The description clearly states the tool manages 'digest-only context status' and lists the specific operations (publish, inspect, supersede, dispute, revoke) with the goal of stopping downstream agents from using stale inputs. This is a specific verb-resource combination that distinguishes it from related siblings like manage_context_rights.

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 implicit usage context (managing status to prevent stale inputs) and mentions a prerequisite (Subscription API key required). However, it does not explicitly state when to use this tool versus alternatives, nor does it specify when not to use it or exclude specific operations.

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

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

Annotations provide no behavioral flags (readOnlyHint, destructiveHint, etc.), so the description carries the full burden. It discloses that only hashes and counters are stored, not content or identities, and requires an API key. However, it does not address side effects of recording operations, idempotency, 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?

The description is two concise sentences, front-loading the core operations and constraints. Every sentence adds unique value: first defines the action and limits, second clarifies what is not stored and the auth requirement. 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?

With 10 parameters, 4 operations, no output schema, and no annotations, the description is insufficient. It does not explain return values, how to structure each operation, or the meaning of fingerprint parameters. The 'inspect' vs 'check' discrepancy undermines 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% – no parameter descriptions exist. The description hints at total_units, per_recipient_limit, and per_category_limit, but ignores 7 other parameters (event_key, control_id, period_seconds, units, category_fingerprint, recipient_fingerprint, and the enum values for operation). There is also a mismatch: description says 'inspect' but the enum uses 'check', which could confuse an 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's purpose: creating, inspecting, recording against, or closing a cumulative disclosure budget with specific limits. It names the operations and distinguishes the resource (disclosure budget) from sibling tools like manage_attention_budget by focusing on content hashing and counters.

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 a prerequisite (Subscription API key required) but provides no guidance on when to use this tool versus alternatives among the 45 sibling tools. It does not explain when to use 'check' vs 'create' or how this compares to other budget managers.

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?

Description clearly states the lease is atomic, short-lived, and exclusive, which are critical behavioral traits. It says it operates on a hashed resource key, implying the key is sensitive or must be pre-processed. Annotations are minimal (all false) so description carries full burden and does well, though it could mention that releasing requires a valid lease_token.

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 clear, front-loaded sentences with no filler. Could be more concise by combining the production note with the API key requirement, but currently it's efficient and readable.

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% parameter documentation coverage, the description covers the tool's core purpose and important behavioral context (atomicity, exclusivity, short-lived, hashed key). It lacks information about return values or failure modes, but for a lock-like tool with three simple operations, this is close to complete.

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

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

Schema description coverage is 0%, so description must compensate. It names or implies parameters (operation, resource_key, lease_token, ttl_seconds) through the purpose statement but doesn't explain their semantics or constraints (e.g., ttl_seconds applies only to acquire, lease_token required for check and release). The enum for operation is partially described, but details are left to 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 atomically acquires, inspects, or releases a short-lived exclusive lease on a hashed resource key. The verb 'acquire', 'inspect', and 'release' combined with the noun 'lease' make the purpose specific and distinguishable from sibling lease management tools like manage_context_rights or manage_authority_delegation.

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 includes a production environment note and API key requirement, but provides no explicit guidance on when to use this tool versus alternatives like manage_action_quorum, manage_task_handoff, or manage_authority_delegation. The sibling tools include many lease-like operations, but no differentiators are provided beyond basic purpose.

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

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

Annotations already indicate readOnlyHint=false and destructiveHint=false. The description adds context that this records service state and is not a legal contract or payment, which tempers expectations. However, it does not disclose side effects, reversibility, permission requirements, or response behavior, so the added value is modest.

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

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

The description is concise with two sentences, front-loading the core action list. However, it lacks structural elements like bullet points or subsections that could improve readability without increasing length. Every sentence earns its place, but minor restructuring could enhance scannability.

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

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

Given the tool has 6 parameters, no output schema, and only partial annotations, the description is insufficient. It omits return values, error conditions, token semantics, and how operations interact with other task management tools. An agent would struggle to invoke this tool correctly without additional documentation or context.

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

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

Schema description coverage is 0%, yet the description only lists the operations (offer, accept, check, complete, cancel). It provides no explanation for parameters like token, control_id, terms_digest, task_fingerprint, or expires_in_seconds. The agent must rely solely on parameter names and schema constraints, which is insufficient for correct invocation.

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

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

The description clearly states the verb-resource pairing: 'Offer, accept, inspect, complete, or cancel a digest-bound technical task commitment.' It distinguishes from sibling tools like manage_task_deadline and manage_task_handoff by specifying the unique focus on digest-bound contract lifecycle and clarifying it is not a legal contract.

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

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

The description implies usage for managing task commitment states but provides no explicit guidance on when to choose this tool over alternatives such as manage_task_deadline or manage_task_handoff. No prerequisites or exclusions are mentioned beyond the non-legal disclaimer.

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

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

Annotations (readOnlyHint=false, destructiveHint=false) indicate mutation. The description goes beyond by explaining that deadline/escalation state uses an independent server clock that works when the agent is offline, and that a subscription API key is required. It does not specify latency, success behaviors, or side effects for each operation, but the stated behavioral insight is valuable.

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 a clear structure: first sentence lists actions and key property (server clock independence), second sentence states a necessary credential (API key). No filler or repetition, though the second sentence could be integrated naturally.

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

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

Given 5 parameters, 0% schema coverage, no output schema, and sibling tools like manage_task_contract and manage_agent_escalation, the description provides enough to grasp the tool's role but lacks usage differentiation, return value clarity, and operation-specific details that would be helpful for an agent to invoke correctly without trial and error.

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

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

Schema coverage is 0%, so description must compensate. The description ties parameters (control_id, due_in_seconds, escalation_grace_seconds, task_fingerprint) to deadlines and escalation behavior, adding meaning beyond the raw schema fields. However, it does not explain all five parameters explicitly (e.g., operation enum values are not re-described), but the high-level mapping is sufficient.

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 (create, inspect, complete, cancel) and identifies the resource (task deadline). It also explains the key differentiating feature: the independent server clock that works even when the agent is offline. This distinguishes it from typical deadline tools but could be clearer about the exact resource managed versus siblings like manage_task_contract.

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

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

The description lacks explicit guidance on when to use this tool versus alternatives. 'Subscription API key required' hints at a prerequisite, but there is no mention of when to use manage_task_contract, manage_agent_escalation, or other sibling tools instead. No exclusion cases or context-based recommendations 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?

The annotations provide no safety hints (readOnlyHint=false, destructiveHint=false), so the description carries full burden. It adds useful context: bearer-token authentication, exactly-once claim, and fingerprint-only storage. However, it omits behavioral traits like whether operations are reversible, what data is mutated, or any authorization requirements beyond mentioning 'paid API identity'.

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

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

The description is short—essentially one sentence plus two fragments—and front-loads the main verb 'Create'. No filler words. It could be more structured by separating operations, but it remains clear 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 tool's complexity (5 operations, 5 parameters, no output schema, no annotations), the description is insufficient. It lacks details on state transitions between operations, parameter constraints, return values, and error conditions. An agent would struggle to correctly invoke operations like 'claim' or 'cancel' without more context.

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

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

With 0% schema description coverage, the description partially compensates by explaining token (bearer-token), operation (enumerated verbs), and task_fingerprint (fingerprints stored). However, it fails to explain control_id and expires_in_seconds, leaving two of five parameters unaddressed.

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: to create, claim, inspect, complete, or cancel a bearer-token task handoff. It specifically mentions the resource ('task handoff') and the actions (create, claim, etc.), distinguishing it from sibling tools that manage different concepts like action challenges or resource leases.

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

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

The description does not provide explicit guidance on when to use this tool versus the many sibling alternatives. It implies usage for task handoff between paid API identities but lacks any 'when-not-to-use' or direct comparisons to other manage_* tools.

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

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

Annotations indicate destructiveHint=false and readOnlyHint=false, which is appropriate for a tool that can either mutate (pin, revoke) or simply inspect (check). The description adds that it stores 'bounded metadata and digests, not the terms body', clarifying what is persisted. However, it does not disclose response behavior for each operation or any side effects of revocation, leaving some ambiguity for the agent.

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 3 sentences, each adding distinct value: listing operations, clarifying storage scope, and stating the non-legal nature plus authentication requirement. The sentences are front-loaded with the core purpose. Minor improvement could be splitting into a one-sentence summary followed by 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 the high complexity (9 parameters, 3 operations, no output schema), the description establishes the tool's domain and constraints but omits details like return format, error scenarios, or how operations interact. Since no output schema exists, the description could better indicate what the agent expects after each operation. The authentication mention is helpful but incomplete for a tool with this many 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?

With 9 parameters and 0% schema description coverage, the description does not explain any parameter meanings beyond what the schema provides. It mentions 'metadata and digests' broadly but does not map specific parameters to their roles (e.g., control_id, price_minor, terms_digest). The baseline of 3 is appropriate given the lack of explicit parameter documentation in the 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 it performs three operations (pin, inspect, revoke) on an immutable digest-bound record of observed terms, interface, version, and price. This distinguishes the tool from siblings which focus on actions, approvals, contexts, and signals. However, the title 'PinMyTerms' is slightly informal compared to the functional 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?

The description notes that this is 'technical evidence, not a legal agreement' and that a 'Subscription API key required', but does not specify when to use this tool vs. alternatives like manage_action_reconciliation or manage_task_contract. None of the siblings appear to deal with terms records, but explicit guidance on when to use this over other management tools would improve clarity.

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

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

Annotations already declare readOnlyHint, idempotentHint, and destructiveHint. The description adds that the comparison is deterministic and bounded, that supplied tokens are processed without storing policy content, and that no legal or compliance conclusions are made—all useful behavioral traits beyond the annotations.

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

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

The description is three sentences long, front-loaded with the core purpose. The second sentence adds behavioral transparency and the third notes an authentication requirement. Every sentence serves a distinct purpose without 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 no output schema, the description does not indicate what the tool returns (e.g., a match/mismatch result or score). It covers purpose, behavioral side-effects, and authentication, but omits return value information that would help the agent anticipate the tool's output. This is adequate but has a clear 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%, so the description must compensate. It mentions 'provider capabilities', 'consumer-required', and 'consumer-forbidden' in the overall function but does not explain what each parameter means beyond their names, their relationships, or any formatting details. This adds minimal value over the schema's type/constraint info.

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 compares provider capabilities with consumer-required and forbidden tokens. It specifies deterministic and bounded behavior, and adds that it does not store tokens or make legal conclusions. However, it does not distinguish itself from sibling tools like compare_text, which could be used for similar comparison tasks.

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 a 'Subscription API key required' but does not provide guidance on when to use this tool versus alternatives, nor does it specify when not to use it. No explicit context or exclusions are given, leaving the agent to infer usage without clear 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?

Annotations already provide readOnly, idempotent, and non-destructive hints. The description adds that it returns multiple outputs (reports) and mentions pay-per-call pricing, which are useful behavioral traits beyond what annotations cover.

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, each adding value: purpose and output, then pricing. No wasted words, front-loaded with the core action.

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

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

Despite good annotations, the description is incomplete for a tool with 3 parameters, no output schema, and many siblings. It lacks details on mode options, report contents, error handling, and how to interpret results, which are essential for correct usage.

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 0% description coverage, and the description provides no explanation of the three parameters (mode, text, redact_sensitive). The description fails to add meaning to the schema, leaving the agent without guidance on how to use these 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 is a preprocessing step for untrusted text, returning agent-ready text plus reports. It sets a clear purpose as a default step, but does not explicitly differentiate from sibling tools like inspect_text or scan_untrusted_text.

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 advises using it as a default preprocessing step, giving a clear context. However, it does not mention when to use alternatives (e.g., specialized tools) or when not to use this tool, such as for already trusted text.

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 notes that the tool does not store the action or outcome payload, only a digest, which adds behavioral context beyond the annotations. Annotations indicate idempotentHint=true and destructiveHint=false, and the description aligns with this by stating it creates an immutable receipt without storing payloads. No contradiction is present.

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, well-structured sentence that conveys the primary purpose, key constraints (immutable, digest only), and important notes (production, API key required). Every element is essential, and there is no wasted wording.

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 (5 parameters, immutable receipt creation/checking) and lack of output schema, the description covers the main purpose and constraints. However, it does not explain return values, error conditions, or the relationship between 'record' and 'check' operations, leaving some gaps for an AI agent to infer.

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 no parameters are described in the schema. The description names operation, receipt_id, outcome_digest, outcome_status, and action_fingerprint implicitly via the action outcome context, but does not explicitly detail their meaning or patterns. With 5 parameters and no schema descriptions, the baseline is 3, and the description only marginally adds value beyond parameter names.

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

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

The description clearly states that the tool creates or retrieves an immutable receipt digest for an action outcome, which is a specific verb-object pairing. It distinguishes itself from sibling tools by focusing on receipt recording and checking, not on other actions like cancellation or approval.

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 this is for production use and requires a subscription API key, setting clear context for when to use it. However, it does not explicitly state when not to use it or compare it to alternatives like fingerprint_action or check_action, leaving some ambiguity in 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?

The description adds behavioral context beyond annotations: it mentions opt-in submission, labeling based on receipt (E1/E0), and constraints on stored data (no prompt, response, etc.). Annotations already indicate idempotency and non-destructiveness, so the description complements rather than repeats. It does not cover rate limits or auth details, but the provided context is valuable.

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-loaded with the primary action and followed by clarifying details. Every sentence earns its place with 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?

Despite a complex tool with 18 parameters, 8 required, no output schema, and zero schema descriptions, the description provides barely any guidance on how to use the parameters. The tool is under-documented for its complexity, leaving the agent likely to make incorrect parameter selections.

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 18 parameters with 0% schema description coverage, yet the tool description explains none of them. Key parameters like observation_key, minimum_evidence_class, or receipt_id are unmentioned, leaving the agent without guidance on what values to provide. This is a critical gap given the parameter count and required fields.

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

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

The description clearly states the tool submits an opt-in structured observation for an exact target and task. It distinguishes between receipt-linked (E1) and other observations (E0), and specifies what data is not stored, making the purpose specific and differentiating from sibling tools like list_quality_cards or get_quality_card.

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 this tool (to record quality observations) and mentions requirements (free verified contributor or subscription key). However, it does not explicitly exclude alternative tools or provide guidance on when not to use it. The context of storing no free-form review is helpful for setting expectations.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true, destructiveHint=false, covering safety and idempotency. The description adds 'pattern-based redaction' which is a useful behavioral trait, but does not explain what the tool returns or whether the input is modified. With annotations present, the description provides some added value but not rich context.

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 redundant information. The first sentence provides usage context, the second mentions pattern-based approach and business model. It is concise, though the pricing detail could be considered less essential for tool selection.

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 one parameter, no output schema, and good annotations, the description covers when to use and the core mechanism. However, it omits details like output format, whether redaction is irreversible, and how it compares to similar siblings (e.g., 'scrub_text'). It is minimally complete but leaves gaps for an agent to infer.

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 one parameter 'text' with 0% description coverage. The description mentions 'text' implicitly in usage context but does not add semantic meaning beyond the schema (e.g., format, encoding, constraints beyond maxLength). Since schema coverage is low, the description should compensate but fails to do so.

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 redacts sensitive text (credentials or identifiers) using patterns, which is a specific verb-resource pair. It distinguishes from siblings like 'detect_secrets' (detection only) by explicitly mentioning redaction and pattern-based approach. The title reinforces the purpose.

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

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

The description gives clear context for when to use ('before storing, sharing, logging, or sending text downstream when it may contain credentials or identifiers') but does not mention when not to use or explicitly name alternative tools among siblings (e.g., 'detect_secrets', 'scrub_text'). The guidance is adequate but lacks exclusions.

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

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

Annotations already indicate destructiveHint=true and idempotentHint=true. The description adds valuable context beyond annotations: it is a paid operation and only applies to uncompleted locks. It also clarifies the intended effect (allowing another attempt to safely acquire the lock). This moves beyond the annotations' basic safety profile.

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, front-loaded with the 'Paid:' note and the primary action ('release an uncompleted action lock'). Every word contributes to the tool's purpose and behavior, with no redundancy or filler.

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

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

This is a simple tool with only two parameters and no output schema, so the description need not be extensive. However, it leaves 'key' unexplained and does not mention what the operation returns or whether it fails silently. The annotations cover destructiveness but not parameter semantics, making the description adequate but 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 description mentions only 'lock_id' as the identifier for the lock. The 'key' parameter is completely unexplained—what it represents and how it relates to the lock is absent. With two required parameters and no schema descriptions, this is insufficient compensation for the low 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?

The description states the specific action: 'release an uncompleted action lock using its lock_id' with the goal of allowing another attempt to acquire it. It clearly distinguishes itself from sibling tools like lock_action and complete_action by specifying the resource (uncompleted lock) and mechanism (lock_id).

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 the tool: when you have an uncompleted action lock and need to release it for another attempt. It provides context but does not explicitly name alternatives or exclusion criteria, such as 'if the lock is completed, use complete_action instead.' This is clear enough for basic 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?

Annotations already indicate non-read-only and non-destructive behavior. The description adds valuable context: 'Creates a secure approval link' and 'Subscription API key required,' disclosing operational requirements and the nature of the output without contradicting annotations.

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

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

The description is two sentences, front-loaded with the usage trigger, and every sentence earns its place. No filler or repetition.

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 high-level purpose but omits parameter semantics and return-value details. With three parameters and no output schema, the description is insufficient for an agent to invoke the tool correctly without additional inference.

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 does not mention any of the three parameters (title, description, expires_in_seconds), and the schema itself has no descriptions (0% coverage). The agent receives no guidance on what values to provide, making this a critical gap.

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

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

The description clearly states the tool's function: 'Use when an agent needs independent human approval before a consequential action. Creates a secure approval link.' It identifies a specific verb (request) and resource (approval), distinguishing it from siblings like cancel_approval and check_approval.

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 opening phrase 'Use when...' provides explicit context for when the tool should be invoked. It does not explicitly mention alternatives or exclusions, but the guidance is clear for the intended 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?

The description adds useful behavioral context beyond the annotations: it states the request is 'digest-only', 'visible as unverified pending state', and that it 'does not erase evidence or prove provider identity'. The annotations already provide idempotentHint=true and destructiveHint=false, and the description complements them without contradiction.

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

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

The description is extremely concise: two sentences that convey purpose, constraints, and behavior without any wasted words. Every sentence adds value, and the structure is front-loaded with the action.

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

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

Given 5 required parameters, no output schema, and moderate complexity, the description covers prerequisites and behavioral constraints but omits critical details: what the tool returns (e.g., success/failure, request ID), error conditions, and the effect of repeated submissions. It is partially complete but leaves gaps.

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

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

Schema description coverage is 0%, so the description must carry the full burden for parameter understanding. It only hints at 'digest-only' relating to correction_digest and 'correction or appeal' for request_kind. It does not explain card_id, reason_code, request_key, or the meaning of the enum values. For 5 required parameters, this is insufficient.

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

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

The description clearly states the action ('attach a digest-only correction or appeal request'), the target ('quality card'), and specifies what the tool does not do ('does not erase evidence or prove provider identity'). It effectively communicates the core function, though it doesn't explicitly distinguish it from sibling tools like record_quality_observation.

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 a prerequisite ('Free verified contributor or subscription key required') and the resulting state ('visible as unverified pending state'), but it offers no guidance on when to use this tool versus alternatives (e.g., record_quality_observation for direct observations). It lacks explicit 'when to use/when not to use' instructions.

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

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

The description adds meaningful behavioral context beyond the annotations: atomicity of reservation, idempotency via reservation_key, storage of hashes/counters rather than purchase details, and production/auth requirements. The idempotentHint annotation is false, but the description conditionally clarifies this via the reservation_key, which is not a direct contradiction. It could go further by explaining over-ceiling behavior, but it already provides substantial 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?

Three concise sentences, front-loaded with the core atomic reserve operation, followed by idempotency and storage/auth context. No wasted words; every sentence adds distinct information.

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

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

The description covers core purpose, idempotency, and storage/auth, but for a 7-parameter tool without an output schema, it omits the behavior of the 'check' operation, what happens when capacity is exceeded, and any return-value semantics. It is adequate for a high-level understanding but incomplete for direct invocation without further investigation.

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

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

Schema description coverage is 0%, so the description must compensate for 7 parameters. It explains the role of reservation_key (idempotency) and hints at budget_key and period_key via 'named, period-scoped ceiling', but gives no meaningful explanation for operation (reserve/check), amount, limit, or retention_seconds. The description adds some value but leaves most parameters underdocumented.

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 atomically reserves integer units under a named, period-scoped ceiling. This specific verb+resource combination distinguishes it from sibling budget management tools, and the mention of reservation_key for idempotency further clarifies the core operation.

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 explicit guidance on when to use this tool versus alternatives. It mentions 'Production' and API key requirements, but does not state when the tool is appropriate or inappropriate compared to sibling tools like manage_attention_budget or manage_disclosure_budget.

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

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

Beyond the annotations (readOnly, idempotent, non-destructive), the description adds behavioral details: deterministic and no LLM, preservation of specific fact types, return of change metrics and preservation checks, and the lack of authorship/watermark verification. It also discloses the payment/access model. This greatly helps the agent understand side effects and limitations.

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

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

The description is three sentences: the first gives the use case, the second explains return values and limitations, and the third covers access. It is concise, front-loaded, and avoids redundancy with the annotations.

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 when to use, what it does, what it returns, what it avoids, and access model. The main gaps are parameter definitions and a more explicit description of the output format, but given the small parameter count and helpful annotations, it is fairly complete.

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

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

The input schema provides no descriptions (0% coverage), and the description does not explain the `text` or `mode` parameters. The enum meaning of 'light/standard/deep' is left undefined, so the agent has no guidance on parameter semantics beyond the raw 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 identifies the tool as a deterministic, no-LLM text rewriter that preserves protected facts (numbers, URLs, emails, quotes). This distinguishes it from sibling tools like compare_text or inspect_text by focusing on rewrite behavior and explicit exclusions (does not verify authorship/watermark).

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 states 'Use when an agent needs a deterministic, no-LLM rewrite' and provides exclusions such as 'does not verify authorship or watermark status.' However, it does not explicitly name alternative tools for those excluded cases, so the guidance is strong but not fully alternatives-aware.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true, and destructiveHint=false. The description adds value by detailing behavioral traits: 'normalizes structural artifacts, returns risk signals, and can redact sensitive patterns.' It also mentions the payment model (trial, subscription, or pay-per-call), which is atypical but provides transparency. No contradictions with annotations are observed. The description does not go into behavior variations for different modes or parameters, but overall it enriches the agent's understanding beyond annotations.

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

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

The description is highly concise: two full sentences plus a pricing fragment. The first sentence front-loads the primary use case, the second enumerates key behaviors, and the third mentions cost implications. Every sentence earns its place; there is no wasted text. This is an excellent example of compact but informative documentation.

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 moderate complexity (3 parameters, no output schema), the description covers the broad purpose and behavior but leaves gaps. It does not specify what 'risk signals' look like or whether the tool returns the sanitized text or only a report. The effect of different 'mode' values is not described. With no output schema, the agent cannot predict what the tool returns, which is a completeness issue. The description is adequate for a high-level overview but lacks sufficient detail 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%, meaning the parameters have no descriptions in the schema itself. The tool description must compensate, but it does not mention any parameter specifics. It states that the tool 'can redact sensitive patterns' (linking to redact_sensitive) and implies modes through 'normalizes structural artifacts,' but that is insufficient. No explanation is given for the 'mode' enum values or the 'text' max length constraint. The agent gains little understanding of how to set these parameters correctly.

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

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

The description clearly states the tool's purpose: 'Use before putting untrusted retrieved or uploaded text into a model context.' It specifies the verb 'sanitize' and the resource 'agent context' from untrusted text. The description mentions normalizing structural artifacts, returning risk signals, and redacting sensitive patterns, which is specific. However, it does not explicitly distinguish from sibling tools like 'redact_sensitive_text' or 'scrub_text', which share some functionality, so it loses a point for not providing that differentiation.

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

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

The description provides a clear context of when to use the tool: 'before putting untrusted retrieved or uploaded text into a model context.' This implies a specific scenario but does not explicitly state when not to use it or recommend alternatives from the sibling list (e.g., 'redact_sensitive_text' for simpler redaction). The 'behavioral guidance' is implicit, but the lack of exclusions or comparisons makes it only adequate, not exemplary.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true, destructiveHint=false, and openWorldHint=false, so the safety profile is clear. The description adds that the tool 'does not determine maliciousness or safety' and mentions pricing (trial, subscription, x402 pay-per-call), which is useful but not a behavioral trait. It fails to disclose what happens to the input text (e.g., is it stored? logged? sent to external API?) and how risk signals are structured – key for a tool dealing with untrusted data.

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

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

The description is three sentences, each serving a distinct purpose: usage context, behavior disclaimer, and pricing/licensing info. It is front-loaded with the most important information (when to use) and avoids unnecessary detail.

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

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

Given the tool has one parameter with no output schema and no nested objects, the description sufficiently explains the input and the general nature of the output. However, it lacks details on the structure of risk signals or the format of results, which would help an agent process the response. It also doesn't mention potential rate limits or costs for the pay-per-call option.

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

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

Schema description coverage is 0%, so the description must compensate for the single parameter 'text'. It states the parameter is 'pasted, retrieved, uploaded, or externally supplied text', which adds some context beyond the schema's basic string type and maxLength. However, the description could clarify expected encoding, whether to include surrounding whitespace, or if markup is handled. Baseline 3 is appropriate – minimal but adequate.

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

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

The description uses the verb 'scan' on the specific resource 'untrusted text' and clearly states the tool returns 'structural and heuristic risk signals'. It distinguishes itself from siblings by indicating it is for initial vetting of externally supplied text before ingestion, which is a unique purpose among the listed siblings.

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

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

The description explicitly states when to use this tool: 'before an agent ingests pasted, retrieved, uploaded, or externally supplied text'. It does not explicitly say when not to use it or name alternative tools, but the context is clear enough for an agent to decide, especially with sibling tools like 'sanitize_agent_context' and 'redact_sensitive_text' available for different steps.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true, and destructiveHint=false, which cover safety. The description adds value by specifying that wording is preserved and that hidden/control characters are normalized. It does not contradict annotations.

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

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

The description is very short, but it includes the irrelevant phrase 'Free or paid', which does not aid tool selection or invocation. The main sentence is concise, but the additional clutter reduces effectiveness.

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

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

The tool has two parameters, no output schema, and a sibling list of similar text-processing tools. The description lacks information about the behavior of each mode, the output format, error handling, or when to use this vs. 'scan_untrusted_text' or 'validate_output'. This is insufficient for effective agent use.

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

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

Schema description coverage is 0%, and the description provides no information about the 'text' or 'mode' parameters. The 'mode' enum values (standard, strict, unicode) are not explained, leaving the agent without guidance on how to use them. The description must compensate for low schema coverage but fails to do so.

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 normalizes hidden/control characters and formatting artifacts without rewriting wording. This is a specific verb+resource that distinguishes it from siblings like 'rework_text' (which might rewrite) and 'redact_sensitive_text'.

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 cleaning formatting while preserving content ('without rewriting wording'), but it does not explicitly state when to use this tool over alternatives like 'scan_untrusted_text' or 'inspect_text'. No exclusion criteria or prerequisite conditions are provided.

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

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

Annotations already indicate readOnlyHint=true, idempotentHint=true, and destructiveHint=false. The description adds a cost model (pay-per-call) but does not disclose other behavioral traits such as error handling, rate limits, or what happens on validation failure. The added value beyond annotations is modest.

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, front-loaded with the usage instruction, and contains no redundant words. Every sentence serves a clear 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 tool performs validation (critical for downstream actions), the description omits return value format, error behavior, and what constitutes a match. No output schema exists to compensate. The description is too brief to fully guide an agent's 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 the description does not explain the parameters. It implies 'output' is the JSON to validate and 'schema' is an optional schema, but adds no detail about accepted formats, constraints, or behavior. The description fails to compensate for the lack of schema descriptions.

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

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

The description clearly states the tool validates AI output for valid JSON or schema conformance. It uses a specific verb ('validate') and resource ('AI output'), but does not differentiate from siblings like check_action or verify_signed_signal, which may have overlapping validation 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 a clear usage context: 'Use immediately before a downstream action when model output must be valid JSON or match a schema.' It also notes pricing (trial, subscription, pay-per-call). However, it does not specify when not to use the tool or mention any alternative tools, so guidance is incomplete.

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

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

Beyond annotations (which only show non-readOnly and non-destructive), the description discloses important behaviors: timestamp freshness enforcement, nonce replay rejection, and that message/secret are never stored. This adds value over the minimal annotation hints.

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

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

The description is three sentences covering purpose, security, and environment/auth. It is concise and front-loaded with the core action. Could be slightly more structured but 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?

With 6 parameters, 0% schema description coverage, and no output schema, the description is too brief. It fails to explain parameter usage, return behavior, or error conditions. The tool combination of verification, freshness, and anti-replay needs more complete context for an agent.

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

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

Schema description coverage is 0%, so the description must compensate, but it does not explain any parameter meaning or constraints. It only implicitly references timestamp and nonce without detailing their roles or formats. Missing max_age_seconds entirely.

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

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

The description clearly identifies the action (verify), the resource (HMAC-SHA256 signal), and key behaviors (enforce timestamp freshness, reject replayed nonce). It effectively distinguishes this tool from sibling tools like create_signal and delete_signal.

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 context (production environment, subscription API key required) but does not explicitly state when to use this tool versus alternatives or when not to use it. It lacks direct usage guidance such as prerequisites or exclusions.

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