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

There are no annotations, so the description carries the full burden. It only says 'Confirms you're ready to work,' which is minimal. It doesn't disclose whether the action is reversible, what side effects occur (e.g., status change, notification), or any permissions needed. For a state-changing action, this is a significant gap.

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

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

The description is two sentences with no wasted words. It front-loads the action, then provides a clarifying consequence. Every word earns its place, and the [ANY ROLE] prefix is a succinct access hint.

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 (1 parameter, no output schema), so the description is adequate for basic understanding. However, it doesn't explain the broader workflow context, such as what happens after acceptance, whether it triggers other processes, or the expected result. It's functional but lacks depth.

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

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

Schema coverage is 100% (task_id is fully described), so the baseline is 3. The description adds no extra meaning for the parameter beyond tying it to the assignment, but it doesn't need to since the schema 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 states a specific verb ('Accept') and resource ('your task assignment'), and the possessive 'your' clearly distinguishes it from assign_agent (assigning someone else) and complete_task (finishing). The scope is explicit, making the tool's purpose unmistakable.

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

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

The description implies usage: you use it when you have a task assignment and want to confirm you're ready to work. However, it provides no explicit when/when-not guidance or alternatives, leaving the agent to infer context from sibling tools.

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

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

No annotations are provided, and the description offers minimal behavioral detail. It does not disclose side effects, irreversible consequences, required permissions, or what happens upon activation. For a critical emergency operation, this is a significant gap.

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

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

The description is a single, front-loaded sentence that concisely conveys the core action. It is appropriately sized, though it could provide more context while remaining concise.

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

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

Given the tool's complexity (4 parameters, no output schema, no annotations), the description is too sparse. It lacks information about activation semantics, valid_until format, trust_epoch meaning, and potential effects. The description does not fully equip an agent to use the tool correctly.

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

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

Schema description coverage is only 25%, with only trigger_evidence having a description. The tool description adds 'with evidence' but does not explain pathway_id, trust_epoch, or valid_until. The parameter names give some hints, but the description does not compensate for the lack of schema documentation.

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: activating a pre-authorized emergency pathway. The verb 'activate' and resource 'emergency pathway' are specific, and it distinguishes from sibling 'define_emergency_pathway' which handles creation.

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

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

The description implies use when an emergency pathway is pre-authorized and needs activation, but it does not explicitly state when to use it versus alternatives, nor mention prerequisites like prior definition of the pathway. No exclusions or alternative tool references 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?

With no annotations provided, the description carries full responsibility for disclosing side effects, but it merely says 'add a signature.' It does not state that this modifies the approval request, whether the operation is idempotent, or the security implications of supplying a private key. This lack of behavioral disclosure is a significant gap for a mutation tool handling sensitive key material.

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

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

The description is a single sentence with no redundant wording, and it front-loads the main action. However, given the tool's complexity (five parameters, sensitive keys), the brevity borders on under-specification. It is concise and well-structured but sacrifices substance for brevity.

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

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

The tool has five parameters, no output schema, and no annotations, yet the description provides only a minimal functional statement. It lacks any information about the approval workflow, return values, error conditions, or prerequisites. The description is completely inadequate for this context, especially given the sensitive nature of the operation.

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 five parameters, but it does not. It fails to clarify key_class, office_id, or the role of the signer_private_key and signer_public_key beyond their names. Users are left with only parameter names and no contextual 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 action ('Add') and the resource ('signature' to an 'approval request'), with a specific verb and object. It distinguishes itself from sibling tools like create_approval_request and sign_charter by specifying the unique operation. The purpose is unambiguous and immediately understandable.

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

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

The description provides no guidance on when to use this tool versus alternatives such as create_approval_request, gateway_approve, or sign_charter. It lacks any mention of prerequisites, workflow position, or situations where another tool should be preferred. Users must infer usage context solely from the tool name.

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

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

No annotations are provided, so the description bears full responsibility for disclosure. It indicates a mutation (adding) without explaining side effects, such as whether it overwrites, requires existing records, or has any idempotency. The 'three-way divergence reporting' hint adds purpose but not behavior, leaving significant gaps.

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

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

The description is two concise sentences with no wasted words. It is front-loaded with the core action and immediately provides the purpose context, making it easy to parse.

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

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

Given four required parameters, no output schema, and no annotations, the description is too minimal. It omits usage guidance, parameter details, and behavioral disclosure, leaving the agent with insufficient information to invoke the tool safely and correctly.

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

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

Schema coverage is 0%, and the description fails to explain any parameter meanings. While a reader might infer that parameters like outcome_id and observed_outcome relate to the principal's report, the description does not explicitly map them. This leaves the agent to guess from field names and the enum for outcome_class.

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: adding a principal's perspective to an existing outcome record. The phrase 'Enables three-way divergence reporting' gives additional context that differentiates this from sibling tools like create_outcome_record, which creates the record itself.

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

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

The description implies usage—when you need to add a principal's perspective to an outcome record—but it does not explicitly state when to use this tool versus alternatives, nor does it mention any prerequisites like requiring an existing outcome record. The context is clear but not elaborated.

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 are absent, so the description carries the full burden of behavioral disclosure. It only says 'apply downgrade', which restates the tool's name and implies a mutating action, but does not disclose side effects, reversibility, permission requirements, or what changes occur to the reputation.

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

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

The description is a single, front-loaded sentence with no redundant words, which is efficient. However, its brevity borders on under-specification, sacrificing useful detail for compactness.

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

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

With seven parameters, no output schema, and no annotations, the description provides an inadequate foundation for invoking the tool correctly. It lacks parameter semantics, return-value expectations, side effects, and any behavioral context beyond the tool name.

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 only 14% (only accept_from has a description). The description does not explain any of the seven parameters, such as attested_tier, attested_diversity_score, downgrade_ratio, or foreign_default_tier, nor how they relate to the downgrade logic. It fails to compensate for the sparse schema.

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

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

The description uses a specific verb ('Apply') and names the resource ('import policy downgrade' to 'foreign vouched reputation'), which makes the purpose clear and distinguishes it from generic tools like update_reputation. However, the phrasing is jargon-heavy and does not explicitly enumerate differentiation from sibling tools.

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

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

No guidance is provided on when to use this tool versus alternatives such as update_reputation or vouch_reputation. The phrase 'foreign vouched' implies an import-policy context, but there are no exclusions, prerequisites, or alternative recommendations.

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

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

With no annotations provided, the description carries the full burden of disclosing behavior. It explains internal steps (per-axis totals, balanced-Merkle commitment, residual buckets) and the output format (fully signed record), giving agents a good understanding of what the tool does without side effects being hidden. It stops short of explicitly stating safety or side-effect status.

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

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

The description is concise and front-loaded with the primary purpose. Four sentences cover the main action, internal processes, and output. Each sentence adds useful information, though it could be slightly tighter without losing essential 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?

The tool is complex with nested objects and no output schema, but the description explains the output type and high-level structure (axes, commitments, residual buckets). It also references a spec file. It does not elaborate on the receipts array elements or prerequisites, but overall it gives sufficient context for a capable agent.

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

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

The input schema already has detailed descriptions for all parameters (80% coverage), including period semantics and gateway fields. The description adds context about the period being half-open and the signed output, but it does not deepen parameter-level meaning beyond the schema. Baseline 3 is appropriate.

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

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

The description clearly identifies the tool's function with a specific verb ('Aggregate') and resource ('Attribution Primitives' into a 'SettlementRecord'). It also details the half-open period, axis outputs, and residual buckets, making it distinct from siblings like aps_verify_settlement or generate_settlement.

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 by describing the input, process, and output, implying when to use it (for batch aggregation of primitives into a signed settlement). It does not explicitly mention alternatives or exclusions, but the context is strong enough to guide selection among siblings.

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

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

No annotations are provided, so the description must carry the safety/behavioral burden. It discloses that signatures are ignored and that the computation is canonical (sha256), which explains key input handling and determinism. It doesn't cover errors or return format, but for a simple hash helper this is adequate.

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

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

Two sentences, front-loaded with the action ('compute'), no redundant phrasing. Every clause carries meaning about purpose, behavior, or usage.

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

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

For a one-parameter compute tool with no output schema and no annotations, the description explains what it does, why it exists, and key input behavior. It could specify the return type (e.g., hex string) but that's implied by 'sha256 id' and not a major 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?

The schema already documents the single 'receipt' parameter as 'AttributionReceipt JSON (signatures ignored)' with 100% coverage. The description adds 'unsigned core' but that is semantically equivalent to the schema's note, providing no extra value over structured data.

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

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

