PHION Agent Trust Infrastructure

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

Annotations already cover read-only, idempotent, and non-destructive behavior, and the description adds genuinely useful context beyond those: the 0.004 USDC cost, determinism, evidence-boundedness, and signed output. It does not detail what the fee pays for or how the 'evidence-bounded' guarantee manifests, but it complements the annotation profile rather than merely repeating it.

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 short fragments each carry distinct information: the core action, the cost, and the tool's guarantees. The description is front-loaded and every phrase earns its place, though the mixed semicolon/period punctuation is slightly awkward.

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 an open input schema and several close siblings, the description leaves meaningful gaps: what '0.004 USDC' refers to (fee vs bound amount), what the required input properties are, what 'evidence-bounded' means operationally, and when to prefer this over mcp_a2a_task_bridge. The existence of an output schema covers return values, but the input and selection contract 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?

With zero named parameters, the schema provides no constraints, and a 0-param baseline of 4 would normally apply. But the schema is an open object with minProperties 1, so the agent must guess which properties to supply. The description hints at relevant entities (A2A task, transaction, USDC, authority) but never maps them to concrete input fields, leaving the input contract underspecified.

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

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

The description states a specific verb and resource ('Bind an A2A task to a transaction') plus a key constraint ('without silently transferring authority'), which gives the agent a clear action and a distinguishing negative. It does not, however, explain the 'A2A' jargon or differentiate itself from the close sibling mcp_a2a_task_bridge, so it falls just 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 phrase 'without silently transferring authority' implies a usage condition: use this when you want to associate a task with a transaction but not hand over authority. However, the description never names alternatives or states when not to use the tool, and the sibling list contains several overlapping bridges (mcp_a2a_task_bridge, ap2_mandate_bridge) that are left unaddressed.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true, destructiveHint=false, and openWorldHint=false, covering the safety profile. The description adds two behavioral facts beyond annotations: the conservative gating logic (stale success plus multiple independent failed probes) and a per-call cost of 0.003 USDC. It lacks details on auth, rate limits, or what happens when conditions are not met.

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 semicolon-joined sentence with no wasted words, but it front-loads the condition rather than the action. Its terse, under-specified style leaves important gaps, so it is concise but not optimally structured for an agent.

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 detector that takes a nested policy object, has no output schema, and has 0% schema description coverage, the description omits what the policy object contains, what the output looks like, and how the classification is returned. It provides only cost and a high-level condition, which is insufficient for confident 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 there are two required nested parameters. The description partially maps conditions to the 'tool' object's fields ('stale success' → last_success_at, 'multiple independent failed probes' → independent_probe_count/reachable), but it says nothing about the required 'policy' object, leaving half the parameters undocumented.

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 indicates the tool classifies likely abandonment but does so indirectly through a condition ('Require stale success plus multiple independent failed probes before classifying...') rather than a direct verb like 'detects' or 'classifies'. It does not differentiate from siblings such as tool_capability_drift_monitor. The pricing detail ('0.003 USDC') is not purpose-related.

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

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

No explicit when-to-use or when-not-to-use guidance is given. The conditional phrasing describes internal logic, not invocation context, and no alternative tools are named. The agent must infer that this is for abandonment classification.

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

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

The description adds useful behavior beyond the annotations: the result is deterministic and signed, and it operates only over the supplied input. It does not contradict the readOnly/idempotent hints, though it omits details about signature format, validation, or error behavior.

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

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

The description is extremely short, but it begins by repeating the tool name and title. The remaining phrase adds some value, but the entry is under-specified rather than efficiently informative.

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

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

Despite simple schema and safe annotations, the tool cannot be invoked confidently because the meaning of 'approval' and the expected input shape are never explained. An agent would not know whether to pass a boolean, an object, or some other 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 high, so the baseline is 3; the description does not need to re-list parameter details. That said, the required 'approval' parameter is completely opaque, and the description's 'supplied input' does not clarify what form the approval should take.

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

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

The description says it produces a 'deterministic signed assessment over supplied input,' which identifies a specific kind of output and a clear scope. However, it is vague about what 'approval relay' actually does and does not distinguish it from related tools like attest, verify, or signed_result_comparator.

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

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

There is no guidance about when to use this tool versus any of its many siblings. The description neither states the intended use case nor names alternatives, so an agent cannot decide when this is the right choice.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true, destructiveHint=false, so the safety profile is covered. The description adds valuable behavioral context: it does not retain payloads or raw identifiers, is deterministic, evidence-bounded, and signed, and includes a cost (0.003 USDC). This goes beyond annotations and helps an agent understand side effects and guarantees.

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

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

The description is two sentences with no waste. It front-loads the core purpose, then adds the cost and key properties. Every clause 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 open schema, no required parameters, and rich annotations, the description is fairly complete. It explains the behavioral commitment, privacy properties, cost, and signing. It doesn't describe the output schema, but an output schema exists, so that's not required. A small gap is the lack of explicit guidance on what inputs are needed, but the open schema makes that less critical.

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 is open (additionalProperties: true, minProperties: 1) with no named parameters, so schema coverage is effectively 100% but provides no semantic detail. The description compensates by explaining the purpose and constraints (privacy-minimized, no raw identifiers, deterministic, evidence-bounded, signed), which gives an agent enough context to know what kind of input is expected. However, it doesn't specify exact required fields, so a 4 is appropriate rather than 5.

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 ('Create') and a clear resource ('a privacy-minimized behavioral commitment'), and distinguishes it from siblings by emphasizing privacy-minimization and evidence-boundedness. It doesn't explicitly name a sibling alternative, but the phrase 'without retaining payloads or raw identifiers' clarifies its unique scope among the many evidence/receipt tools.

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

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

The description implies when to use it: when a privacy-minimized, deterministic, signed behavioral commitment is needed. It does not explicitly state when not to use it or name alternatives, but the context of sibling tools (e.g., agent_reputation_evidence, attest) suggests a niche. The guidance is implied rather than explicit.

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

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

With no annotations, the description carries the full behavioral burden. It discloses the cost (0.002 USDC) and budget scopes, but says nothing about what happens when a budget is exceeded, whether the operation blocks or logs, required permissions, idempotency, or side effects.

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

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

The single sentence is front-loaded with the core action and scope, with zero wasted words. It is appropriately sized but extremely terse, bordering on under-specification rather than being structurally deficient.

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

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

Despite having an output schema, the definition is incomplete for a guard tool with no annotations: it omits critical when-to-use context, behavioral outcomes on enforcement, and any differentiation from siblings. An agent has enough to know the broad purpose but not enough to call it correctly in context.

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

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

Schema description coverage is reported at 100%, so the structured schema is expected to document parameters, setting the baseline at 3. The description adds no mapping or meaning for the required request, usage, and policy parameters beyond the general budget categories already implied.

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 ('Enforce') and resource ('budgets'), and enumerates per-call, task, session and period scopes, making the core purpose clear. However, it does not differentiate itself from similar sibling guards like subscription_spend_guard or mandate_reserve, so it falls short of a 5.

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

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

There is no explicit guidance on when to use this tool versus alternatives, nor any stated exclusions or prerequisites. The budget enforcement context implies a use case, but an agent must infer when to call it relative to the many other guard and payment tools.

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

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

Annotations already provide readOnly, idempotent, and non-destructive hints. The description adds meaningful behavioral context beyond those: a fixed fee of 0.005 USDC, determinism, evidence-boundedness, signing, and the restriction to only supplied data. No contradiction with annotations is present.

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

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

The description is brief and front-loaded with the primary purpose alert. The three clauses each add distinct information: what it builds, what it costs, and how it behaves. The punctuation/format is slightly awkward, but there is no wasted text.

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

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

For a tool with no defined schema parameters, an output schema, and rich annotations, the description covers the essential expectations: construction, privacy boundaries, cost, determinism, evidence, and signing. It lacks usage-direction details, but those belong to the usage dimension. Overall, an agent likely has enough to invoke it correctly.

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

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

The schema has no explicit parameters, so the 0-param baseline of 4 applies. The description compensates somewhat by indicating the input should consist of supplied nodes and edges, even though it does not define exact property names. Since the schema itself is an open object, the description adds at least directional 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 names a specific verb ('Build') and resource ('privacy-bounded economic relationships') and constrains scope to 'supplied nodes and edges'. It is distinct from more generic graph or relationship tools, though it does not explicitly name sibling alternatives. The added attributes 'Deterministic, evidence-bounded and signed' further clarify the output's nature.

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

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

There is no explicit guidance on when to use this tool versus alternatives. The phrase 'only from supplied nodes and edges' implies a privacy/scope constraint but does not state conditions, exclusions, or which sibling tools are more appropriate in other scenarios. An agent would have to infer usage context.

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

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

Annotations already declare readOnly, idempotent, and non-destructive behavior, so the safety profile is covered. The description adds 'deterministic signed,' which hints at a reproducibility and output-signing property, but it does not clarify what 'signed' means here or what side effects, if any, the assessment has on the supplied input.

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

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

The description is short and front-loaded, with no wasted phrasing. However, it is terse to the point of under-specification, leaving important semantic and selection information absent.

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 large, semantically overlapping sibling list and unnamed required parameters, the description is incomplete for reliable tool selection and invocation. The presence of an output schema helps, but the description still fails to convey the intended use case, input semantics, or differentiation criteria.

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 required parameters 'memory' and 'source' are given no semantic explanation in either the schema or the description. The phrase 'supplied input' is generic and does not clarify which parameter maps to which concept, so an agent cannot confidently determine what values to provide.

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

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

The description says the tool produces a 'deterministic signed assessment over supplied input,' which conveys the basic operation and resource. However, it does not explain what 'agent memory provenance' means, what question is being answered, or how this differs from many similarly named provenance/attestation 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?