The description uses a specific verb ('compute'), identifies the resource ('canonical sha256 id of an AttributionReceipt's unsigned core'), and distinguishes itself from sibling tools by focusing on id generation for tamper detection, not receipt creation or verification.

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

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

It clearly positions the tool as a helper for verifiers to detect id tampering, implying when to use it. It doesn't explicitly name alternatives or exclusions, but the use case is concrete enough given the sibling tool names.

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

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

With no annotations, the description carries the full burden and does well by disclosing that it returns a null value for no-share contributors and that the response includes the full signed record and per-axis data. It also mentions the trust property (verifiable without trusting the gateway), adding behavioral context. It omits any mention of side effects or permissions, but as a query-building tool, no mutations are implied.

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

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

The description is a single, information-dense sentence that front-loads the primary action. It includes all essential details without redundancy, though a slight split into two sentences could improve readability. It remains concise and effective.

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

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

For a tool with no output schema, the description adequately specifies the return values (total_weight, contribution_count, merkle_path, axis_root, full signed record) and the null case. It explains the end-to-end verification use case. It doesn't cover all potential error conditions, but given the modest complexity, the description is sufficiently complete.

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

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

The input schema has full (100%) description coverage for all three parameters. The description adds minimal extra meaning beyond the schema, only confirming the role of record and contributor_did. This meets the baseline of 3, as the schema already provides the necessary 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 with a specific verb ("Build") and a specific resource ("contributor-query response"). It distinguishes itself from sibling tools by detailing the exact input (signed SettlementRecord and contributor DID) and output (per-axis fields plus the signed record), leaving no ambiguity about its 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 a clear context: use this when you have a signed SettlementRecord and need a contributor's share verification data. It explains the output and the null case, which guides the agent on when to call it. However, it does not explicitly mention alternatives or when not to use it, which prevents a perfect score.

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

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

With no annotations, the description carries the full burden. It states this is a request for permit/deny but does not disclose side effects, whether it mutates state, consumes the token, is idempotent, or has security implications. The mention of a 'revealed authority-token preimage' hints at sensitivity but leaves out consequences.

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

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

The description is compact: two sentences plus search keywords. Every sentence adds protocol context. The jargon (v0.1, M2, sink) is dense but purposeful for the domain. The search keywords are a minor extra but do not hurt.

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 complexity (7 params, nested objects, no output schema), the description explains the overall purpose and the flow but omits expected return format (permit/deny response structure) and any prerequisites beyond M1. It is adequate for a protocol-literate developer but not self-sufficient.

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

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

Schema description coverage is 71%, so the schema already documents most parameters. The description adds context by mapping 'sink's M1' to challenge, 'delegation chain' to delegation_chain, and 'authority-token preimage' to authority_token, but it does not explain the less-covered fields like freshness_beacon or the nested token_preimage/merkle_proof semantics beyond the schema.

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

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

The description clearly identifies the tool as a capability-token authority evaluation request (M2) and explains the protocol flow: the subject signs a request carrying M1, delegation chain, and token preimage, which the gateway consumes to permit/deny. This distinguishes it from sibling tools like aps_capability_issue_challenge (M1) and aps_capability_mint_receipt.

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: it is the M2 step after receiving the sink's M1, and it is used to request an authority decision. It does not explicitly list when-not-to-use or alternative tools, but the protocol framing and sibling names imply a specific place in the capability-token flow.

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

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

With no annotations provided, the description carries the burden of behavioral disclosure. It does reveal that the tool signs an action statement, returns a challenge and hash, and is part of binding gateway policy evaluation. However, it does not state whether the operation is non-mutating, idempotent, or whether specific permissions or key formats are required beyond the schema.

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

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

The description is concise: three sentences plus a search keywords line. It front-loads version and protocol context, clearly states the action and return values, and ends with useful search tags. Every sentence earns its place with no filler.

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

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

The tool has 7 parameters with nested objects and no output schema, so the description must compensate. It provides the purpose, return fields, and usage context, but does not explain the structure of the challenge, error conditions, or how to handle the signing keys. The info is sufficient for a basic understanding but not fully complete 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 moderate (71%), not high enough to avoid additional parameter guidance. The description only references the 'action' parameter via 'signed canonical action statement' and does not explain optional parameters like validity_seconds or required_policy_freshness, leaving a gap for these self-explanatory but undocumented 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 states a specific action: 'Sink issues a signed canonical action statement' and returns the SinkChallenge and its challenge_hash. This clearly identifies both the function and outcome, and the tool name 'issue_challenge' plus context 'capability-token sink challenge (M1)' distinguishes it from sibling tools like aps_capability_evaluate_authority or aps_capability_sign_effect.

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 contextual usage: it is used in capability-token flow step M1 to 'bind the gateway's later policy evaluation to a specific action the sink authored.' This implies when to use the tool (as a precursor to gateway evaluation) but does not explicitly mention when not to use it or name alternatives, which is a minor gap.

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

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

No annotations are provided, so the description bears full responsibility for disclosing side effects and operational traits. It mentions signing and echoing but does not explain whether a receipt is stored, returned, or what permissions are required. The private key usage is implied but not stated explicitly.

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

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

The description is compact—three sentences plus search keywords—and front-loads the 'capability-token gateway receipt' label. It is efficient, though the M2/M3 jargon could be clarified without much extra length.

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, lack of output schema, and absent annotations, the description is incomplete. It does not explain the overall flow, return value, or how the inputs like request and gateway_private_key are used, assuming substantial domain 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 only 33%, leaving most parameters (request, deny_reason, gateway_private_key, gateway_public_key) undocumented. The description introduces terms like challenge_hash and delegation_chain_root that are not directly mapped to schema properties, adding some context but failing to explain the parameters themselves.

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

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

The description states the tool signs a permit or deny over the sink's challenge_hash and echoes the delegation_chain_root, making the core function clear. It distinguishes from siblings like aps_capability_evaluate_authority by positioning itself as the 'M3 gateway receipt' step, though it relies on domain-specific shorthand.

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

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

No explicit guidance on when to use this tool versus alternatives such as aps_capability_issue_challenge or aps_capability_sign_effect. The description implies it fits an M2-to-M3 flow but does not state prerequisites, sequence, or exclusions.

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

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

With no annotations provided, the description carries the full burden and does well: it discloses the nullifier replay rejection, token consumption, action execution, and signing of the EffectReceipt binding token to result. This goes beyond what the schema or name alone would convey, though it does not mention reversibility or permission requirements.

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

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

The description is two dense sentences plus search keywords. It is front-loaded with the version and role, and every sentence adds value—protocol position, behavior, and attestation context. 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?

There is no output schema, so the description should clarify what the tool returns. It says 'signs an EffectReceipt' and mentions the attestation tuple, implying the receipt is the output, but it never explicitly states the return value or error cases beyond nullifier replay. For a complex protocol tool with 7 parameters, this leaves a noticeable 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 coverage is 57%, with challenge, challenge_receipt, and gateway_public_key already described. The description adds protocol context (M3 preimage, M1 binding) but does not explicitly explain sink_private_key, sink_public_key, or the effect object structure beyond what the schema already shows. It partially compensates but not fully.

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 and resources: 'consumes the token preimage', 'executes the action', and 'signs an EffectReceipt'. It clearly identifies this as the M4 sink step in the capability-token protocol, distinguishing it from sibling tools like aps_capability_issue_challenge and aps_capability_mint_receipt.

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 protocol sequencing: it must be invoked after the gateway's M3, consuming the token preimage from that step. It references the (M1, M3, M4) tuple, which implies the prerequisite context. However, it does not explicitly state alternatives or when not to use this tool, so it misses the full top score.

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

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

With no annotations provided, the description carries the full burden and meets it thoroughly. It discloses validation conditions (signed, unexpired receipts, content + principal match, replay protection, key binding), failure behavior ('stop passing this gate'), and the precise meaning of both a positive result and a non-result. This is well beyond what the schema or name alone communicate.

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 dense but every sentence earns its place: purpose, validation criteria, valid-result semantics, non-implications, and a failure condition. The main purpose is front-loaded, and the remaining sentences efficiently add essential detail 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 and no annotations, this description is remarkably complete for a complex validation tool. It tells the agent what inputs must satisfy, what a passing result establishes, what it does not establish, and what causes failure. The agent can invoke this tool with a clear mental model of its behavior.

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

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

Schema coverage is 100%, so the baseline is 3, but the description adds substantial meaning beyond the property descriptions. It explains what makes receipts acceptable, how citations must resolve, and what binding context implies. It does not map these rules to each parameter name directly, but it enriches the agent's understanding of artifact and receipts enough to justify a 4.

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 opens with a specific verb and resource: 'gate a binding artifact's citations.' It immediately distinguishes this from the many aps_verify_* siblings by focusing on artifact citations backed by receipts, and the validation conditions are clearly enumerated.

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 this gate is appropriate and explicitly states a limitation: 'What it does not establish: authority to act on the artifact.' It does not name alternative sibling tools, but the boundary semantics and the check/gate framing make the intended use reasonably clear.

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

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

No annotations are provided, so the description carries the full burden. It discloses the return shape ({required, requirement?, reason?}) and the escalation-boundary nature of the check. However, it does not explicitly state whether the check is read-only, whether it mutates any state, or whether special authorization is required.

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

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

The description is three concise sentences. The first sentence front-loads the core purpose, the second gives the return shape, and the third points to the related confirmation tool. There is no filler or redundancy.

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

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

There is no output schema, but the description explicitly provides the return object shape. Combined with the detailed input schema, this gives enough context for the tool's usage. It lacks edge-case or error behavior, but that is not critical for this simple guard-check 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 100%, and each parameter already has a helpful description (e.g., delegation, session_id, action_class, action_details). The tool description adds no parameter-level detail beyond the schema, so the baseline score of 3 applies.

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

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

The description clearly states a specific action: 'check whether an action on a v2 delegation requires owner confirmation before execution.' It names the resource (v2 delegation) and the check semantics, and it distinguishes itself from related tools like create_v2_delegation and aps_record_owner_confirmation.

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 for when to use the tool: 'before execution' of an action on a v2 delegation. It also names the relevant follow-up tool (aps_record_owner_confirmation) to clear the flag when required. It does not explicitly enumerate when not to use the tool or mention alternative check tools.

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

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

The description fully specifies the return values: {same_receipt: true} for success, and {same_receipt: false, reason: ...} with four enumerated reason codes for failure. Since no annotations are provided, this output disclosure carries the transparency burden, though it doesn't explicitly confirm read-only behavior or describe malformed input handling.

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

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

The description is two sentences: the first states the purpose, the second precisely lists the output schema and reason enums. No filler, well-front-loaded, and 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?

The description provides the complete output contract (since no output schema exists), covering both success and all failure reasons. It is sufficient for an agent to invoke and interpret results, though it omits edge-case behavior like invalid projection 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?

With 100% schema description coverage (projection_a and projection_b each have brief descriptions), the baseline is 3. The description adds limited value beyond restating that two projections are involved; it does not explain what constitutes a valid projection or how to format 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 states the tool performs a cross-projection consistency check to confirm two projections originate from the same signed receipt. This specific verb-resource pairing distinguishes it from sibling verification tools that focus on single projections.

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

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

The description implies usage when you have two projections that need to be checked for shared receipt origin, but it does not explicitly contrast with alternatives like aps_verify_attribution_projection or provide when-not-to-use guidance. Usage context is implicit 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?

With no annotations provided, the description carries the full burden. It discloses the output format (hex sha256) and conceptual role (anchor for axis projections), but it does not mention side effects, error behavior, or input prerequisites. For a seemingly pure computation, the lack of explicit 'no state change' or failure-mode information is a gap, but the essential behavior is adequately conveyed.

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, front-loaded with the core action, and every sentence provides value: what it does, what action_ref is, and a practical use case. No fluff or redundancy makes it appropriately concise.

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

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

Given 4 required parameters, no annotations, no output schema, and 0% schema description coverage, the description is incomplete. It explains the purpose and output but leaves the input structure wholly undocumented, forcing the agent to guess how to form a valid action tuple. This is a significant gap for a tool that depends on precise parameters.

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

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

Schema description coverage is 0%, and the description does not explain any of the four parameters (agentId, actionType, params, nonce). It only vaguely references an 'action tuple' without mapping the tuple components. The meaning of nonce, structure of params, and nature of agentId/actionType are left entirely to inference, which is insufficient for reliable 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: 'Derive the action_ref (hex sha256) for an action tuple.' This is a specific verb ('derive') and resource ('action_ref'), with additional context about it being a content-addressed anchor. It distinguishes from sibling tools like aps_construct_attribution_primitive by focusing on the hash computation rather than the full primitive.

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 use case: 'Useful for indexing primitives by action without constructing the full primitive.' This tells the agent when it is appropriate to use this tool, implying a niche between construction and projection. However, it does not explicitly mention alternatives or when not to use it, so it stops short of full 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?

With no annotations provided, the description carries the full burden for behavioral disclosure. It transparently reveals the computation formula (prompt_tokens + completion_tokens × COMPLETION_MULTIPLIER, default 3.0), the normalization, and the output format (canonical ComputeAxisEntry[] with 6-digit decimal strings summing to ~1.0). This is substantial, although it omits error handling, permissions, and potential side effects, which prevents a 5.

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

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

The description is compact yet information-dense, covering purpose, formula, output, and usage in roughly four sentences. It is front-loaded with the core action and immediately gives the output type and downstream consumer. Every clause contributes substance without redundancy, making it an excellent example of conciseness.

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

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

Given the tool's complexity and the absence of an output schema, the description thoughtfully explains the return format and the computation, filling the gap left by no output schema. It also connects to the downstream primitive. While it doesn't cover edge cases, error conditions, or profile details, the provided context is sufficient for typical use, so it scores a 4.

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

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

Schema description coverage is 100%, so the schema already documents both parameters. The description adds beyond this by explaining how the parameters are used: 'providers' are per-provider billing records, 'profile' is an optional override, and the formula ties prompt_tokens/completion_tokens to the multiplier. This enriches the semantics beyond the raw schema, meriting a 4 (baseline is 3 for high coverage, and this adds extra 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 identifies the tool's function: 'Compute the C-axis fractional weight vector from a list of inference billing records'. It specifies a concrete verb ('compute'), a resource ('C-axis fractional weight vector'), and contextual distinction by referencing the sibling primitive 'aps_construct_attribution_primitive' and implicitly contrasting with 'aps_compute_data_axis_weights' (sibling). This makes the tool's purpose unmistakable.

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

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

The description provides clear context for when to use the tool: 'feed directly into aps_construct_attribution_primitive' and lists the input type (inference billing records). It implies the tool is for C-axis weight computation, which differentiates it from siblings like 'aps_compute_data_axis_weights'. However, it lacks explicit 'when not to use' or alternative guidance, so it earns a 4 rather than 5.

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

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

With no annotations provided, the description carries the full burden. It discloses important behavioral details: empty input returns empty array, all-zero raw weights cause an error, output uses 6-digit decimal strings, weights sum to ~1.0, and the exact formula (role × recency_decay × length_weight) normalized per spec BUILD-B.

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

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

The description is compact and dense: three sentences cover purpose, output, edge cases, formula, spec reference, and SDK naming. Every sentence earns its place and the information is front-loaded.

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

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

Despite no output schema, the description gives a complete picture: input types, output format, normalization target, error condition, formula reference, and a downstream consumer. It is sufficient for an agent to decide when and how to invoke it.

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

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

Schema coverage is 100%, so parameters are already described in structured data. The description adds value by explaining the weight formula, the default profile behavior, and that parameter names align with the SDK, which helps an agent understand how the parameters interact.

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 opens with a specific verb ('Compute') and clearly identifies the resource ('D-axis fractional weight vector'), input type (AccessReceipt records), and output (DataAxisEntry[]). It also ties the output to a downstream sibling (aps_construct_attribution_primitive), which helps distinguish it from other computation tools.

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

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

Usage is strongly implied by stating the input requirements and that the result 'feed[s] directly into aps_construct_attribution_primitive.' It also conveys context like empty/all-zero edge cases, but it does not explicitly state when not to use this tool or mention alternatives for other axes.

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

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

With no annotations provided, the description carries the transparency burden. It clearly states that the tool builds and signs an object, names the axes, and says it returns the complete signed object—implying a pure construction operation with no hidden persistence. It does not disclose potential failure modes or validation requirements, but the core behavior is well 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 two concise sentences: the first states the function and names the axes, the second states the return value. There is no redundancy or filler, and the most critical information is front-loaded.

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

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

The tool has 5 parameters with nested schemas and no output schema. The description adequately communicates the overall scope, axes names, and return value, which is enough for a well-described schema. It lacks explicit usage guidance and deeper behavioral caveats, but the core invocation context is present.

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 100% parameter coverage with detailed descriptions (e.g., action_ref derivation, axes spec reference, issuer DID, key format, timestamp default). The tool description adds no parameter-level meaning beyond the axis labels, so the baseline 3 applies due to high schema coverage.

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

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

The description uses a specific verb and resource: 'Build and sign a four-axis AttributionPrimitive for an action.' It names all four axes (D, P, G, C), making the purpose unmistakable. It also distinguishes from sibling tools like aps_verify_attribution_primitive by emphasizing construction and signing, and notes the return value.

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: you use it when you need to build and sign an attribution primitive for an action. However, it offers no explicit when-to-use guidance or contrast with similarly named tools (e.g., aps_create_attribution_receipt, aps_create_provisional), so the choice among alternatives is not clarified.

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

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

With no annotations, the description carries the behavioral burden and does useful work: it states that the receipt will not verify with bare public keys or did:web identifiers and that the created receipt is not yet valid until consent is signed. It does not describe return values or persistence side effects, but the key state transition is 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?

Three sentences, each carrying essential information: the purpose, the DID representation constraint, and the validity lifecycle. No redundant restatement of schema fields or 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?

Given 9 parameters and no output schema or annotations, the description covers the critical protocol context: what is built, how parties must be represented, and why the receipt is not immediately valid. It could be more complete by stating what the tool returns or whether it persists the receipt, but the missing information is secondary to 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 coverage is 100%, so the baseline is 3, and the description adds real value by explaining that each DID must commit to its adjacent public key and by naming invalid forms (bare public key, did:web). This supplements the schema's per-field descriptions with a cross-field constraint.

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

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

The description names a specific action ('build a citer-signed AttributionReceipt attributing a claim to a third-party principal') and clearly identifies the resource and principal parties. It also distinguishes this from related attribution operations by emphasizing the citer-signed representation boundary and the subsequent consent step.

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 workflow context: the receipt is created before the cited principal signs consent, and it will not be accepted by checkArtifactCitations until aps_sign_attribution_consent is completed. It does not explicitly contrast this tool with aps_create_provisional or aps_construct_attribution_primitive, so exclusions are left implicit.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It reveals key behaviors: default non-binding, promotion condition via PromotionPolicy, and dead-man expiry auto-withdrawal. It lacks details about persistence or return behavior, but the disclosed lifecycle semantics are substantial.

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 dense, front-loaded sentences with no filler. The opening 'Commitment boundary' provides framing, and each subsequent sentence adds essential lifecycle information.

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

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

For a lifecycle-driven provisional commitment tool, the description covers the core purpose, non-binding default, promotion trigger, and expiry behavior. It could be improved by referencing sibling tools for promotion/withdrawal and clarifying the return value, but the schema covers parameter details fully.

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

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

Schema description coverage is 100%, so the baseline is 3. The description adds contextual meaning around dead-man expiry and promotion policy, but it does not provide parameter-level detail beyond what the schema already documents.

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 'emit a provisional statement for agent-to-agent negotiation' with a specific verb and resource. It further distinguishes itself by explaining 'non-binding until a PromotionEvent satisfies a PromotionPolicy,' setting it apart from final/promotion-related tools.

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

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

The description provides clear context for when to use the tool: for non-binding, provisional statements in agent-to-agent negotiation. It implies exclusions (e.g., not for binding commitments) but does not explicitly name alternatives like aps_promote_statement or aps_withdraw_provisional.

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

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

With no annotations provided, the description carries the full burden and adds meaningful detail: it discloses that the projection contains axis content plus a two-hop Merkle path, and explains the cryptographic purpose. It does not fully describe the return format or error behavior, but this is a simple read-like operation.

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

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

The description is compact and front-loaded, with the first sentence stating the core operation. The remainder adds essential behavioral details and the axis enum without unnecessary 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?

The description is complete for a straightforward extraction tool: it identifies inputs, output contents, and downstream use. There is no output schema, but the description adequately covers the key return aspects, though it could mention the exact return type or structure.

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

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

Schema description coverage is 100%, and the description merely mirrors the schema by listing axis values and referring to aps_construct_attribution_primitive for the primitive parameter. No additional parameter semantics are added beyond what the schema already provides.

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

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

The description uses a specific verb ('Extract') and identifies the exact resource ('AttributionPrimitive'), making the action unambiguous. It also distinguishes the tool from siblings like aps_verify_attribution_projection by describing the projection's content and 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 implies usage by explaining that the projection is for downstream verification, but it does not explicitly state when to prefer this over alternatives or provide exclusions. No sibling tool is mentioned, unlike the get_calls exemplar.

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

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

With no annotations provided, the description carries the full burden. It discloses the core mechanism (attaching a PromotionEvent satisfying m-of-n signatures) and a key edge case (dead_man_elapsed auto-withdraws). However, it does not mention permissions, reversibility, side effects, or return behavior, which are important for a mutation 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 two sentences, front-loaded with 'Commitment boundary:' and zero redundant wording. It efficiently covers purpose, mechanism, and an exclusion in a compact, well-structured form.

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 provides good context for the core operation and leverages the schema's parameter descriptions. However, since there is no output schema, the description does not explain return values, error cases, or post-promotion behavior (beyond 'binding'). It also omits prerequisites such as needing a valid provisional statement, aside from what is inferred from the schema.

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

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

Schema coverage is 100%, so baseline is 3. The description adds value by explaining the relationship between promotion_event and policy ('m-of-n principal signatures') and by clarifying that dead_man_elapsed is an invalid state. This helps the agent understand how to construct valid parameters beyond the terse schema descriptions.

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

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

The description clearly states the tool's purpose: 'promote a provisional statement to binding by attaching a PromotionEvent that satisfies the PromotionPolicy (m-of-n principal signatures)'. It uses a specific verb (promote) and resource (provisional statement), and the scope (to binding) is explicit. It distinguishes itself from sibling tools like aps_create_provisional and aps_withdraw_provisional.

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 boundary by stating 'dead_man_elapsed cannot promote — it auto-withdraws via the dead-man path.' This gives an explicit when-not condition. However, it does not name an alternative tool (e.g., aps_withdraw_provisional) for the dead-man path, so it falls short of fully explicit alternatives.

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

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

With no annotations, the description must disclose behavior itself. It does disclose that the call builds and signs in one action, binds via hash, and is scoped. However, it omits important traits such as whether the confirmation is persisted, what the return value looks like, and the security implications of providing the owner's private key.

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

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

The description is three sentences with no filler. Each sentence adds distinct value: the escalation context, the single-call build-and-sign behavior, and the technical binding/scoping details. It is front-loaded with the core purpose.

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

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

This is a signing/authorization tool with no output schema and no annotations, so the description needs to carry more weight. It explains the core mechanism, but it does not mention what the tool returns, any prerequisites (e.g., valid delegation, matching key), or what happens after the confirmation is created.

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

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

Schema description coverage is 100%, so the baseline is 3. The description adds a little extra context about scoping (per_action/per_session/time_window) and hash-binding of action_details, but the parameter meanings are mostly already covered by 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 states a clear action: 'Builds the ConfirmationRequest and signs it in a single call.' It specifies the resource (OwnerConfirmation) and the context (escalation boundary for flagged actions), which differentiates it from sibling tools like generic approval/request tools.

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

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

It provides clear context: this is for the escalation boundary where an owner authorizes a flagged action. It implies use when an action has been flagged and requires owner confirmation, but it does not explicitly name alternatives or exclusions relative to similar approval/signing tools.

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

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

With no annotations, the description carries the full disclosure burden. It explains the mutation ('adds their consent signature'), the downstream consequence for verification tools, and the cryptographic requirement that the signature is checked against the receipt's party key and the DID-committed key. It does not mention return values or explicit failure modes, but the core behavioral traits are covered.

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

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

The description is three sentences and each contributes: the action, the downstream dependency, and the key-validity constraint. The phrase 'Representation boundary' is somewhat jargon-heavy, but the description is otherwise dense and front-loaded.

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

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

For a two-parameter signing operation with no annotations and no output schema, the description adequately covers purpose, workflow placement, and the key-matching precondition, which is sufficient for an agent to select and invoke the tool correctly. It omits the return shape and failure behavior, but the input schema covers the parameters and the dependency context is strong.

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

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

Schema coverage is 100%, so the baseline is 3. The description adds meaningful param semantics by linking the private key to the receipt: the key must match the one the receipt carries for that party and must be the one committed to by that party's DID. This clarifies the relationship between the two otherwise separate 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 states a specific action and resource: the cited principal 'adds their consent signature to an AttributionReceipt.' It also distinguishes this tool from its verification siblings by explaining that verifyAttributionConsent and checkArtifactCitations reject the receipt without this signature.

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 usage context: use this before relying on verifyAttributionConsent or checkArtifactCitations, and ensure the signing key is the one the cited principal's DID commits to. It does not explicitly list when-not-to-use or alternative tools, but the named dependencies make the intended placement in the workflow clear.

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

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

With no annotations, the description carries the full burden and succeeds: it discloses the exact checks, the meaning of a valid result, the non-guarantees about authorization and identity, the refusal behavior for identifiers that do not self-certify, and the return shape {valid, reason?}. This goes well beyond the tool name and schema.

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

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

The description is tightly structured: a one-line boundary statement, followed by clearly labeled valid-result semantics, non-guarantees, refusal semantics, and return shape. No sentence is redundant, and the most important scope information is front-loaded.

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

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

For a verification tool with two parameters, full schema coverage, and no output schema, the description supplies the missing return contract and behavioral caveats. An agent can understand what to pass, what success means, what it must not infer, and what response to expect.

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

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

Schema description coverage is 100%, so the baseline is 3. The description adds context about what the receipt verification establishes, but it does not add parameter-specific meaning beyond the schema's descriptions for receipt and now.

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 verb 'verify' with the resource 'an AttributionReceipt end-to-end', enumerating the checked elements (id, citer signature, consent signature, expiry) and the party-to-key binding. It also clarifies the scope by explicitly saying what a valid result does and does not establish, distinguishing this end-to-end verification from narrower verification tools among the 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 conveys a clear intended use: verify a full attribution receipt and interpret its meaning. It lacks explicit naming of sibling alternatives such as aps_verify_attribution_primitive or explicit when-not-to-use conditions, but the 'end-to-end' framing and the 'does not establish' boundary give strong contextual guidance for 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?

With no annotations provided, the description carries the burden of behavioral disclosure. It adds useful context by explaining that the tool constructs projections for all four axes before verifying, but it does not mention potential side effects, error behavior, or return format. This is acceptable 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, front-loaded with the primary verb 'verify,' and free of unnecessary detail. It efficiently conveys purpose and usage 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?

For a two-parameter verification tool with no output schema, the description covers purpose, usage, and key behavioral details. The only gap is that it does not indicate what the tool returns (e.g., boolean, result object), but the overall context is reasonably 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 schema already covers both parameters with descriptions (100% coverage), so the baseline is 3. The description adds some context by referring to 'full' primitive and 'four axes,' but it does not clarify the expected type/structure of the primitive parameter beyond what the vague schema says.

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

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

The description clearly states the tool performs 'End-to-end verify of a full AttributionPrimitive' and specifies it constructs projections for all four axes. It uses a specific verb and resource, and distinguishes itself from sibling tools like aps_verify_attribution_projection by emphasizing 'full' verification.

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

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

The description provides explicit use cases: 'post-construction sanity check' and 'verifying a primitive received from a peer.' However, it does not explicitly name alternatives or state when not to use this tool, so it falls just short of a perfect score.

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

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

With no annotations to rely on, the description carries the burden of behavioral disclosure. It discloses the return format ({valid: true} or {valid: false} with specific reason codes) and reveals a key behavioral trait ('purely local'), which is valuable. It does not mention potential exceptions, performance, or permission requirements, but for a verification tool the return-value transparency is strong.

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 concise sentences, each adding necessary information. It front-loads the verb and resource, then details the return format and the local-only nature. No redundant or filler content, making it highly 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 verification tool with two well-documented parameters and no output schema, the description is complete. It explains the return values (including possible reason codes) and the local execution model, covering all essential aspects a user would need to invoke the tool correctly.

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

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

The schema already provides 100% coverage for both parameters ('projection' and 'issuer_public_key'), including descriptions. The tool description adds minimal extra meaning beyond the schema—only clarifying that 'projection' comes from aps_project_attribution, which is also mentioned in the schema. Thus, baseline 3 is appropriate.

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

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

The description clearly states the tool's purpose: verifying a single-axis AttributionProjection under the issuer's Ed25519 public key. It uses a specific verb ('verify'), identifies the resource ('AttributionProjection'), and distinguishes itself by noting 'single-axis' and 'purely local — no other axes required', which differentiates it from sibling APS verification tools.

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

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

The description provides some usage context by emphasizing 'single-axis' and 'no other axes required', implying this tool is appropriate for single-axis verifications without requiring additional data. However, it does not explicitly name alternative tools or state when to use them, leaving room for clearer guidance.

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

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

No annotations are present, so the description must carry the burden. It discloses the internal verification logic in detail, but it omits the return behavior (e.g., boolean, throw) and side effects (likely read-only but not stated). The term 'verify' implies a non-mutating check, but this is not made explicit.

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

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

The description is a single sentence, front-loaded with the key action 'verify'. The parenthetical list is dense but each item is meaningful and directly supports the purpose. No filler 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 description thoroughly explains what is verified, but because there is no output schema, it leaves out what happens on success or failure (e.g., returns boolean, raises exception). For a verification tool, this behavioral outcome is important context. Still, the core operation 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?

Schema coverage is 100% with short descriptions for both parameters, giving a baseline of 3. The tool description adds semantic context by enumerating the criteria checked, which clarifies how 'statement' (PromotionEvent) and 'policy' are used together. This adds value beyond the schema's minimal 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 a specific action: 'verify that a promoted statement's PromotionEvent cryptographically satisfies the PromotionPolicy'. It lists concrete checks (policy_reference match, promoter in required_signers, threshold, signature, max_time_to_promote, author-signature tamper check), distinguishing it from other verify tools like aps_verify_attribution_consent or verify_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 phrase 'Commitment boundary' provides clear context for when this tool is used, implying it is the validation step after promotion. However, it does not explicitly name 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 no annotations, the description carries the behavioral transparency burden. It discloses the return format ({valid: true} or {valid: false, reason, detail}), highlights the strongest invariant (S3 conservation) and its security implication. It could mention error handling for malformed records, but the provided details are meaningful.

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

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

The description is two sentences with no filler. It front-loads the action and scope, then adds the key invariant and return format. Every sentence earns its place.

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

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

For a read-only verification tool, the description is quite complete: it lists the verification criteria (S1-S5), describes the return shape, and explains the optional parameter behavior. The lack of an output schema is partially mitigated by the return format. Minor gaps include not explaining terms like 'residual shape' for unfamiliar agents, but this is acceptable for domain-specific tools.

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

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

Schema description coverage is 100%, so the baseline is 3. The description adds semantics beyond the schema by explaining that passing inputReceipts triggers S5 cross-checking and recomputes input_receipts_hash, and that gateway_public_key is the Ed25519 key for verification. This added context justifies a 4.

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 ('Verify') plus a specific resource ('a signed SettlementRecord') and scopes it to S1-S5 checks (signature, Merkle roots, conservation, residual shape, optional input-receipts cross-check). This clearly distinguishes it from sibling verify tools like aps_verify_attribution_primitive.

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

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

The description clearly indicates when to use the tool (to verify a signed SettlementRecord) and provides guidance on the optional inputReceipts parameter to enable an additional cross-check. It does not explicitly name alternatives or list exclusion conditions, but the context is sufficient for an agent to select it appropriately.

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

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

With no annotations, the description carries the transparency burden. It discloses the ownership requirement, the promoted-statement restriction, and the exact signature payload format (canonicalize({action:'withdraw', statement_id})). It does not mention reversibility or return behavior, but the disclosed constraints are substantial and actionable.

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, and every sentence adds distinct information. No fluff or redundancy.

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

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

The description covers the essential context for invocation: the action, constraints, and signature requirement. With no output schema, it omits return/error behavior, but the schema handles parameter documentation and the constraints are well-articulated. Moderately complete for a tool of this complexity.

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

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

Schema covers all 3 parameters with descriptions, but the description adds meaningful semantics by specifying the canonicalization payload for the author_signature and clarifying the author-ownership requirement for the statement parameter. This goes beyond what the schema provides.

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

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

The description states exactly what the tool does: 'author withdraws their own provisional statement.' It clearly differentiates from siblings like aps_create_provisional and aps_promote_statement by specifying the withdrawal action and the restriction against promoted statements.

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

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

Provides clear context (author withdrawing own provisional statement) and an explicit exclusion ('Already-promoted statements cannot be withdrawn'). Does not name alternative tools explicitly, but the when-not is clear enough for an agent to 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?

With no annotations provided, the description carries the full burden of behavioral disclosure. It discloses that the tool 'creates a delegation automatically,' which is a meaningful side effect. However, it does not mention any required permissions, potential overwrites, reversibility, or what the response looks like. For a mutation tool, this is not enough transparency.

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

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

The description is two concise sentences totaling 15 words. It is front-loaded with the primary action and adds the key side effect without any fluff. Every word contributes to the tool's understanding.

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

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

For a tool with 6 parameters and no output schema, the description is minimal. It covers the core action but fails to mention the return value or clarify the role of sensitive parameters like agent_public_key and spend_limit. It is adequate for a basic understanding but leaves gaps for an agent deciding whether to invoke it.

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

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

The input schema has 100% description coverage, so the baseline is 3. The description does not add any meaning beyond the schema; it merely restates the overall purpose. The parameters like spend_limit and agent_public_key are not explained further in the description, but the schema already provides adequate descriptions for each.

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: 'Assign an agent to a role in a task' and adds the key side effect 'Creates a delegation automatically.' This is a specific verb and resource, and it differentiates the tool from generic delegation tools like create_delegation by focusing on role assignment within a task. However, it does not explicitly name sibling alternatives or scope boundaries, so it stops short of a 5.

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

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

The description implies the tool should be used when an agent needs to be assigned a role in a task and a delegation should be created. It does not provide explicit when-to-use/when-not-to-use guidance or mention alternatives such as create_delegation, sub_delegate, or create_v2_delegation. The usage context is inferable but not explicitly stated.

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

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

With no annotations, the description carries the full burden of behavioral disclosure. It fails to state whether the attestation is irrevocable, whether it records a formal commitment, or if any authentication is required, leaving the agent underinformed about 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 a single concise sentence that is front-loaded with the verb and resource. It conveys the core purpose without unnecessary words, though it could benefit from more context without harming clarity.

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

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

For a commitment-related action, the description is too sparse. It does not explain the significance of attesting to the floor, the role of extensions, or any potential consequences, and there are no annotations or output schema to fill the 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?

The input schema fully documents both parameters, so the description adds no additional meaning beyond what is already provided. The high schema coverage (100%) sets a baseline of 3.

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 as 'Attest' and the resource as 'Values Floor', distinguishing it from sibling tools like load_values_floor which loads the floor rather than attesting to it.

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

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

No guidance is provided on when to use this tool versus alternatives. It does not mention prerequisites (e.g., the Values Floor must be loaded first) or any exclusions.

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

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

With no annotations provided, the description must carry the full burden of behavioral disclosure. It mentions the message is signed, which hints at authentication, but it does not disclose potential side effects, permissions required, delivery guarantees, or return behavior, leaving significant gaps for a mutation-style tool.

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

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

The description is a single sentence that is front-loaded with the action and scope. It contains no filler or 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?

Although the schema documents all parameters, there is no output schema and no annotations, so the description should explain return values or side effects. It only provides the basic action and target, leaving out important context like success/failure behavior, signing mechanism, or delivery semantics.

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

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

The input schema has 100% description coverage, so the schema already documents all parameters. The description adds no parameter-level detail beyond indicating the message is signed, which does not improve on the schema, hence the baseline score of 3.

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 ('Send'), a clear resource ('a signed message'), and an explicit scope ('to all agents'), making the tool's purpose unambiguous. It also names the endpoint ('comms/broadcast.json'), which helps distinguish it from sibling tools like send_message or post_agora_message.

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

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

The description clearly indicates the tool is for broadcasting to all agents, which gives context for when to use it. However, it does not explicitly mention when NOT to use it or point to alternatives for direct or targeted messaging, 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 no annotations, the description must fully disclose behavioral traits. It only states the check purpose, but does not mention side effects (if any), return format, what 'violate' means, or whether it is read-only. Minimal behavioral context beyond the obvious read-only implication of a 'check' operation.

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

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

The description is a single, front-loaded sentence that clearly names the operation and subject. It is concise and well-structured, though it sacrifices necessary detail for brevity.

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

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

For a tool with 9 parameters, no output schema, and no annotations, a one-line description is severely incomplete. It lacks essential context about parameter relationships, return values, error conditions, and the meaning of 'aggregate rate limits' in terms of the inputs. The description is inadequate for reliable invocation.

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

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

Schema description coverage is 0% and the description provides no parameter-level context. The 9 parameters, including required fields like currentAccessCount and windowStartMs, are completely unexplained. The description adds no value over the bare schema field 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 uses a specific verb 'check' with a clear resource 'aggregate rate limits', making it distinct from many other check_* siblings. It states exactly what the tool evaluates, though it does not explicitly differentiate itself from related check tools.

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

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

No guidance is provided on when to use this tool versus alternatives like check_usage_permitted or check_purpose_permitted. The description only states what it does, with no conditions, prerequisites, or exclusions.

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

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

No annotations are provided, so the description carries the full burden. It mentions that the tool prevents prohibited inferences and lists regulations, but it does not disclose return format, side effects, or error behavior. It is unclear whether this is purely read-only or if it blocks operations.

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 long, front-loaded with the primary purpose, and includes regulatory context without any fluff. Every word earns its place.

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

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

Given the tool has six parameters and no output schema or annotations, the description is too sparse. It does not explain expected return values, parameter usage, or behavior when a combination is not permitted, leaving the agent with significant 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%, and the description does not explain any of the six parameters. Parameter names like otherSourceId and forbiddenSourceIds are weakly self-describing, but 'reason' and 'otherSourceClasses' remain ambiguous. The description gives only a vague hint that two sources are involved.

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 whether combining data from two sources is permitted, with the regulatory context preventing prohibited inferences. It distinguishes from sibling check tools by specifying the combination scenario and relevant regulations.

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

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

The description implies the tool is used when combining data from two sources, but it does not explicitly state when not to use it or mention alternatives such as check_purpose_permitted or check_aggregate_constraints. The context is clear but exclusions are absent.

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

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

There are no annotations, so the description bears the full burden of behavioral disclosure. It only states the tool checks permission; it does not disclose the return type (e.g., boolean, reason list), whether it is read-only, or how the constraint types interact with the input parameters. This is insufficient for an agent to predict tool behavior.

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

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

The description is a single, well-front-loaded sentence with no wasted words, containing the core purpose and example constraints. It is appropriately concise for a simple tool, though it sacrifices necessary elaboration for brevity.

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

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

Given the absence of an output schema and annotations, the description should explain what the tool returns and how constraints map to the parameters. It does neither, so an agent would not know what to expect from the call or how to interpret the result. The tool is simple, but the description leaves too much unspecified.

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 only 40% (sourceJurisdiction and targetJurisdiction have descriptions; purpose, transferConstraints, and processingRestrictions are undocumented). The description adds no detail about these undocumented parameters and only references constraint names, which are not explicitly mapped to any parameter. It does not compensate for the low schema coverage.

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

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

The description states the tool checks whether a data transfer is permitted under jurisdiction constraints, using a clear verb ('Check') and specific resource ('data transfer'). It also lists three constraint types (EU_ONLY, GDPR_ADEQUATE_ONLY, NO_CROSS_BORDER), which helps distinguish it from generic check tools, though it does not explicitly differentiate from the many sibling 'check_*' tools.

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

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

No guidance is provided on when to use this tool versus alternatives. The description implies it is for jurisdiction-related transfer checks, but with siblings like check_purpose_permitted, check_combination_permitted, and check_usage_permitted, the absence of explicit usage context or exclusions leaves the agent without a clear selection basis.

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

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

With no annotations, the description carries the burden of behavioral disclosure. It reveals the data source (reads from a JSON file) and implies a read operation. However, it doesn't explicitly state that setting mark_read=true can modify state, nor does it describe the return format. This is a moderate gap.

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

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

Two short sentences, front-loaded with the purpose and backed by a data source. No wasted words and the structure is clean.

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 data source, which is adequate for a simple message-checking tool. It doesn't explicitly state what the tool returns, but with no output schema the return value is fairly obvious from context. Overall, it's complete for the tool's simplicity.

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?

Both parameters (mark_read, unprocessed_only) are fully described in the schema with defaults and coverage at 100%. The tool description adds no parameter-specific guidance, but the schema already provides sufficient semantics, so baseline 3 is appropriate.

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

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

The description clearly states the tool's purpose: checking messages addressed to the agent. It specifies the resource (messages addressed to you) and the data source (comms/to-{your-agent-name}.json), which distinguishes it from siblings like send_message or get_agora_topics.

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

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

The description gives clear context: use this to read personal messages addressed to you. It doesn't explicitly mention alternatives or exclusions, but the scope is unmistakable when compared to siblings like send_message or broadcast.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It reveals that the tool supports wildcards and hierarchical matching, which is useful behavioral context. However, it does not disclose the return format, edge-case behavior, or confirm that it is read-only, which limits transparency for a simple check tool without an output schema.

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

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

The description is two sentences, front-loaded with the main action and resource, and every word adds value. It states the core function and then a key capability without redundancy, making it highly concise and well-structured.

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

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

For a tool with only 2 parameters and no output schema, the description covers the primary functionality and the wildcard feature. However, it omits information about what the tool returns (e.g., a boolean or result object) and any potential error conditions. Given the simplicity of the tool, this is a noticeable gap, so a score of 3 reflects that it is 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?

The schema already describes both parameters with 100% coverage, but the description adds critical semantic detail by noting that purposes support wildcards (e.g., research:*). This goes beyond the schema's example values and clarifies how the `purpose` parameter can be formatted, enhancing the agent's ability to construct valid inputs.

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 opens with a specific verb+resource: 'Check if a purpose is permitted under source terms.' This clearly identifies the tool's function and scope, and the second sentence about wildcards and hierarchical matching adds a distinguishing feature that differentiates it from sibling check tools like check_usage_permitted or check_combination_permitted.

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

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

The description implies usage context through the wildcard and hierarchical matching features, but it does not explicitly state when to choose this tool over similar check tools or provide exclusions. For example, it doesn't mention that exact matching might be handled elsewhere. The guidance is implied rather than explicit, so a score of 3 is appropriate.

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

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

No annotations are provided, so the description carries full responsibility for behavioral disclosure. It only restates the check concept and does not disclose whether maxRetentionMs=null means never expires, how accessType affects the result, or whether the operation is side-effect free.

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

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

The description is a single sentence with no redundancy, front-loading the verb and subject. It is appropriately terse for what appears to be a simple predicate check.

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

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

With no output schema and no annotations, the description should clarify return semantics and edge cases. It does not state what the tool returns, how null maxRetentionMs behaves, or how accessType is interpreted, leaving an agent without enough information to invoke and use the tool correctly.

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

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

The schema already documents accessedAt and maxRetentionMs, but accessType has only an enum with no explanation and the description adds no meaning. The relationship between accessedAt, maxRetentionMs, and current time is not stated, so the agent cannot infer how the parameters combine to produce a result.

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

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

Description states a specific verb ('Check') and resource ('data retention expired based on TTL policy'), which conveys a predicate about retention. It does not explicitly distinguish from sibling 'check_*' tools, but the TTL/retention domain is clear enough to broadly identify the tool's intent.

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 such as check_purpose_permitted, is_evidence_fresh, or compare_timestamps. The description implies a time-based check but gives no context, prerequisites, exclusions, or conditions that would help an agent route to 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?

No annotations are provided, so the description carries full burden. It discloses the return behavior ('Returns null if permitted, or escalation details if tier is insufficient') but does not mention side effects, authorization requirements, or error behavior. This is more transparent than a bare mutation description but still leaves key behaviors unstated.

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, information-dense sentence that front-loads the action and quickly states the output. No filler or redundant phrases.

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 six parameters and no output schema. The description explains the core logic and return value abstractly ('null if permitted, or escalation details'). It does not clarify how tier levels map to autonomy/spend or what escalation details contain, but for a focused check tool it is reasonably 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 100%, with each parameter having its own description. The tool description reinforces the role of requestedAutonomy and requestedSpend but adds no new parameter-level detail beyond what the schema already provides.

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

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

Description states the specific verb+resource: 'Check if an agent's earned tier permits an action at a given autonomy level and spend amount.' It clearly distinguishes this tool from sibling permission-check tools by naming the tier-checking purpose and the two key inputs.

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 intended use is clear from the description (checking tier permissions), but there is no explicit guidance on when to use this versus alternative checks like check_purpose_permitted or check_usage_permitted. Exclusion criteria are not stated.

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

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

With no annotations, the description carries the full burden of behavioral disclosure. It states the check action but does not mention return format (e.g., boolean), error handling for invalid block JSON, or whether the operation has side effects. The word 'check' implies read-only, but this is not made explicit.

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

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

The description is a single, front-loaded sentence with no extraneous words. It delivers the core purpose efficiently, making it easy to parse and act upon.

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 required parameters and no output schema, so the description should clarify the return value and any prerequisites. It only states the core function, leaving the agent to infer return semantics and error behavior, which is insufficient for effective tool 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?

The schema already provides descriptions for 'block' and an enum for 'usage', but coverage is only 50%. The description adds little beyond restating that a usage type is checked; it does not explain how the block JSON should be structured or what the usage values mean. It fails to compensate for the partial schema coverage.

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

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

The description clearly states a specific action ('check') and resource ('usage type permitted under a governance block's terms'). It distinguishes itself from sibling tools like check_purpose_permitted by focusing on usage type rather than purpose, and from other check_ tools by naming governance block terms.

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 purpose implies when to use this tool (to verify a usage type under a governance block), but it does not provide explicit guidance on alternative tools or exclusions. The description does not compare with siblings like check_combination_permitted or check_purpose_permitted, leaving the agent to infer the appropriate context.

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

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

With no annotations, the description must disclose side effects and behavior. It only states the classification output; it does not mention whether the operation is read-only, how missing booleans affect grading, or what 'infrastructure' checks are performed, leaving significant behavioral ambiguity.

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

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

A single sentence with no filler; it succinctly conveys the action, classification labels, and output range.

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 includes the return grade and category labels, but lacks usage context, parameter semantics, and behavioral caveats. While the tool is moderately complex (nested evidence object, four parameters, no output schema), the description provides only a minimal functional definition.

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 explain how method, evidence, has_issuer_signature, and has_principal_binding map to the quality categories or grade. Schema coverage is only 50%, so the description should compensate but does not clarify the boolean parameters' roles.

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 specifies the verb 'classify' and the resource 'attestation evidence quality', enumerates four quality categories, and states the output grade (0-3). This makes the tool's purpose explicit and distinct from sibling tools like review_evidence or get_passport_grade.

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

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

No guidance is provided about when to use this tool over alternatives such as review_evidence or get_passport_grade, nor are any exclusions or prerequisites mentioned. The intended use is only implied by the tool's clear 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?

With no annotations, the description carries the full burden. It clearly discloses that the tool no longer executes and returns a deprecation notice. It could add a bit more about the notice's format or that input parameters are ignored, but the core behavioral change is transparently stated.

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

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

Two sentences, front-loaded with the deprecation status, and every clause adds value. No 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?

For a deprecated stub tool with no output schema, the description fully covers what the tool does, why, and what to use instead. It even points to the gateway endpoint via the deprecation notice, making the context 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 100%, so the schema already documents all 5 parameters. The description adds no parameter-specific meaning beyond noting that the tool is deprecated, so a baseline 3 is appropriate.

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

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

Purpose is explicit: the tool is deprecated and now returns a machine-readable deprecation notice instead of running the preflight pipeline. It clearly states the resource (commerce preflight orchestration) and the new behavior, distinguishing it from the actual preflight functionality now living in the gateway.

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 tells the agent when not to use this tool ('no longer runs the pipeline locally') and provides concrete alternatives: 'Compose the pure gate predicates from the SDK yourself, or call the gateway.' This is perfect usage guidance.

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

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

No annotations are provided, so the description must disclose behavioral traits. It only says 'determine ordering' but does not specify the return format (e.g., boolean, integer, enum), side effects, or error behavior. This is a significant gap for a read-only comparison tool.

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

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

The description is a single sentence with no wasted words, making it highly concise and easy to parse.

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

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

The tool has nested object parameters and no output schema or annotations, yet the description explains neither the comparison algorithm nor the return value. This is severely under-specified for an agent to invoke and correctly interpret the result.

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

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

The schema has 0% description coverage, and the description only labels the parameters as 'two hybrid timestamps'. It does not explain the meaning of the nested fields (logicalTime, wallClockEarliest, wallClockLatest, gatewayId) or how they influence the comparison.

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 (compare) and the resource (two hybrid timestamps) and the purpose (determine ordering). It distinguishes from sibling tools such as create_hybrid_timestamp.

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 information is provided about when to use this tool versus alternatives. There is no context, prerequisites, or exclusions, leaving the agent without guidance on selecting 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?

No annotations are provided, so the description carries the full burden of behavioral disclosure. It mentions the action 'complete' implies a mutation but does not explain permissions, side effects, reversibility, failure modes, or the structure of the proof chain. The deprecation note is useful context but does not compensate for the missing behavioral transparency.

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

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

The description is a single, tightly scoped sentence with the deprecation notice front-loaded. Every element earns its place, and there is no redundant or filler 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?

With no output schema, the description indicates the return concept ('full 3-signature proof chain') but does not detail its shape or behavior. The parameters are well-covered by the schema, and the deprecation guidance is complete, but for a state-changing tool, the absence of side-effect and permission context leaves some 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 100%, so the baseline is 3. The description adds no parameter-specific meaning beyond what the schema already provides (e.g., intent_id provenance, status enum, summary). It does not enhance or clarify parameter semantics further.

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 ('complete') and identifies the resource ('a permitted action') plus the key output ('full 3-signature proof chain'). It is clear about the core function, though it does not explicitly differentiate itself from the sibling tool 'complete_task' beyond the proof-chain detail.

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 marks the tool as deprecated and provides a direct alternative ('use gateway.aeoess.com REST API'). This gives unambiguous when-not-to-use guidance and names a replacement, exceeding typical usage guidance.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. It indicates a finalizing/mutating operation but does not disclose whether the action is irreversible, whether operator permissions are required, or what happens to the task unit after closure. The '[OPERATOR]' prefix hints at privileged use but is not explained.

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

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

The description is a single, front-loaded sentence that conveys the core action without any wasted words. The '[OPERATOR]' prefix provides useful context about the tool's intended audience without adding bulk.

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 consequential close/finalize operation with no annotations and no output schema, the description is under-specified. It does not explain whether the retrospective is required (schema shows it is not), whether closure can be reversed, what the resulting state is, or any side effects. The schema covers parameters but not the behavioral context needed for an AI agent to safely invoke this tool.

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

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

Schema coverage is 100%, and the parameter descriptions already define 'Final status' and 'What went well, what didn't'. The description's mention of 'final status and retrospective' adds no new semantic meaning beyond what the schema provides, so the baseline score of 3 applies.

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

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

The description uses a specific verb 'Close' with a clear resource 'task unit' and specifies the action includes final status and retrospective. This clearly distinguishes it from sibling tools like complete_action by focusing on task-level closure rather than general action completion.

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

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

The description implies the tool is used when closing a task unit, but it provides no explicit guidance on when to use it versus alternatives, nor does it mention exclusions or prerequisites. The sibling complete_action could be confused with this, and no differentiation is provided.

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

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

With no annotations, the description carries the behavioral burden and does disclose determinism, timestamp normalization, and the equality property. However, it omits important canonicalization details (e.g., whether scope_required is order-sensitive) and says nothing about side effects or the returned representation.

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 tight sentences front-load the core algorithm and then state the key semantic guarantee. There is no filler or repetition of schema content.

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

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

There is no output schema and no annotations, yet the description never states what the tool returns (e.g., a hex digest string) or how the action_ref is represented. It also leaves canonical serialization unspecified, which is critical for a deterministic identity function.

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?

Despite only 25% schema coverage, the description maps all four parameters into the hash inputs (agentId, actionType, scope, normalized timestamp) and the schema adds timestamp format rules. The camelCase 'agentId' mismatch with schema 'agent_id' is minor but could briefly 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?

States a specific operation (compute a content-addressed request identity) and gives the exact hashing inputs, which clearly distinguishes it from the numerous sibling compute/attestation tools. The equivalence sentence further pins down what an action_ref means.

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

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

The description implies the tool is used to compare or correlate receipts ('two receipts with the same action_ref describe the same request'), but it never states explicit when-to-use or when-not-to-use conditions, nor names alternatives. Usage guidance is left for the agent to infer.

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

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

With no annotations, the description carries full responsibility for behavioral disclosure. It does not state whether the operation is read-only, whether it requires specific permissions, how it handles missing derivation chains, or what the output format is. This leaves significant ambiguity for a compute 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, front-loaded sentence with no wasted words. It directly communicates the core 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?

The description is minimal for a tool with no annotations and no output schema. It does not mention the return value, possible error cases, or any prerequisites (e.g., must have lineage resolved). Given the likely complexity of a governance taint calculation, this is incomplete.

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

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

Schema description coverage is 50% (revokedSources is described, artifactId is not). The description adds the concept of 'derivation chain' and implies artifactId identifies the artifact, but it does not fully compensate for the missing schema description on artifactId or clarify how the inputs interact beyond a general statement.

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

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

The description clearly states the tool computes a governance taint level, using specific input concepts (derivation chain, revoked sources). This distinguishes it from sibling tools like evaluate_revocation_impact, which focuses on broader impact rather than a computed taint score.

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

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

The description implies the tool is used when a taint level is needed, but provides no explicit guidance on when to use it over alternatives or any exclusions. There is no mention of scenarios where another tool would be more appropriate, such as evaluate_revocation_impact or resolve_lineage.

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

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

With no annotations provided, the description carries the full burden. It explains the receipt captures terms and revocation policy, but does not disclose side effects, how the private key is used or handled, whether data is persisted, or what the output looks like. Some context is added, but critical behavioral details are missing.

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 ('Create a signed access receipt') followed by a clarifying detail. Every word contributes to understanding the tool's purpose; no filler or redundancy.

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

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

This tool has 5 required parameters, no annotations, and no output schema. The description does not explain the return value, prerequisites, or any security considerations around submitting a private key. For a cryptographic operation with a private key input, the description is insufficiently 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 100%, so all parameters are well-defined in the schema. The description adds minimal extra meaning, only hinting that 'terms and revocation policy' relate to the block parameter. This aligns with the baseline of 3 for high schema coverage.

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

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

The description clearly states the tool's purpose: 'Create a signed access receipt — cryptographic proof that your agent consumed content under specific terms.' It uses a specific verb and resource, and distinguishes itself from sibling receipt tools by emphasizing 'access' and 'revocation policy at access time.'

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

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

The description implies the use case (proof of content consumption under terms) but does not explicitly state when to use this tool over similar ones like create_derivation_receipt or aps_create_attribution_receipt. No alternatives or exclusions are mentioned.

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

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

With no annotations, the description carries the burden. It discloses key behavioral traits: immutability, freezing at access time, and anti-rug-pull permanence. However, it omits important details like whether it overwrites, required permissions, or what happens to existing snapshots.

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, direct and front-loaded. 'Anti-rug-pull' is informal but adds semantic value regarding permanence. Minor fluff, but overall 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?

The description is too sparse for a tool with 7 parameters, no output schema, and complex governance semantics. It does not explain return values, prerequisites, edge cases, or how this relates to the many sibling create_* tools. Significant gaps remain.

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 there are 7 parameters. The description loosely alludes to 'terms, jurisdiction, and constraints', which maps to termsVersion, sourceJurisdiction, and allowedPurposes, but provides no explicit meaning for accessReceiptId, sourceId, compensationRate, or currency. This is minimal compensation 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 identifies the action ('Create') and the resource ('immutable access snapshot'), and elaborates on what it does: freezes terms, jurisdiction, and constraints. It is distinct enough from most siblings, though ambiguity remains with similar create_* tools like create_access_receipt.

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

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

No guidance is provided on when to use this tool versus alternatives. The description implies a use case (recording access terms) but does not state prerequisites, exclusions, or compare with related tools such as create_access_receipt.

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

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

With no annotations provided, the description carries the full transparency burden. It discloses a key behavioral trait—automatic routing through the 3-signature policy chain—but does not mention auth requirements, return values, reversibility, or the global scope implied by 'every action.'

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

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

The description is one compact sentence with the critical deprecation notice front-loaded. It contains no filler and earns its place by conveying purpose and the most important usage caveat.

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 five parameters, no output schema, and no annotations, yet the description only covers purpose and one behavioral trait. It omits what the caller should expect in return, whether creation activates the context immediately, and any side-effect warnings needed for a creation 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 100%, so the structured data already documents all five parameters, including defaults and enums. The description adds no parameter-specific guidance, keeping this at the baseline.

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

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

The description clearly states the verb+resource: 'Create an enforcement context' and adds a specific behavioral qualifier—'automatically runs every action through the 3-signature policy chain'—which distinguishes it from generic create tools like create_policy_context.

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

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

The description explicitly marks the tool as deprecated and directs users to an alternative: 'use gateway.aeoess.com REST API.' This provides a clear when-not-to-use signal and names a specific replacement, satisfying the highest usage-guideline bar.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It only states the action ('create a request') and mentions 'multi-party,' but does not disclose side effects, permission requirements, whether the request persists, how approvals are collected, or what the response contains. This is minimal for a state-changing 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, front-loaded sentence that communicates the core purpose efficiently. The use of 'etc.' is slightly vague but does not add unnecessary bulk; the structure is clear and easy to scan.

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 creation tool with 5 parameters (4 required), no output schema, and no annotations, yet the description provides only a high-level purpose. It does not explain expected return values, required fields beyond examples, failure modes, or the multi-party approval workflow. The description is inadequate for safe and 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 only 20% (only 'subject' has a description), so the description must compensate. It adds some context by mapping subject_type examples ('charter amendments, office transfers') but fails to explain policy_id, requested_by, or timeout_seconds semantics. The agent is left guessing what these fields mean and how they relate to the request.

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

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

The description uses a specific verb ('Create') and resource ('multi-party approval request'), clearly distinguishing it from sibling tools like add_approval_signature or request_human_approval. It also provides concrete examples ('charter amendments, office transfers, etc.') that reinforce what the tool is for.

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 examples of subject types but provides no guidance on when to use this tool versus alternatives such as add_approval_signature or request_human_approval. There is no mention of prerequisites, exclusions, or context that would help an agent choose between approval-related tools.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It mentions hashing content and recording risk class and authoring agent, but does not explain side effects, persistence, reversibility, permissions, or any other behavioral traits. The schema's note that content is not stored is not reflected in the description.

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

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

The description is a single, concise, front-loaded sentence that states the tool's purpose without extraneous words. It is appropriately sized for the high-level information it conveys.

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 8 parameters, 6 required, no output schema, and no annotations. The one-sentence description is far too thin to give an agent adequate context for required fields, expected behavior, or return values. It is inadequate for a tool of this complexity.

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

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

Schema description coverage is only 25% (2 of 8 parameters have descriptions). The description mentions content hash, risk class, and authoring agent, but the latter is not a schema parameter, and the remaining required fields (delegation_ref, intended_use, artifact_type, valid_until) are left unexplained. The description adds minimal value beyond the sparse 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 tags an agent-generated artifact with provenance metadata, using the specific verb 'Tag' and a clear resource. It lists metadata types (content hash, risk class, authoring agent), but does not explicitly contrast with sibling tools like create_derivation_receipt or aps_create_attribution_receipt, so it lacks explicit 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 no guidance about when to use this tool versus alternatives, no prerequisites, and no exclusions. An agent receives no context for selecting it among the many provenance-related sibling tools.

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