There is no guidance about when to use this tool versus alternatives. The sibling list contains numerous provenance, evidence, and attestation tools, but the description provides no conditions, prerequisites, or exclusions to help an agent choose among them.

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

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

Annotations already provide rich safety context: readOnlyHint=true, idempotentHint=true, destructiveHint=false. The description adds only 'deterministic' (which overlaps with idempotentHint) and 'signed,' which is undefined. There is no contradiction with annotations, but the added behavioral insight is minimal.

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

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

The description is short, but brevity here is under-specification rather than useful compression. It repeats the tool name and adds a vague clause without front-loading any concrete, actionable 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?

With two required opaque parameters, no property definitions, and no explanation of the negotiation semantics, the description is insufficient for confident invocation. The output schema exists, but it does not compensate for missing input semantics and absent usage context.

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

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

The schema requires 'demand' and 'offer' but provides no property definitions, and the description's phrase 'supplied input' adds no meaning to either parameter. An agent is left to guess what shape demand and offer should take, what they represent, and whether additional properties are meaningful.

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 moves slightly beyond a pure tautology by saying the tool produces a 'deterministic signed assessment over supplied input,' but it never states a concrete verb or resource. It does not clarify whether the tool negotiates rate limits, assesses a demand/offer pair, or returns a signed verdict, and it does not distinguish it from sibling negotiation or assessment 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?

There is no guidance about when to use this tool versus alternatives such as capability_negotiation_preflight or agent_budget_guard. No conditions, exclusions, or examples are given; the only implied use case comes from the tool name itself, not the description.

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 it does disclose two useful behavioral traits: the assessment is bounded by supplied evidence, and the call costs 0.005 USDC (a paid operation). It does not disclose what happens when evidence is insufficient, what the signed receipt guarantees, or any permission/latency characteristics.

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

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

A single dense sentence with no filler, and the core purpose plus the output contents and price are front-loaded. It is appropriately sized for the amount of information offered, though it packs the price tag on with a semicolon in a slightly awkward way.

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

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

An output schema exists, so return values need not be described, but for a tool with three parameters, nested objects, and 0% schema coverage the definition is materially incomplete. It gives no indication of what must go into 'subject' or what qualifies as valid 'evidence', which an agent needs in order to call it correctly.

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

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

Schema description coverage is 0% for three parameters including two nested objects, so the description must compensate but does not. It never mentions 'subject', 'signals', or 'evidence' directly, leaving the agent to infer the shape of the required subject object and the maxItems=32 evidence array from the raw schema alone.

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

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

The description names a specific operation (evidence-bounded reputation assessment) on a specific resource (an agent subject), and lists what the result contains (confidence, coverage, provenance limitations, signed receipt). It is clearly distinguishable from generic siblings like verify or attest, though it never names a sibling to differentiate against.

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

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

There is no explicit when-to-use or when-not-to-use guidance and no alternative tool is named. The phrase 'evidence-bounded' weakly implies evidence must be supplied, but nothing tells the agent which of the many sibling preflight/verify/screening tools to prefer in a given situation.

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

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

Annotations already cover readOnlyHint, idempotentHint, and destructiveHint. The description adds 'deterministic' and 'signed,' which are genuine behavioral details beyond the annotations, but it does not describe failure modes, input constraints, or what the signed assessment is used for. No contradiction with annotations.

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

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

The description is admirably short and front-loads the core idea, but it is terse to the point of underspecification. The opening phrase repeats the tool title and the remaining clause is generic, so while there is no filler, the brevity sacrifices necessary context.

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 output schema and annotations cover the return and safety profile, but the description does not explain what session continuity means, what inputs should contain, or when this assessment is needed. Given the required previous/current inputs and a large sibling set, the description is not complete enough for reliable tool selection or 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?

The schema lists required fields 'previous' and 'current' without property descriptions, and the description only refers to 'supplied input,' adding no meaning to these fields. Although context reports high schema coverage and zero formal parameters, an agent still has to infer what 'previous' and 'current' represent, and the description does not help.

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 that the tool produces a 'deterministic signed assessment over supplied input,' which gives a general action and resource, but it never explains what 'Agent Session Continuity' actually determines or how it relates to the input. The phrase is vague and does not differentiate this tool from sibling tools like signed_result_comparator or verify.

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

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

There is no guidance on when to use this tool, what preconditions exist, or when a sibling tool would be more appropriate. The description only defines the tool in isolation and provides no context 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?

No annotations, so the description carries the full behavioral burden. It discloses the cost (0.003 USDC) and that the handoff is 'bounded', which implies a scoping constraint, but says nothing about permission requirements, irreversibility, idempotency, or what happens if payment fails.

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 short sentence with no wasted words, and the action verb plus the payment cost are front-loaded. Brevity is efficient here rather than merely under-specified, though it verges on too terse.

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?

An output schema exists, so return values need not be described, but this is a payment-bearing signing operation with zero annotations and the description leaves the key operational context (payment flow, bounded scope, failure handling) unstated. For a tool with monetary and signing implications, that is a significant gap.

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

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

Schema description coverage is reported at 100%, so the structured schema is expected to document the required 'handoff' parameter. The description adds no syntax, format, or content guidance for that parameter beyond restating that a handoff is being signed, so the baseline 3 applies.

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

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

States a specific verb ('Sign') and resource ('bounded agent-task handoff'), which is enough to distinguish it from the many guard/evidence siblings. It does not, however, name any sibling or clarify how it differs from receipt-producing tools like delivery_evidence or retention_deletion_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 indication of when to call this versus alternatives, no prerequisites, no exclusions. The only usage-adjacent detail is the price, which hints the call is paid but does not say under what circumstances a handoff should be signed.

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

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

Annotations already declare readOnlyHint, idempotentHint, and destructiveHint. The description adds valuable behavioral context beyond these: a cost of 0.004 USDC, determinism, evidence-bounded behavior, and signed output. It also discloses a limitation (no unsupported AP2 production authorization). No contradiction with annotations.

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

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

The description is short but structurally awkward. The semicolon after 'authorization.' creates a fragment, and '0.004 USDC. Deterministic, evidence-bounded and signed.' are separate staccato phrases. While concise, the flow hinders readability and could confuse an agent parsing the sentence.

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

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

The tool is low-complexity with zero parameters, rich annotations, and an output schema present, so the description need not cover return values or parameter details. It provides cost, determinism, evidence-boundedness, signing, and a scope limitation, which together are reasonably complete for 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?

The tool has zero named parameters, so the baseline is 4. The schema allows additional properties with minProperties 1, but the description does not need to explain parameter semantics for a tool with no defined params.

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 ('map') and resource ('mandate fields') with a clear purpose ('for review'). The qualifier 'without advertising unsupported AP2 production authorization' clarifies scope, but it does not explicitly differentiate from siblings such as mandate_reserve or mcp_a2a_task_bridge, so it falls short of a 5.

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

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

No guidance is given about when to use this tool versus alternatives. There are no mentions of sibling tools, conditions, or exclusions. The phrase 'for review' weakly implies a review context, but that is not sufficient to guide an agent's tool selection.

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

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

With no annotations, the description carries the full burden, and it does disclose two genuine behavioral facts: this is a paid operation and the price/chain are 0.001 USDC on Base. It omits whether it is a write/side-effecting operation, whether the attestation is stored or returned, and what signing or auth is needed.

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?

It is a single front-loaded fragment with no wasted words, which is efficient. However, the brevity crosses into under-specification rather than conciseness, so the structure succeeds only as a one-line label.

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 paid, signed operation with three undocumented parameters, no annotations, and no output schema, the description is materially incomplete. An agent knows the price but not what it must pass, what it gets back, or how the result is consumed.

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

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

Schema description coverage is 0% for all three parameters (content, sources, ttl_seconds), and the description explains none of them. The required 'content' parameter and the ttl_seconds semantics (expiry of the attestation?) are left entirely undocumented.

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 the resource (signed JSON attestation) and the mechanism (x402 paid), which tells an agent what it produces, but it reads as a jargon fragment rather than a clear verb+resource statement. It does not distinguish this from siblings like verify or fetch_evidence, which plausibly operate on the same attestation concept.

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

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

There is no statement of when to use this tool versus verify, fetch_evidence, or preflight/payment_preflight. The cost mention implies a paid path exists, but the description never says to call payment_preflight first or what condition selects attestation over verification.

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

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

Annotations already signal read-only, idempotent, and non-destructive behavior; the description adds useful non-obvious traits: a deterministic output, an evidence-bounded computation, a cryptographic signature, and a 0.005 USDC cost. These go beyond the structured hints, though 'signed' is not elaborated.

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 purpose, and every phrase adds signal—scope, non-goal, cost, determinism, boundedness, and signing. The semicolon-separated fragments are slightly awkward but not bloated.

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

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

For a zero-parameter tool with an output schema and safety annotations, the description covers purpose, non-goal, cost, determinism, and signing. The main remaining gap is the unconstrained input object: minProperties 1 with additionalProperties true leaves agents guessing what at least one property should be.

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

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

There are no declared parameters and the schema only permits a free-form object with at least one property, so the baseline for this dimension is 4. The description's 'failure evidence' phrase hints at the intended payload, though it does not spell out accepted keys.

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 ('Assemble'), a concrete object ('failure evidence'), and an explicit non-goal ('without executing refunds'), so the tool's role is immediately distinguishable from sibling payment/execution tools. It also names the expected output ('recommend resolution').

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—bundling evidence and recommending a resolution after a failure—and explicitly excludes refund execution, but it names no sibling tools or conditions that should route an agent here instead of related tools like payment_diagnose or transaction_recovery. It leaves the when-to-use decision largely to inference.

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

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

Beyond the readOnly and idempotent annotations, the description discloses a 0.005 USDC cost, determinism, evidence-boundedness, and signed output. These are meaningful behavioral traits that are not present in the annotations or 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 content is dense and front-loaded: the core action, scope, cost, and key behavioral properties all appear in a short span. The punctuation is awkward ('without purchasing.; 0.005'), but every phrase earns its place.

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

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

The description covers the core behavior, cost, and output properties, while the output schema handles return-value details. It could be more explicit about what inputs are expected and what counts as an eligible provider under a mandate, but it is adequate for a zero-parameter read-only tool.

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

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

Context reports zero formal parameters and 100% schema description coverage, so the baseline of 4 applies. The description does not document the open-schema input keys, but with no defined parameters this is not a significant gap.

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

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

The description uses a specific verb ('Recommend') and a specific resource ('verified eligible provider under a mandate'), and explicitly states the tool does not purchase. This clearly separates it from payment, bridge, and mandate-execution siblings even without naming them.

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

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

The description implies usage context: when a mandate exists and a provider recommendation is needed without purchasing. However, it does not explicitly name alternatives or state when not to use this tool, leaving selection among siblings to inference.

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

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

Annotations already declare read-only, idempotent, non-destructive behavior, and the description adds meaningful context: deterministic execution, evidence-boundedness, signed results, and a specific 0.004 USDC cost. This goes beyond the annotations, though the exact meaning of 'evidence-bound' and the pricing fragment remain somewhat underspecified.

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

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

The description is short and front-loads the core purpose. However, the semicolon-separated '0.004 USDC' fragment and the staccato tag list read as disconnected metadata rather than integrated prose, which makes the structure choppy.

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

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

With zero parameters and an output schema, the essential invocation details are mostly covered: what is measured and the key guarantees. Still, the description does not explain what actually drives the benchmark, what 'signed' outputs mean, or how it relates to the many neighboring capability and verification 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?

The tool reports zero parameters and 100% schema description coverage, so there is no parameter documentation burden. The description hints at implicit benchmark cases, but since no explicit parameters exist, this is not a meaningful gap. The baseline for parameterless tools is appropriately credited.

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 ('Measure') and names concrete resources ('reproducible success, latency and cost' from 'versioned evidence-bound benchmark cases'). It is not a tautology and gives a clear sense of what the benchmark computes. However, it does not explicitly distinguish itself from siblings like capability_verification or signed_result_comparator.

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

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

No guidance is given for when to use this tool instead of alternatives. The phrase 'from versioned evidence-bound benchmark cases' implies a prerequisite, but it is not stated as a decision rule. There are no exclusions or references to sibling tools, so an agent receives little routing help.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true, and destructiveHint=false, so the safety profile is covered. The description adds 'deterministic signed assessment', which is useful behavioral context beyond the annotations, but it does not explain what signing entails, what the assessment covers, or what happens to the input. No contradiction with annotations.

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

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

The description is a single short sentence with no wasted words. It front-loads the tool name and then adds the key qualifiers 'deterministic signed assessment'. It is concise, though it could be more informative without becoming verbose.

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

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

Given the tool's moderate complexity (two required params, output schema present, many siblings), the description is too thin. It does not explain what the assessment evaluates, how 'required' and 'offered' relate to capability negotiation, or when an agent should choose this over capability_verification or preflight. The output schema exists but the description still leaves the tool's purpose ambiguous.

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 the two required parameters ('required' and 'offered'). The description adds no meaning beyond the schema; it does not explain what 'required' and 'offered' mean in the context of capability negotiation. Baseline 3 is appropriate because the schema carries the parameter documentation burden.

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 'Capability Negotiation Preflight; deterministic signed assessment over supplied input' states a specific verb-ish resource ('assessment') and mentions determinism and signing, but it does not explain what a 'capability negotiation preflight' actually does or what the assessment is about. Among siblings like capability_verification, capability_benchmark, and preflight, the description does not distinguish this tool from those alternatives.

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

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

No guidance is given on when to use this tool versus siblings such as capability_verification, capability_benchmark, or preflight. The phrase 'over supplied input' implies it takes input and produces an assessment, but there is no explicit context, exclusions, or alternative routing.

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

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

Beyond the readOnly and idempotent annotations, the description adds useful traits: deterministic, evidence-bounded, and signed, plus an explicit cost of 0.003 USDC. These are meaningful behavioral signals, though 'evidence-bounded' could be more precise.

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, with the purpose and key constraints front-loaded. Minor punctuation quirks aside, every clause adds information without unnecessary elaboration.

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

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

Despite having an output schema, the description omits crucial context: what the input object expects (the schema allows any additional properties), what 'evidence-bounded' means in practice, and whether the 0.003 USDC cost requires a transaction beforehand. The description is too abstract for agents to safely invoke.

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

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

The tool declares zero parameters, and the schema coverage is 100%, so the baseline of 4 applies. No parameter documentation is needed, and the description adds nothing that could be misread as parameter guidance.

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

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

The description states a clear goal—'separate claimed capabilities from independently evidenced successful demonstrations'—but it reads more like an outcome than a concrete tool action with a specific verb and resource. The title and sibling names hint at verification, yet the exact operational function remains ambiguous.

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

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

No guidance is given for when to use this tool versus alternatives like capability_benchmark, capability_negotiation_preflight, or tool_capability_drift_monitor. There are no use conditions, exclusions, or comparisons, leaving the routing decision to the agent.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. It does add meaningful context by disclosing a free input preflight, provider attribution, signed evidence, and a fixed price of 0.005 USDC, which helps an agent understand billing and validation behavior. However, it omits broader operational details such as authentication requirements, data source behavior, failure modes, and return structure, so it is only partially transparent.

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 dense sentence with no filler: it names the operation, key features, and cost. The information is packed tightly, though it slightly sacrifices clarity by relying on jargon like 'provider attribution' without elaboration.

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 28 parameters, nested objects, no output schema, and no annotations, the description is too thin to support correct invocation. It provides no invocation guidance, no examples, no explanation of what the signed evidence contains, and no comparison to similar enrichment tools. An agent needing to choose parameters or interpret the result would be under-informed.

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 7%, and the tool description itself adds no parameter-level meaning beyond 'company enrichment.' The schema's own description does clarify that identifier can be pdl_id, website/domain, profile, ticker, name, company, or identifier and that nested inputs are accepted, but the remaining ~26 parameters are opaque. The description does not compensate for the low coverage.

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

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

The description identifies a clear domain ('Company enrichment') and distinguishes it from sibling evidence tools such as contact_enrichment_evidence, person_enrichment_evidence, and entity_enrichment_evidence by naming the company scope. It does not state what the returned 'signed evidence' contains, which leaves some ambiguity about the tool's exact output, but the primary purpose is recognizable.

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

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

The description gives no explicit guidance on when to use this tool versus sibling alternatives like contact_enrichment_evidence or entity_enrichment_evidence. There are no exclusion criteria, no mention of alternatives, and no condition-based routing. The only implicit signal is that it is for company-related enrichment.

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

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

Annotations already declare readOnlyHint, idempotentHint, and destructiveHint=false, so the safety profile is covered. The description usefully adds the fail-closed posture, the freshness requirement on the counter, and the 0.002 USDC cost, which annotations do not convey. It stops short of saying what a denial looks like or whether the call itself performs the slot reservation.

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 dense sentence that front-loads the failure condition and appends the price. Nothing is wasted, though the compression is extreme enough to obscure the tool's core action.

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

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

For a 7-required-parameter guard with no output schema and no field descriptions, the definition is thin: it does not explain how active_slots plus requested_slots are compared against policy.maximum_slots, nor what the caller receives on pass versus fail-closed.

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% across 7 required parameters, so the description carries the full burden. It loosely hints at three parameter clusters (counter freshness → counter_observed_at, lease → lease_id/lease_valid_until, idempotency binding → idempotency_key) but leaves requested_slots, active_slots, and policy.maximum_slots unexplained, and never states the freshness window or timestamp units.

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 decision policy ('fail closed unless...') and the inputs that gate it (fresh counter, lease, idempotency binding) plus a price, so the resource is identifiable. However, it never states the tool's overall function in plain terms (e.g., admit/deny a request against a concurrency cap), and it does not distinguish itself from close siblings such as idempotency_replay_guard or resource_cycle_guard.

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

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

There is no when-to-use guidance, no prerequisites, and no named alternative. Given the dense set of guard siblings (idempotency_replay_guard, resource_cycle_guard, delegation_scope_guard), the agent has no signal for choosing this one over them.

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

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

No annotations exist, so the description carries the full burden. It does add genuinely useful behavior: an abstain path, a bounded-confidence constraint, and a concrete price of 0.003 USDC. It omits permissions/payment mechanics, what happens when candidates are irreconcilable, and the result shape.

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 dense sentence that front-loads the operation and appends the per-candidate requirements and price. No filler, though the semicolon-separated clauses make it slightly terse to parse.

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

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

For a two-parameter tool with a nested array, a nested policy object, no output schema and no annotations, the description is too thin. It never explains the policy structure, the resolution rules, or the return value, leaving an agent unable to invoke it confidently.

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

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

Schema coverage is 0% and objects are nested, so the schema explains little. The description usefully enumerates the required candidate bindings (source, value hash, observation time, bounded confidence), which covers the candidates parameter, but the required 'policy' object is left entirely opaque.

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

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

The verb pair 'Resolve or abstain' combined with the name gives a rough idea that this adjudicates conflicting candidates, and it names the shape candidates must take. But it never states the resource being resolved (conflicting values? sources?) or what resolution produces, so the purpose stays implied rather than stated.

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

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

There is no guidance on when to call this versus siblings like signed_result_comparator or verify, nor any precondition or exclusion. 'Resolve or abstain' hints at output behavior, not usage context.

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

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

With no annotations, the description carries the full burden. It does disclose useful behavioral traits: free input preflight, identity limitations, signed receipt, and the 0.007 USDC cost. But it omits whether the operation is read-only, what the signed receipt contains, and possible failure modes.

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 tight sentence, front-loading the core purpose and packing cost, preflight, and identity constraints without filler. It could be slightly better structured, but it earns its 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 28 parameters, no output schema, and no annotations, one line is insufficient. An agent cannot determine which identifier to pass, what the signed receipt looks like, or how identity limitations affect the enrichment 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?

Schema description coverage is only 7%, yet the description names no parameters and gives no guidance on the 28 inputs. It only implies the input is a business contact, which does little to clarify how to populate fields like lid, pdl_id, query, or subject.

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 'Business-contact enrichment' – a specific verb and resource – and the 'business-contact' qualifier helps distinguish it from company or person enrichment siblings. However, it does not name any sibling or explicitly state what the evidence output looks like.

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

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

No usage context or alternatives are provided. The description mentions preflight and identity limitations but never says when to use this tool over company_enrichment_evidence, person_enrichment_evidence, or entity_enrichment_evidence.

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

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

No annotations are provided, so the description carries the full behavioral burden. It usefully discloses the 0.002 USDC charge, but says nothing about what 'hash and label' produces, whether the hashed content is transmitted or retained, or whether the operation is deterministic — significant gaps for a tool that ingests arbitrary content.

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?

It is a single compact sentence with the core action front-loaded and the cost appended. Nothing is wasted, though the terse phrasing leans on jargon that would benefit from a short clarifier.

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?

An output schema exists, so return values need not be explained. However, with no annotations and no usage context for a content-ingesting, paid operation, the definition leaves the agent guessing about safety, retention, and when this tool is appropriate.

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 reported at 100%, so the schema is presumed to document 'content' and 'source' adequately, giving a baseline of 3. The description adds no meaning beyond that, such as expected content types or source format.

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 specific verbs (hash, label) and the resource (context integrity, confidentiality and source), so an agent can tell it produces a provenance/integrity artifact. It does not, however, distinguish itself from siblings in the same evidence/attestation family (e.g. dependency_provenance_assessment, attest, fetch_evidence).

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

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

There is no when-to-use guidance, no prerequisites, and no mention of alternatives among the numerous sibling guard/evidence tools. The only decision signal is the price, which tells the agent it costs money but not when it is the right tool.

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

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

With no annotations, the description carries the full burden, and it does disclose two useful traits beyond the schema: the evaluation is deterministic (same inputs yield the same verdict) and it costs 0.003 USDC. It omits whether the call is read-only, whether it requires auth or holds/reserves funds, and what happens on a failing verdict.

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

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

A single front-loaded sentence with the core capability first and the price appended. Nothing is padded, though the trailing cost fragment is slightly awkward rather than fully integrated.

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?

An output schema exists, so return values need not be explained, but the tool has four undocumented nested-object inputs and no annotations. For a deterministic policy-evaluation tool, the description leaves the agent unable to construct the required 'subject' and 'policy' payloads.

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% across four nested-object parameters, so the description must compensate and largely does not. It only hints at two of them ('reputation evidence', 'transaction limits') and says nothing about the 'policy' or 'subject' objects or the shape of any nested field.

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

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

The description names a specific resource (counterparty policy) and operation (deterministic preflight) and states what inputs drive it (reputation evidence, transaction limits). It is clear enough to distinguish from generic siblings like 'verify' or 'try_service', but it never explicitly contrasts itself with the closely related 'payment_preflight' or 'preflight' 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?

There is no statement of when to call this versus the many preflight/assurance siblings (payment_preflight, preflight, transaction_assurance). No prerequisites, ordering, or exclusions are given; the agent must infer that 'preflight' means 'call before transacting' from the name alone.

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

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

Annotations already declare read-only, idempotent, non-destructive behavior; the description adds that the result is deterministic and signed, which is a genuine extra behavioral trait. However, it does not explain the signature's role, failure modes, or assessment semantics, so the contribution is modest.

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

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

The description is short, but the opening clause is a verbatim repeat of the title and the remaining clause is too generic to carry meaningful information. This reads as under-specification rather than disciplined 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?

With a required `receipts` input, a large sibling tool set, and no prose guidance, an agent cannot reliably determine what to pass or when to select this tool. The output schema and annotations cover some safety/return expectations, but the core invocation and routing questions are entirely unanswered.

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 names a required `receipts` field but provides no property description, and the phrase 'supplied input' is a placeholder that adds no meaning. The 100% schema-description coverage does not help because the schema itself contains no real parameter 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 first clause simply restates the tool's title. 'Deterministic signed assessment over supplied input' names a generic action but not what the tool actually bundles, assesses, or returns, and it does not distinguish this from the many sibling receipt/bundle/evidence 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 given for when to use this tool versus alternatives such as agent_task_handoff_receipt, cross_protocol_receipt, or multi_source_fact_bundle. There are no conditions, prerequisites, or exclusion criteria.

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

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

Annotations already declare readOnlyHint, idempotentHint, and destructiveHint. The description adds meaningful behavioral context beyond those hints: 'Deterministic, evidence-bounded and signed' plus the explicit cost of '0.004 USDC'. This enriches the agent's understanding of side effects and execution guarantees without contradicting annotations.

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

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

The description is very short and front-loaded with the core function. The cost and property descriptors add value without padding. The semicolon/dangling '0.004 USDC' fragment is slightly awkward structurally, but overall the text is efficiently writed.

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

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

Despite good annotations and an output schema, the description is too thin for a tool with an open input schema (minProperties 1, additionalProperties true). It does not explain what transaction commitments should be supplied, what 'consistent' means in practice, how protocols are identified, or how the bundling is requested. An agent has little concrete guidance for constructing a valid 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?

The schema declares no named parameters (0 params, 100% schema description coverage), so the baseline is 4. The description does not need to explain parameter meaning because there are no explicit parameters to document; however, it also does not clarify what should go into the allowed arbitrary object, which is a minor gap.

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

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

The description uses a specific verb ('Bundle') and resource ('consistent transaction commitments across multiple protocols'), clearly conveying the core function. It is not a tautology and the cross-protocol qualifier distinguishes it from generic receipt tools, though it does not explicitly name a sibling alternative.

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

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

There is no guidance on when to use this tool versus alternatives such as cross_agent_receipt_bundle or automated_dispute_bundle. No prerequisites, exclusions, or selection criteria are provided; usage must be inferred entirely from the purpose statement.

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

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

No annotations exist, so the description carries the full behavioral burden. It does disclose a genuinely useful trait beyond the schema: a per-call cost of 0.002 USDC. But it omits whether inspection is advisory or blocking, what the policy argument changes, and any auth or rate-limit behavior for a paid gate.

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

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

A single front-loaded clause with no filler; the scope and cost are stated compactly. It is efficient, though the extreme brevity is part of why the behavioral and parameter gaps exist.

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?

An output schema exists so return values need not be explained, but for a paid, complex-input preflight with zero annotation coverage and 0% parameter documentation, the description leaves key questions unanswered (blocking vs advisory, policy semantics, payload format). It is too thin for the tool's complexity.

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

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

Schema description coverage is 0% across three parameters, including two required nested/opaque objects. The description conceptually names 'data' and 'destination' (mapping loosely to payload and destination) but says nothing about the optional 'policy' object, what shape payload/destination take, or what policy controls.

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 gives a specific verb ('Inspect') with its resources ('outbound agent data and destination') and timing scope ('before transmission'), which is enough to distinguish it from payment-oriented siblings like payment_preflight. It stops short of explicitly naming which sibling to use instead, so it falls just below full sibling 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?

'Before transmission' implies the usage context, so an agent can infer this is a pre-send gate. However, with numerous preflight/guard siblings (counterparty_risk_preflight, tool_call_policy_guard, transaction_assurance), no guidance is given on when this is the correct gate versus the others, and no exclusions are 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 behavioral burden. It usefully discloses a hard prerequisite (the binding requirement) and the cost (0.002 USDC), and the phrase 'only when' implies refusal otherwise. But it says nothing about failure behavior, what the certificate contains, or how the maximum_age_seconds policy is enforced.

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 dense sentence that front-loads the core verb and constraints, with cost at the end. No wasted words, though the compression leaves semantic gaps that a slightly longer definition could close.

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 nested required schemas, zero parameter descriptions, no annotations, and no output schema, the single sentence is not sufficient. It omits the policy semantics, the certificate's contents, and the failure/return behavior an agent needs to call this correctly.

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

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

Schema description coverage is 0% and both parameters are nested required objects. The description maps three data subfields (observed_at, source_uri, content_sha256) to their intent and adds the '64-hex' format detail, which is genuinely beyond the schema. But the entire policy object, including the central maximum_age_seconds threshold, is left unexplained.

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 verb (Certify) and resource (freshness) with the exact binding conditions required to issue the certification. It is clearly distinguishable from generic siblings like attest or verify by the freshness/URI/hash semantics, though it does not explicitly name a sibling it is not. Purpose is clear but sibling differentiation is left implicit.

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 states a precondition (only when timestamp is bound to source URI and a 64-hex content hash), which is a form of when-to-use guidance. However, it does not explain when to prefer this over nearby tools like attest, verify, or service_sla_attestation, nor any exclusions. Usage is implied rather than routed.

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

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

Annotations already disclose read-only, idempotent, and non-destructive behavior. The description adds that the result is deterministic and signed, which is useful but minimal; it does not explain what input is accepted, what the assessment contains, or whether any external state is involved.

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

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

The description is short and wastes few words, and the key functional hint 'deterministic signed assessment' is front-loaded. However, the leading phrase 'Delegated Credential Guard' simply duplicates the tool name and adds no 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?

Despite having an output schema and annotations, the description leaves the tool's core semantics undefined: what a delegated credential assessment is, what inputs are expected, what output shape or meaning results, and when an agent should prefer it over similar guards. This is too sparse for safe autonomous 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?

The schema names two required inputs, `credential` and `action`, but provides no property definitions or descriptions. The description does nothing to clarify what format these should take, what 'action' means, or how they relate to the assessment, so an agent cannot reliably construct a valid call.

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 merely pairs the tool name with a generic phrase, 'deterministic signed assessment over supplied input,' without stating what kind of credential or action is assessed, what the guard actually does, or what makes it different from the many sibling guard/assessment tools. It restates the title and adds only vague functional language.

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

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

There is no guidance on when to use this tool, when not to use it, or which sibling tools are alternatives. The description gives an agent no contextual signal to distinguish delegated_credential_guard from delegated_spend_policy, delegation_scope_guard, or attest.

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

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

Annotations already establish readOnly, idempotent, and non-destructive behavior, and the description adds meaningful context: fail-closed semantics, deterministic results, evidence-bounded output, and signed results, plus an apparent 0.003 USDC cost. This goes beyond the structured fields without contradicting them.

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

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

The text is short and front-loaded with the core failure behavior, but the remaining clauses are sentence fragments; '0.003 USDC' is ambiguous between a cost and a threshold, and the list grammar is slightly off. It earns points for brevity but loses polish.

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

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

For a zero-parameter policy tool with an output schema and safety annotations, the description covers the core decision, determinism, and signed evidence. It is incomplete on when to choose this tool over related guards and on what exact input object the tool expects, which matters because the schema is intentionally open.

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

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

There are zero documented parameters and the input schema is an open object, so the description must carry the semantic weight; it names the relevant conceptual inputs (delegated authority, per-call limit, remaining budget). It still doesn't provide exact keys or value formats, but with no schema-defined parameters this is a reasonable baseline-4 case.

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

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

The first clause names the resource (delegated spend) and the core behavior (fail closed when delegated authority, per-call limit, or remaining budget is insufficient), so an agent can tell this is an authorization/policy gate. It does not explicitly state a success-path action or differentiate itself from the many guard-style sibling tools, which keeps it from a 5.

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

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

There is no 'use when' or 'instead of' guidance, and none of the many sibling guard tools are named as alternatives. The only usage cue is the failure condition, which tells an agent when the tool would block, not when it should be called.

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 the full burden of behavioral disclosure. It does not state whether the guard blocks, warns, or logs, what happens when a policy is violated, what the output contains, or what the 2 required nested objects must include. Only the protected dimensions are listed.

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

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

One compact sentence with no filler. It front-loads the guard's purpose, though it omits any structural cue about the required objects.

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

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

No annotations, no output schema, two required nested objects with 0% schema description coverage, and no behavioral details. The description is far too thin for a tool that appears to make security-critical decisions about delegation.

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 both parameters are required nested objects with no shape or property descriptions. The description adds no meaning beyond naming the domains, so an agent cannot infer what 'delegation' and 'policy' must contain.

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: enforcing 'least-privilege guard' on 'agent-to-agent delegation scope, destinations, budget and expiry'. However, no verb directly states what the tool does (e.g., validate, check, enforce). It also lacks distinguishing context from siblings like payment_preflight or counterparty_risk_preflight, which also appear to be pre-execution guards.

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

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

There is no when-to-use or when-not-to-use guidance. The description does not explain in which scenarios an agent should invoke this guard versus alternatives such as preflight or counterparty_risk_preflight.

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 cover the safety profile (readOnly, idempotent, non-destructive, closed-world), so the bar is lower. The description adds genuinely useful behavior: it does not echo content, and it requires matching 64-hex expected/observed hashes. But it omits what counts as 'successful', what a mismatch returns, and the pricing/billing mechanics beyond the flat fee.

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 dense sentence followed by the price. Front-loaded with the core action and no filler. The dense clause stacking slightly hurts readability but nothing is wasted.

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?

A paid, mutation-adjacent evidence tool with a nested 6-field object, 0% schema coverage, and no output schema. The description should explain the input object shape, the matching rule, mismatch behavior, and the return value. It covers only the hash-matching idea and the price, leaving most of what an agent needs to call it correctly 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 0% and the single required 'delivery' parameter is a nested object with six required sub-fields, none documented. The description gestures at the fields (transaction, request, content hashes) but supplies no format, no max length enforcement, and no explanation of the hash-matching semantics the caller must satisfy.

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 verb ('Bind') and the resources involved (delivery, transaction, request, content hashes), which is more specific than a tautology. However 'Bind successful delivery' is jargon that doesn't clearly explain to an agent what the tool actually produces or how it differs from near siblings like transaction_assurance, agent_task_handoff_receipt, or attest. The purpose is inferred rather than stated plainly.

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 when-to-use guidance and no mention of alternatives, despite dozens of closely-named evidence/attestation siblings. The '0.003 USDC' price hints at a paid operation but the description never says when this paid call is warranted versus free siblings like schema_normalize_free or try_service.

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 it does disclose meaningful behavior: it fails closed on empty dependency sets or missing registry policy, and it separates claimed digests from verified provenance. It also discloses metered pricing (0.003 USDC). Still missing are whether it performs network/registry lookups, what an assessment result looks like, or any auth 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?

Three compact clauses, front-loaded with the fail-closed constraint and ending with the cost, with no padding or repetition. It is efficient, though the brevity contributes to under-specification elsewhere.

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 two required parameters, a nested object schema at 0% description coverage, no output schema and no annotations, the description is far too thin to call correctly. It neither explains the input contract nor what the assessment yields, leaving core questions unanswered.

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 both parameters (including a nested policy object with allowed_registries) are undocumented at any level. The description only implicitly alludes to 'dependency sets' and 'registry policy' without specifying entry format, registry identifier shape, or the 1000-item cap, so it does almost nothing to compensate for the schema gap.

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

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

The name and phrase 'distinguish digest declarations from verified provenance' gesture at the function, implying a supply-chain provenance check against registry policy. However, the description never states plainly what the tool does or returns (e.g., 'assesses/attests dependency provenance'), and it offers no differentiation from nearby siblings like fetch_evidence or mcp_manifest_firewall. Purpose is inferable but vague.

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

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

There is no statement of when to use this tool, what prerequisites exist, or which siblings are alternatives. The clause 'fail closed on empty dependency sets or absent registry policy' describes a guard behavior, not a usage condition that tells an agent when to select 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?

With no annotations, the description carries the behavioral burden. It usefully discloses accepted input formats, the source-backed nature of the output, the lack of OCR support, and the price. However, it does not describe failure modes, rate limits, processing guarantees, or whether any action is taken beyond normalization.

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

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

The description is very short and front-loaded, with the core transformation stated first, followed by the OCR limitation and cost. Every clause adds useful information. It is slightly too terse given the unexplained expected_fields parameter, but the structure itself is 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 tool has two parameters, no annotations, no output schema, and only a one-sentence description. The description fails to explain expected_fields, input URL semantics, output shape, or behavioral constraints beyond OCR. An agent cannot confidently invoke this tool correctly from the provided information.

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 clarify the parameters. It indirectly describes source_urls as public text/HTML/JSON/XML sources, but it does not explain expected_fields at all, and gives no hint about their format, purpose, or relationship to the output. This leaves a required part of the contract unexplained.

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 resource (public text, HTML, JSON, XML) and the result (source-backed JSON). It positions the tool as a normalizer/converter and adds a differentiating constraint ('no OCR'). It does not explicitly distinguish it from siblings such as source_backed_search or verified_web_extract, but the core purpose is clear.

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 'Public text, HTML, JSON or XML' and 'no OCR' imply the tool is for public non-image document conversion, but there is no explicit statement of when to use this tool versus a sibling, and no mention of when not to use it. No alternatives or routing conditions are provided.

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

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

No annotations are provided, so the description carries the full burden. It does disclose the price (0.003 USDC), the freshness requirement, the accepted proof methods, and the control-vs-legal-ownership distinction — useful behavioral context. It omits whether the call is read-only or mutating, what happens on failure, and what the caller receives.

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 dense sentence with no filler, and the cost and freshness constraint are placed up front. The phrasing 'Require a fresh ... challenge' is elliptical but compact.

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 annotations, no output schema, and an undocumented nested evidence object, the description leaves too much for the agent to infer about inputs and outcomes. Given the tool's structural complexity, substantially more detail was warranted.

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

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

Schema description coverage is 0% for two parameters, one of which is a nested object with five required subfields. The description maps loosely onto 'domain' and, via DNS-01/HTTP-01, onto the evidence method, but leaves challenge_sha256, verified_at, and independently_verified unexplained, so it does not compensate for the coverage gap.

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

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

The description identifies a domain-ownership verification via DNS-01/HTTP-01 challenges and distinguishes control from legal ownership, which is a meaningful resource-specific idea. However, the leading verb 'Require' is an odd framing for a tool call and never states plainly what the tool does (verify, attest, issue evidence, or gate an action). An agent knows roughly the subject matter but not the operation.

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

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

There is no when-to-use guidance, no mention of alternatives among the many evidence sibling tools (rwa_sanctions_screening_evidence, agent_reputation_evidence, mcp_server_identity_evidence, etc.), and no preconditions stated beyond a fresh challenge. The 'freshness' hint is the only contextual cue.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true, destructiveHint=false, and openWorldHint=false, so the agent knows this is a safe, pure, repeatable read operation. The description adds the cost (0.003 USDC), which is useful operational context not present in annotations. However, it does not describe output format, detection sensitivity, or how duplicates are identified.

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, efficient sentence that front-loads the purpose and appends the cost. It wastes no words, though it could be slightly more structured by separating purpose and cost.

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

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

For a single-parameter read-only detection tool with no output schema, the description covers what is detected and the cost. However, it lacks details on input format, output shape, and when to use it, which are needed for correct invocation given the 0% schema description coverage.

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

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

Schema description coverage is 0%, so the description must carry the burden of explaining the 'charges' parameter. The description mentions 'transaction hashes, payment identifiers and idempotent intents', which hints at what the charges array should contain, but does not specify the expected object shape, required fields, or limits (maxItems: 1000 is only in the schema). This leaves a significant gap for the sole required parameter.

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

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

The description names a specific verb (detect) and resource (duplicate/repeated transaction hashes, payment identifiers, idempotent intents). It clearly distinguishes itself from adjacent siblings like payment_preflight and idempotency_replay_guard by focusing specifically on duplicate detection. However, it does not explicitly differentiate itself from payment_diagnose or payment_receipt_reconciler.

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

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

There is no guidance on when to use this tool versus alternatives. The description does not mention prerequisites, when-not-to-use cases, or which sibling tools handle related concerns. The only contextual cue is the cost, which helps with selection but is not 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?

Annotations already declare readOnlyHint=true, idempotentHint=true, and destructiveHint=false, covering the safety profile. The description adds behavioral context with 'deterministic signed', implying output is reproducible and cryptographically signed, which goes beyond annotations. However, it does not explain what 'signed' entails, whether authentication is needed, or what the output format is. With annotations doing most of the work, a 3 is appropriate.

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

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

The description is very short and front-loaded with the tool name, which is efficient. However, 'Durable Agent Task' simply repeats the title and does not earn its place. The rest of the sentence adds some value, so overall it is mostly concise but with a minor 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 too vague for a tool with one required parameter and no parameter descriptions. It does not explain what a 'durable agent task' is, what 'deterministic signed assessment' means for the caller, or how the 'task' input should be provided. Although an output schema exists and annotations cover safety, the description does not give enough context for an agent to call this correctly, especially given many similar sibling 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 reported as 100%, so the baseline is 3. The description adds 'supplied input', which suggests the 'task' parameter is the input being assessed, but it does not clarify the expected structure, format, or constraints of that input. This provides minimal additional meaning beyond the parameter name.

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

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

The description says it is a 'deterministic signed assessment over supplied input', which gives a rough sense of the tool's function but lacks a specific verb or clear resource. It does not distinguish itself from sibling tools like 'attest' or 'verify', which could also be described as signed assessments. It is more than a tautology but remains vague about what the tool actually does (executes a task? returns an assessment? creates a durable record?).

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

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

There is no guidance on when to use this tool or how it differs from alternatives. No conditions, exclusions, or references to sibling tools are provided. An agent would have no way to decide between this and similar-sounding tools like 'attest' or 'signed_result_comparator'.

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

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

Annotations already declare read-only, idempotent, and non-destructive behavior. The description adds meaningful context: deterministic, evidence-bounded, signed, and no live-catalog change. However, it leaves 'signed' and 'evidence-bounded' undefined, and the fee '0.004 USDC' is unclear.

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

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

The description is very brief and front-loaded with the core purpose, followed by three short constraints. The stray '0.004 USDC.' feels abrupt and there is a typo ('catalog.;'), but every sentence carries intent.

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

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

For a zero-parameter, read-only tool with an output schema, the description is nearly sufficient. Yet it doesn't clarify whether the caller should supply arbitrary properties (schema allows additionalProperties) or what 'evidence-bounded' means in practical terms, leaving some ambiguity.

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

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

There are zero defined parameters, and the schema is a generic object with additionalProperties true. The description adds no parameter-level guidance, but with zero formal parameters the schema inherently covers everything. Baseline 3 applies.

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

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

States a specific action (propose) on a specific artifact (capped shadow price) and explicitly notes it does not modify the live catalog, which distinguishes it from price-update tools. However, the phrase 'capped shadow price' is domain-specific and not fully self-explanatory to an unfamiliar agent.

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

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

The description implies a use case (proposing a price without changing the catalog) but provides no explicit when-to-use guidance, prerequisites, or alternatives like price_discovery_engine. An agent would have to infer when this tool is appropriate relative to its many siblings.

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

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

Annotations already declare readOnlyHint, idempotentHint, and destructiveHint. The description adds meaningful behavioral context: deterministic, evidence-bounded, signed, and a 0.004 USDC cost. There is no contradiction with the read-only annotation since 'Detect' is consistent with it.

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

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

The description is very short and front-loads the core purpose, but the semicolon splice before '0.004 USDC' is awkward and the cost fragment is not labeled as a cost. The behavioral terms are high-signal, but the structure feels fragmented rather than polished.

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

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

For a zero-parameter read-only tool with an output schema, the description covers purpose, cost, determinism, evidence-boundedness, and signing. However, it lacks when-to-use guidance relative to sibling tools and leaves the meaning of 'evidence-bounded' and the '0.004 USDC' fragment unexplained.

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

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

There are zero named parameters and the schema only accepts an arbitrary object with minProperties 1. With no declared parameter contract, the description cannot meaningfully enrich parameter semantics, and the 0-param baseline of 4 applies.

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

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

The description clearly identifies a specific action and resource: 'Detect self-transfer and reciprocal economic patterns'. The clause 'without presenting correlation as fraud' adds useful intent, but it does not explicitly differentiate this tool from siblings like trust_anomaly_detector or sybil_reputation_guard.

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

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

There is no guidance about when to use this tool versus alternatives, and no sibling/alternative is named. The non-fraud caveat is a behavioral guardrail rather than a usage directive, 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 bears the full burden of behavioral transparency. It adds some useful traits—source-bounded results, explicit missing facts, and a 0.008 USDC cost—but it does not disclose read/write behavior, whether it fetches the source URLs, persistence, auth, response shape, or failure semantics.

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 definition is compact and front-loaded: scope appears first, missing-facts behavior second, and price last. There is no filler and each clause earns its place. It is under-specified overall, but the structural efficiency is strong.

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 three parameters, a nested subject object, no output schema, and a crowded sibling list, the one-sentence description is insufficient. The agent cannot learn how evidence is returned, how subject relates to expected_fields, or when to select this tool over similar ones.

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

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

The schema has 0% description coverage for three parameters, so the description must compensate. It indirectly maps 'source-bounded' to source_urls, 'entity' to subject, and 'field coverage ... missing facts' to expected_fields, adding some meaning beyond the bare schema names. However, it does not explain formats, requiredness, constraints, or how subject and expected_fields 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 conveys a specific output concept—'Source-bounded entity field coverage with explicit missing facts'—and mentions the price, but it uses a noun phrase rather than a clear verb+resource statement. It does not distinguish this from siblings like multi_source_fact_bundle or source_backed_search.

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

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

There is no when-to-use guidance, no exclusions, and no reference to alternatives. The description only characterizes the result and cost, leaving the agent to infer when this evidence tool should be chosen over the many related tools in the sibling list.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true, and destructiveHint=false. The description adds valuable behavioral context beyond these: 'Deterministic, evidence-bounded and signed,' plus a 0.004 USDC cost. This enriches the agent's model of the operation without contradicting the annotations.

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

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

The description is short and front-loads the action. The semicolon leading into '0.004 USDC' is slightly abrupt, and 'separating registration from ownership' is a bit cryptic, but no sentence is wasted and the core behavior is stated first.

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 output schema present and annotations covering safety and idempotency, the description does not need to explain return values. However, the input schema is open with minProperties=1, and the description does not clarify what properties an agent should supply (e.g., how to specify identity or evidence). For a specialized ERC-8004 tool, this leaves a meaningful 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 tool has 0 declared parameters, so the baseline is 4. The description does not document parameter details, but there are none in the schema to explain. The open additionalProperties=true schema means the description's references to 'identity' and 'evidence' are the only semantic clues, which is acceptable for a zero-param tool.

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

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

The description states a specific verb and resource: 'Bind an ERC-8004 registry identity to evidence.' This clearly identifies the tool's core function and adds a distinguishing constraint ('separating registration from ownership'). It does not explicitly contrast with sibling tools like erc8004_reputation_intelligence or onchain_evidence, so it falls short of a 5.

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

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

The description gives no guidance on when to use this tool versus alternatives. It mentions the cost and behavioral properties but provides no selection criteria, prerequisites, or exclusions, leaving an agent to infer suitability from the name alone.

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

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

Annotations already declare readOnlyHint, idempotentHint, and non-destructive behavior. The description adds meaningful context beyond that: deterministic execution, evidence-bounded results, signed output, low-sample abstention, and a cost of 0.004 USDC. These are behavioral traits an agent could not infer from the annotations alone.

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

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

The description is very short and front-loads the core purpose. The fragments about cost, determinism, and signed output each add useful information. Minor punctuation oddity ('abstention.;') slightly detracts, but the overall structure is appropriately terse and scannable.

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

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

Annotations cover the safety profile and an output schema exists, so the description does not need to explain return values. However, the input contract is unclear: the schema allows arbitrary additional properties and minProperties is 1, yet the description never explains what input the tool expects or how it relates to other ERC-8004 tools. This leaves an agent uncertain about what to pass when invoking 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?

With zero documented parameters and 100% schema coverage, there are no parameter details for the description to clarify. The baseline for a zero-parameter tool is 4. The open input schema with additionalProperties remains ambiguous, but the description was not required to compensate for undocumented parameters because none are defined.

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 identifies a specific operation ('aggregate') and a specific resource ('diverse verified reputation observations'), with a notable behavioral qualifier ('low-sample abstention'). It is not a tautology and gives an agent a working sense of the tool, though it does not explicitly differentiate itself from sibling tools like erc8004_identity_evidence or agent_reputation_evidence.

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

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

The description gives no explicit guidance on when to choose this tool over alternatives, nor does it mention any related sibling tools or exclusions. 'Low-sample abstention' hints at a condition, but there is no practical routing information such as 'use this when you need aggregated evidence' or 'use agent_reputation_evidence for individual observations.'

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

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

Annotations already declare readOnlyHint, idempotentHint, and destructiveHint, so the description does not need to restate safety. It adds the behavioral traits 'deterministic' and 'signed' for the assessment, which are useful beyond the annotations, though it does not explain what 'signed' means or mention any other operational 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?

At one sentence, the description is compact and the 'deterministic signed assessment' clause is meaningful. However, the opening repeats the title and provides little structured information, making this conciseness more under-specification than efficient 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?

The schema lists required fields (steps, budget_atomic) without property definitions, so the description needed to explain what input is expected and what kind of assessment is produced. It only says 'supplied input,' leaving important context to inference despite the presence of an output schema.

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

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

The schema exposes no property definitions (parameter count 0), so the description carries no parameter-semantics burden under the 0-param baseline. The description does not add detail about the required steps and budget_atomic fields, but it also does not mislead; coverage is reported at 100%.

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 leads with a restatement of the title ('Execution Cost Estimator') and then describes the tool only as a 'deterministic signed assessment over supplied input.' This lacks a specific verb and resource, and it does nothing to distinguish the tool from siblings such as transaction_risk_score or signed_result_comparator.

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

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

The description gives no indication of when to use this tool, what it should not be used for, or which sibling alternatives exist. There are no prerequisites, no exclusion conditions, and no reference to the many cost/risk/budget siblings in the list.

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

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

The description adds meaningful behavioral context: it performs SSRF checks on redirects, DNS, and connected addresses, plus hashing and injection screening. Annotations already declare readOnly, openWorld, idempotent, and non-destructive. The cost mention is helpful, but there's no detail on failure modes, rate limits, or output format.

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

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

Single efficient sentence that packs in key features and cost. Front-loaded with the core action. No wasted words.

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

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

Given no output schema and a single parameter, the description covers the core action and security checks. However, it omits return value details, error handling, and cost implications beyond the flat fee. Adequate but with clear 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 there is one required parameter 'url'. The description doesn't explain the parameter's expected format beyond the schema's 'uri' type, but 'bounded' and 'public' imply restrictions on what URLs are allowed. Baseline 3 when schema has minimal elaboration.

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

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

States a specific verb+resource: 'fetch bounded public evidence' with the added detail of SSRF checks and hashing. It's clear what the tool does, though it doesn't explicitly contrast with siblings like 'try_service' or 'webhook_verifier'.

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 indication of when to use this tool versus alternatives. The '0.004 USDC' cost hints at a paid service, but there's no guidance on when it's appropriate or what happens if the fetch fails.

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 the full behavioral burden. It usefully discloses a cost of 0.002 USDC, which is a behavioral trait, but it does not state whether this is a read-only operation, what permissions are required, or any side effects.

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

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

The description is a single, front-loaded sentence that efficiently conveys the core purpose and the cost. Every element earns its place.

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

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

Given the tool's simplicity, the presence of an output schema, and the inclusion of cost, the description is largely complete. It lacks usage guidance and deeper behavioral disclosure, but for a straightforward classifier it is adequate.

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

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

Schema description coverage is 100%, so the schema already documents the parameters, and the description adds no additional meaning about 'action' or 'policy'. With high schema coverage, a baseline of 3 is appropriate.

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

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

The description states a specific verb ('Classify') and resource ('an action') with the three possible outcomes, making the tool's purpose clear. It does not explicitly distinguish itself from siblings like inter_agent_policy_evaluator or tool_call_policy_guard, so it falls short of a 5.

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

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

There is no guidance on when to use this tool versus alternatives. The description simply states what it does, without any context, prerequisites, or when-not-to-use conditions.

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

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

Without annotations, the description carries the full behavioral burden. It discloses the cost (0.002 USDC) and that it detects replays/conflicts, but says nothing about side effects, authentication needs, rate limits, or what happens on detection. This is insufficient for a guard-type 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?

A single, front-loaded sentence with no wasted words. The price is tacked on after a semicolon, which is slightly awkward but still efficient and informative.

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

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

An output schema exists, so return values need not be explained. However, with no annotations, the description should cover prerequisites, behavior, and usage context — it provides none of these, leaving significant gaps for an agent to call the tool correctly.

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

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

Schema description coverage is 100%, so the schema already documents the two required parameters. The description adds no param-specific meaning (e.g., format of idempotency_key or allowed values for action), 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 names a specific verb ('Detect') and resource ('safe replays and conflicting idempotency-key reuse'), making the tool's function clear. It does not explicitly differentiate itself from siblings like duplicate_charge_detector or concurrency_guard, but the idempotency-key focus is distinctive enough.

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

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

No guidance is given on when to use this tool versus alternatives, prerequisites, or exclusions. The description only states what it does and the cost; an agent must infer usage entirely.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true, and destructiveHint=false, so the safety profile is covered. The description adds useful context such as the fee (0.005 USDC), the digest-based delta mechanism, and the exact record/template/evidence contents, but it does not explain response shape or pagination 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 compact sentence that front-loads the core purpose and packs content, delta semantics, evidence, templates, and pricing without unnecessary filler. It is efficient, though the final clause is dense.

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

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

For a simple read-only, idempotent feed with two parameters, the description is adequate but not complete. It lacks explicit return-format details and does not fully connect the optional SHA-256 parameter to delta mode, which would matter given there is no output schema.

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

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

Schema coverage is 0%, but the description partially compensates by naming 'snapshot' and 'digest-based delta,' which maps to the mode enum. It does not explicitly clarify when since_snapshot_sha256 should be supplied, though the pattern and parameter name make the intent inferable.

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 resource: a canonical catalog snapshot or digest-based delta, and enumerates its contents (HTTP/MCP records, PHION Execute templates, signed evidence). This goes beyond the name and distinguishes the tool from the many evidence/verification siblings, though it lacks an explicit verb.

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 'snapshot or digest-based delta' wording implies when the tool should be used, but it does not provide explicit when-to-use guidance, exclusions, or comparisons with sibling tools. Usage context is present mainly by inference from the content description.

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

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

Annotations declare readOnlyHint=true and destructiveHint=false, but the description says successful inspections cost 0.009 USDC and failed inspections are not charged. Charging a fee is a side effect that contradicts the read-only annotation, so the description contradicts the structured behavioral hints.

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

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

One front-loaded sentence with three semicolon-separated clauses; every clause adds distinct information: scope, failure billing, and price. There is no wasted wording.

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

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

No output schema exists, and the description does not explain what the inspection checks, what constitutes a failed inspection, or what result is returned. For a paid pre-payment inspection, this leaves the agent without enough context to interpret the outcome.

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 lone 'url' parameter has no schema description. The protocol list weakly suggests the URL is an agent endpoint in one of those protocols, but it does not explain what URL should point to or what forms are accepted.

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 verb and resource: pre-payment agent inspection across named protocols. It is clear enough to distinguish from generic tools, though it does not explicitly differentiate itself from siblings such as payment_preflight or counterparty_risk_preflight.

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 'Pre-payment' implies use before paying an agent, but there is no explicit when/when-not guidance or mention of alternatives such as payment_preflight, try_service, or verify. The agent must infer timing from the title-like clause rather than from stated usage rules.

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

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

Annotations already establish read-only, idempotent, non-destructive behavior. The description adds cost (0.003 USDC) and enumerates required fields, which is useful, but does not explain conflict behavior or how the computation is used. With annotations covering safety, this is an acceptable addition.

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?

Very concise, but the three semicolon-separated clauses are poorly structured and front-loaded with a requirement rather than the tool's purpose. The information could be delivered more clearly in the same 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?

For a tool with one complex array parameter, no output schema, and annotations that cover safety, the description is incomplete: it does not explain return values, how policies are evaluated, or the significance of 'restrictive cap' and 'shared actions'.

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 provide semantics. It lists the required fields ('policy identity, subject, action, lifetime and valid decisions') which maps to the schema's nested required fields, adding some meaning. However, it does not explain the array structure, min/max limits, or the meaning of each field beyond renaming.

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 computation ('compute the restrictive cap and shared actions'), which is a clear verb+resource, but it is preceded by a requirement list and lacks a clear statement about evaluating policies or how it relates to sibling tools. It is not a tautology, but the purpose is not front-loaded.

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

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

No guidance on when to use this tool versus alternatives like tool_call_policy_guard or preflight. The precondition list ('Require policy identity...') is a schema requirement, not 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?

With no annotations, the description carries the full behavioral burden. It discloses a gating condition and a price of 0.003 USDC, but does not explain what happens if conditions are unmet, what the resume action actually mutates, or how idempotency and side effects are handled.

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

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

The description is a single front-loaded sentence with no filler, efficiently stating the gating condition and cost. The semicolon-separated price is compact, though the dense field list could be clearer.

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 three nested object parameters, 0% schema description coverage, no annotations, and no output schema. The description does not explain return behavior, failure modes, or how the nested objects map to recovery semantics, leaving significant gaps for safe invocation.

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

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

Schema description coverage is 0%, so the description must compensate. It names several required concepts (identity, sequence, deadline, attempt budget, side effects), but it omits nested fields such as checkpoint.state_sha256 and policy.max_attempts, and mentions idempotency which does not appear in 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 implies a resume/recovery action for interrupted tasks, and the name confirms the resource. However, it does not state the purpose as a clear verb+resource pair and offers no differentiation from sibling recovery, idempotency, or transaction tools.

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

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

The phrase 'Resume only when...' gives a precondition for use, which is more than no guidance. But it does not say when to choose this tool over alternatives like transaction_recovery or idempotency_replay_guard, nor does it describe when not to use it.

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

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

Annotations already cover the safety profile (readOnly, idempotent, non-destructive, closed-world), so the bar is lower. The description adds genuinely new behavioral context the annotations do not carry: what exactly is checked (hash continuity, timestamps, ordering) and the 0.010 USDC cost of the call. It still omits what a failure result looks like.

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 dense sentence that front-loads the verification targets and tucks the price at the end. No filler, though the arrow notation for the lifecycle is compressed enough to require inference.

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, no parameter documentation, and a nested 'expected' object, so the description should do more. It communicates scope and cost but leaves the return semantics (pass/fail shape, mismatch reporting) and the role of 'expected' unexplained.

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% across three parameters (journey_id, events, expected) with a nested object and array constraints (minItems 2, maxItems 128). The description vaguely gestures at event content through 'hash continuity' and 'ordered lifecycle' but never explains journey_id, what belongs in events, or the role of expected, so it does not compensate for the coverage gap.

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

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

The description names a specific verb (verify) and the exact resource scope: hash continuity, timestamps, and an ordered intent→quote→payment→delivery lifecycle. That is far more concrete than the sibling 'verify' or 'transaction_assurance', though it does not explicitly name how it differs from those near-neighbors.

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

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

Usage is implied by the lifecycle wording — you call this to validate a recorded journey's integrity — but there is no explicit when-to-use statement, no prerequisites, and no pointer to alternatives like payment_receipt_reconciler or transaction_assurance for overlapping verification needs.

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 only adds a cost figure (0.002 USDC) but does not disclose the return value, how the evaluation works, what happens when the maximum age is exceeded, or any side effects.

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

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

The description is very brief and front-loads the action and cost, but it is a fragment rather than a structured explanation. The brevity leaves out necessary details, making it under-specified rather than efficiently 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 no annotations and no output schema, the description is far from complete. An agent would not know what result to expect, how to handle stale sources, or what the 0.002 USDC signifies beyond a cost.

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

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

Schema description coverage is 0%, so the description must explain the parameters. It implicitly maps 'explicit maximum age' to max_age_seconds but does not clarify source_urls beyond a vague 'live source observation', leaving the URL format and interpretation undocumented.

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 verb ('Evaluate') and resource ('live source observation against explicit maximum age'), indicating a freshness check. It is not a tautology and is distinct enough from related tools, though it doesn't explicitly compare to 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?

There is no guidance on when to use this tool versus alternatives. The description only includes the task statement and a cost, with no mention of context, exclusions, or 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?

Annotations already declare idempotentHint=true, readOnlyHint=false, and destructiveHint=false, so the safety profile is covered. The description adds genuine context beyond that: atomicity, a cumulative cap that persists across calls, and conflict-safe idempotency. It still omits what happens on cap exhaustion, whether a reservation can be released/expires (ttl_seconds), and the role of capability_token as an authorization requirement.

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

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

A single front-loaded sentence with no filler; the key traits (atomic, capped, idempotent) come first and the cost note is appended. It is dense but not padded.

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 state-mutating, 6-parameter, 5-required financial tool with no output schema and zero schema descriptions, and the description does not compensate. Authorization via capability_token, TTL behavior, cap-exhaustion behavior, and return semantics are all unaddressed.

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% across 6 parameters, so the description carries the full burden and largely fails. 'Cumulative cap' loosely maps to cumulative_limit and 'idempotency' to idempotency_key, but amount units (the schema only gives an integer-string pattern), capability_token, ttl_seconds, and mandate_id are never explained. The '0.004 USDC' figure describes the tool's own price, not the amount parameter.

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

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

States a specific action and object: an atomic spending reservation against a mandate, with a cumulative cap and idempotency guarantee, plus its price (0.004 USDC). The verb+resource is clear, but it does not differentiate itself from plausible siblings such as agent_budget_guard, subscription_spend_guard, idempotency_replay_guard, or rwa_nav_reserve, leaving the agent to guess which reserve/guard tool applies.

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 never says when to call this versus the many guard/preflight siblings, nor does it state prerequisites such as holding a valid mandate_id or capability_token. Usage is only implied by the phrase 'spending reservation'.

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

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

No annotations are provided, so the description carries the full behavioral burden. It usefully discloses that the diff is recursive, requires explicit versions, flags sensitive changes without a version advance, and costs 0.002 USDC. However, it does not explain what counts as sensitive, how the diff is returned, or any permission or payment workflow beyond the cost mention.

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 efficiently combines the core operation, a key constraint, a behavioral flag, and pricing 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 tool with nested inputs, no output schema, and no annotations, the description is moderately complete: it conveys the diff behavior, version requirement, sensitive-change flagging, and cost. Still missing are return format, treatment of nested manifest fields, and any auth or payment details beyond the stated USDC amount.

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 both parameters are nested objects. The description only adds that explicit versions are required, which maps to the schema's required version fields, but it does little to explain the remaining object structure or how previous and current manifests are compared. With low coverage and nested objects, this is insufficient.

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

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

The description states a specific operation (recursive manifest diff) and adds distinctive conditions: explicit versions required and sensitive changes flagged only when there is no version advance. It is clear what the tool does, though it does not explicitly distinguish itself from siblings like mcp_manifest_firewall or tool_capability_drift_monitor.

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

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

There is no guidance on when to use this tool versus alternatives, nor when not to use it. The description implies a diff use case, but it leaves the agent to infer the correct context and any prerequisites from the name and function alone.

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 reveals that the snapshot is timestamped, provenance-bearing, and costs 0.005 USDC, which is useful context. But it does not disclose side effects, data-source behavior, failure modes, or what the returned snapshot structure is, leaving major behavioral gaps.

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

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

The description is a single concise sentence that front-loads the core concept and ends with the cost. It contains no filler words. It loses one point because it prioritizes compactness over including a verb and parameter linkage, but structurally it is 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?

With 3 parameters, 0% schema coverage, no annotations, and no output schema, the description needs to carry substantial weight. It does not explain how to call the tool, what the output looks like, or what the required parameters mean. The brief noun phrase and price are insufficient for correct invocation.

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

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

Schema description coverage is 0%, so the description must compensate by explaining the three parameters. Instead, it only loosely maps to the idea of market data and provenance and never mentions source_urls, subject, or expected_fields. The required source_urls parameter is completely unexplained, leaving an agent without enough information to fill it correctly.

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

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

The description says "Timestamped public market-data snapshot with provenance; 0.005 USDC." This names a specific resource and adds distinguishing attributes (timestamped, provenance, cost), which separates it from many siblings. However, it lacks a verb — it never states explicitly what the tool does with the snapshot — so it stops just short of a full purpose statement.

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

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

The description gives no guidance on when to use this tool versus alternatives. It implies a paid public-data retrieval context with the cost note, but it does not state when to prefer this over sibling tools like live_data_freshness or source_backed_search, nor any conditions or exclusions.

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

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

Annotations already cover read-only, idempotent, and non-destructive behavior. The description adds valuable traits beyond annotations: determinism, evidence-boundedness, signing, and the abstaining behavior on insufficient history. This provides meaningful context for an agent's expectations, though it does not detail output format or error handling.

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

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

The description is very short and front-loads the core purpose. Each phrase adds value (purpose, cost, behavioral traits). However, the punctuation is awkward (multiple periods/semicolon) and the cost mention could be considered extraneous, but overall it is 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?

For a tool with an open input schema, no parameter guidance, and only an output schema (not described), the description is incomplete. An agent cannot determine what input to provide or what the response structure will be. The abstaining behavior is noted, but the lack of input/output details makes the tool hard to invoke correctly.

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

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

The schema has zero defined parameters but is an open object requiring at least one property (minProperties: 1). The description does not explain what properties to provide, leaving the agent without guidance on input structure. With no named parameters, the baseline is 4, but the open schema creates a gap that the description fails to fill.

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 ('Forecast verified demand trends') and a resource ('market demand'), and includes a behavioral qualifier ('abstaining on insufficient history') that differentiates it from generic predictors. The added traits (deterministic, evidence-bounded, signed) further clarify its distinct nature among many sibling tools.

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

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

The description implies a usage condition ('abstaining on insufficient history') but does not explicitly name alternatives or state when this tool should be preferred over other predictors like provider_quality_predictor or price_discovery_engine. There is no explicit 'use this when' guidance or exclusion of other contexts.

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

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

Annotations already cover readOnly, idempotent, and non-destructive behavior. The description adds 'deterministic' and 'signed' attributes, which slightly extends the behavioral picture by indicating reproducible, cryptographically signed results. However, it does not disclose what input boundaries exist or what 'assessment' actually entails beyond that.

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

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

The description is one sentence and wastes no words. Front-loading the name and appending the key behavioral qualifier is efficient. It is concise, though the brevity contributes to vagueness.

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 two required parameters and no enums, the tool is moderately simple, but the description leaves essential details undefined: what protocol versions are valid, how methods should be passed, what a 'signed assessment' looks like, and how the result should be consumed. The output schema mitigates return-value ambiguity, but input semantics and operational meaning are missing.

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

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

The input schema names required parameters (protocol_version, methods) but gives no property descriptions Armstrong. The description's 'supplied input' adds no meaning to these parameters. Although schema description coverage is reported as 100%, the visible schema lacks any property-level documentation, so the description does not compensate for the missing semantic context around protocol_version or methods.

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, 'deterministic signed assessment over supplied input,' restates the name's 'compatibility gateway' without explaining what compatibility is being assessed or what the output represents. There is no clear verb-resource pair—'assessment' is generic and does not distinguish this from numerous sibling assessment/gateway 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 given about when to use this tool versus alternatives. None of the sibling tools (e.g., mcp_manifest_firewall, preflight, verify) are referenced, and no context or exclusions are provided, leaving an agent with no basis for routing between similar tools.

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