Agentic Keychain

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

Annotations already declare the safety profile (readOnlyHint, idempotentHint, destructiveHint=false, openWorldHint=false). The description adds real behavior beyond that: it shares the same method and offer shape as evaluate_capability, returns a ranked result set, and surfaces blocked entries with reason codes. It does not discuss cost/latency of running the comparison, which is a minor gap.

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

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

Front-loaded with the action, then Use when / Not for / Input / Output in a tight sequence. Every sentence carries routing, input, or return information; no filler.

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

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

There is no output schema, so the description correctly supplies the return contract: ak.comparison.v1, ranked by decision, lower-bound net saving, relevance and capability id, each with reasons and an ak.offer.v1 offer. Combined with 100% schema coverage on seven parameters, an agent has everything needed to call and interpret it.

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

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

Schema coverage is 100%, so baseline is 3. The description exceeds it by clarifying that the optional task, model, expected_runs, baseline_cost_estimate_usd, context and constraints are exactly those evaluate_capability reads, giving the agent cross-tool semantic consistency. It adds no per-parameter syntax beyond the schema.

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

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

The first sentence states a precise verb (Assess), resource (capabilities), cardinality (two to five), and scope (same inputs, same method/offer shape as evaluate_capability). It explicitly distinguishes itself from search_capabilities and evaluate_capability, so an agent can route without opening any schema.

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

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

It gives an explicit 'Use when' trigger (holding a shortlist of ids and wanting decision, reasons and offer in one answer) and an explicit 'Not for' with the two named alternatives for the excluded cases. Nothing about when to select this tool is left 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 readOnlyHint, idempotentHint and destructiveHint=false, so safety is covered. The description goes beyond them by disclosing output edge cases: break-even runs is null when the interval does not show a saving, and the user's estimate is omitted where success is not accepted or the baseline falls outside the measured range. It does not mention auth or rate limits, but for a read-only estimator the added result semantics are substantial.

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

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

It is front-loaded with the result shape, then cleanly partitioned into 'Use when', 'Not for', 'Input' and 'Output' segments, so every sentence earns its place. The phrasing is densely packed with clauses, which costs a little readability, but there is no filler.

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

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

With no output schema, the description carries the return contract and does so well: it names the ak.roi.v1 shape, states one economics entry per measured model, and explains the null break-even and omitted-estimate cases. Combined with the input guidance, an agent has everything needed to call and interpret this tool.

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

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

Schema description coverage is 100%, so the baseline is 3 and each parameter is already documented. The description still adds relational meaning beyond the schema by pairing expected_runs with baseline_cost_estimate_usd ('an estimate at your scale') and by clarifying that model narrows output to one model while the measured-range constraint governs whether baseline is usable.

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 opening clause states a precise verb and resource ('expected saving per run, break-even runs and net saving over expected_runs, with intervals') and scopes it to 'one capability and no task'. The 'Not for' clause explicitly separates it from evaluate_capability (single task decision) and compare_capabilities (multiple candidates), so an agent can distinguish it from siblings without opening schemas.

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

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

It gives explicit 'Use when: you know the capability and want its economics on each model the registry measured' plus a named 'Not for' list with the two competing siblings and the condition that selects each. When-to-use, when-not, and alternatives are all present.

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 a safe read-only, idempotent, closed-world operation, and the description adds material context beyond them: 'these tools never charge', 'Every purchase still needs human approval', capabilities outside constraints are 'reported as blocked, with the reason code', and 'do_not_recommend is a normal answer' (guarding against an agent retrying on a negative 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?

Well front-loaded: purpose, then when, then not-for, then input, then output. It is long and dense (the output enumeration and 'the four evidence kinds listed apart' are heavy), but nearly every clause carries routing or contract information, so the size is largely earned.

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 an 8-parameter tool with nested objects and no output schema, the description supplies the missing return contract (ak.evaluation.v1 fields, ak.offer.v1, blocked statuses and reason codes) and the money-estimate input combination. An agent has everything needed to call it and interpret the result.

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

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

Schema coverage is 100%, so the baseline is 3, but the description adds real meaning: model/expected_runs/baseline_cost_estimate_usd are jointly required 'for a money estimate', and omitting capability makes the registry weigh its closest matches rather than failing. That interaction logic is not visible in the schema. It does not, however, explain the context-keying or budget_policy precedence beyond the schema's own text.

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 (decide) and object (whether a registry capability is worth using or buying), and pins the scope to registry-run benchmarks only. The description explicitly differentiates itself from four named siblings, so an agent can route without opening any schema.

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

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

Contains an explicit 'Use when' clause plus a 'Not for' clause that names the alternative tool for each adjacent case: resolve_task for a bare answer, search_capabilities for a list, compare_capabilities for 2-5 candidates, estimate_roi for break-even without a task. It also clarifies the optional-capability branch (name one vs. let the registry weigh closest matches).

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 (readOnlyHint=true, idempotentHint=true, destructiveHint=false, openWorldHint=false), so the bar is lower. The description adds behavioral context beyond annotations: it labels publisher claims as 'PUBLISHER CLAIMED' and states 'publisher claims never decide anything', which is a decision-relevance caveat an agent would not infer from annotations. It does not describe empty-result or error behavior, but the added provenance-qualification is substantive.

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?

Front-loaded purpose, then Use when / Not for / Input / Output in compressed labelled segments, with no filler sentences. Each clause carries routing or format 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?

This is a read-only, openWorld=false, idempotent lookup with one required parameter and no output schema. The description supplies what is missing: the output type (ak.benchmark.v1), the elements of the evidence (paired runs, model, fixtures, method, limitations, attestations), and the publisher-claim caveat. Nothing an agent needs to call it correctly is absent.

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

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

Schema coverage is 100%, so baseline is 3, but the description adds accepted input formats ('a capability id, ak:// URI or slug') and, via the output line, signals the expected ak.benchmark.v1 shape. The schema already documents the id/URI/slug formats, so the incremental value over structured data is modest rather than large.

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?

Uses a specific verb+resource ('Registry-run benchmark summaries', 'publisher claims', 'signed attestations of one capability') and explicitly names the sibling tools it is not (evaluate_capability, get_provenance), so an agent can distinguish it without opening any schema.

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

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

The tool states an explicit 'Use when' condition ('you want the measurements behind an answer ... or want to check them yourself') and a 'Not for' exclusion, naming the two alternatives (evaluate_capability for task answers, get_provenance for artifact hashes and log proof). This is exactly the routing guidance an agent needs among 11 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 cover the safety profile (readOnly, idempotent, non-destructive, closed-world), so the bar is lower. The description adds useful content-level context by specifying the output resource type (ak.capability.v1) and the concrete fields returned, including the task-independent ak.offer.v1 offer. It stops short of noting pagination, caching or rate behavior, so it is good but not exhaustive.

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

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

Front-loads what the card is, then usage, then exclusions, then input, then output — a logical order with no filler. It is dense to the point of being a run-on paragraph, but every clause carries information an agent needs.

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

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

Although there is no output schema, the description compensates by naming the returned contract (ak.capability.v1) and its major field groups. Combined with fully covered input schema and rich annotations, an agent has everything needed to select and invoke this 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 coverage is 100%, so the accepted id/URI/slug formats are already documented, establishing a baseline of 3. The description goes beyond the schema by telling the agent where to source the value (from a search, an evaluation or a page), which is genuinely useful routing information not present in the structured 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?

Names a specific verb+resource (get a capability card) and enumerates exactly what the card contains: purpose, conditions, permissions, price, evidence, trust checks, links and an offer. It explicitly distinguishes itself from siblings by naming evaluate_capability and get_benchmark as the wrong choices.

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

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

Provides explicit 'Use when' conditions (you can name a capability and want its facts, or want to check conditions an evaluation asked about) and 'Not for' exclusions that route to the correct alternatives (evaluate_capability for a task answer, get_benchmark for full records). No inference is required.

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, non-destructive and closed-world. The description goes beyond that by specifying the output shape (ak.provenance.v1, RFC 9162 inclusion proof against the signed tree head, trust checks, keys URL), which is valuable context not in the annotations. However, since there's no output schema, this relies on prose to convey return structure, which it does adequately.

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?

Front-loaded with the output first, then usage, then exclusions, then input/output. Every clause earns its place; no redundancy.

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

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

Since there's no output schema, the description helpfully names the return format and key fields. Covers input formats and behavioral expectations. Minor gap: doesn't state what happens if the proof fails or if the capability is unknown, but overall complete for a read-only retrieval tool.

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

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

Schema coverage is 100%, so the schema already fully documents the single 'capability' parameter including accepted formats. The description repeats this ('a capability id, ak:// URI or slug') without adding syntax or validation details beyond the schema. Baseline 3 is correct.

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 (retrieves provenance for one capability) and enumerates what it returns: artifact hash, manifest hash, signed publisher and registry attestations, and a transparency-log inclusion proof. Distinguishes itself from siblings by explicitly ruling out get_benchmark and get_capability.

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?

Has explicit 'Use when' (verifying a package matches what the registry published and signed) and 'Not for' clauses naming the alternative tools get_benchmark and get_capability. Nothing is left 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 declare readOnlyHint=true and destructiveHint=false, so safety is already covered. The description adds rich context beyond annotations: 'It charges nothing; a purchase requires operator approval in the hosted checkout', the 15-minute expiry, signed claims bound to capability version, and that the price comes from the registry only. No contradiction.

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

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

Front-loaded with the core purpose, then Use when / Not for / Input / Output in a compact structure with zero waste.

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

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

Given no output schema, the description covers the return values (quote_id, signed claims, checkout link, unlock request). Combined with the behavioral and usage context, an agent has everything needed to call this 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 coverage is 100%, so the schema already documents both parameters including patterns. The description adds the semantic link (evaluation_id links quote to evaluation) but nothing about syntax or format beyond the schema. Baseline 3 is appropriate.

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

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

States a specific verb+resource with scope: 'signed 15-minute price quote with the hosted checkout link'. It names both the input and output artifacts, and distinguishes itself from siblings like evaluate_capability.

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

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

Explicit 'Use when' and 'Not for' clauses name alternatives (evaluate_capability) and the condition that selects them, including the free-capability case. This is the rare definition that fully routes the agent.

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

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

Annotations declare readOnlyHint=false and destructiveHint=false, so mutation and safety are largely covered; the description goes further by disclosing the storage label (AGENT REPORTED), that the report cannot alter trust/ranking, and that no task text is retained. It does not address the non-idempotent behavior (duplicate submissions) or any auth requirements, which is the remaining gap.

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

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

Front-loads the core semantics, then uses labeled 'Use when / Not for / Input / Output' segments. Every sentence carries information; there is no filler or repetition of the name.

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

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

With no output schema, the description compensates by describing the return (stored status, label, remedy policy for a failed paid capability), and the write semantics plus data-retention policy are stated. Minor gaps remain around idempotency/duplicate reports, but nothing blocks a correct call.

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% for 13 parameters, so the schema already documents every field. The description only groups them (required id/success; optional evaluation_id/purchase_ref links, token/tool-call/latency/cost counts, failure_reason with success false) without adding syntax, formats, or units beyond what the schema provides. 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 and resource (report an outcome for a capability) and immediately scopes it: 'Stored as AGENT REPORTED; it never changes evidence labels, trust or ranking.' The 'Not for' clause names the sibling tools that cover capability questions, so an agent can distinguish this from get_capability/get_benchmark.

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

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

Explicit 'Use when: you ran a capability, or decided not to, and can say whether the task succeeded' plus 'Not for: questions about a capability (get_capability, get_benchmark)'. Both the positive trigger and the exclusion with named alternatives are given, leaving nothing to inference.

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

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

Annotations already declare readOnly/idempotent/non-destructive/closed-world, so the safety profile is covered. The description adds real behavioral context beyond them: evidence is 'from registry-run benchmarks only', savings exist only for measured models, unknown fields are refused with the allowed list, and do_not_use/no_match are normal answers rather than errors. It stops short of stating latency, rate limits, or caching, but for a read-only resolver that is minor.

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?

Front-loaded with purpose and decision vocabulary, then when-to-use, exclusions, input and output in a fixed order; every clause carries information. It is dense and long for one paragraph, but little of it is waste.

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

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

No output schema exists, yet the description enumerates the ak.resolve.v1 payload (decision, capability id, reason codes, measured saving with interval, baseline estimate with break-even, confidence, evidence label, price, free alternatives, next action, evaluation_id, detail tool). Combined with the named inputs and constraint semantics, an agent has everything needed to call and interpret it.

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

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

Schema coverage is 100%, so the baseline is 3, but the description adds the enforcement behavior that the schema only implies ('any other field is refused with the allowed list') and groups the inputs as task + optional model/expected_runs/baseline_cost_estimate_usd/context/constraints. It doesn't add syntax beyond the schema, so it is a modest step above baseline.

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

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

States a specific verb+resource: turn a plain-language task into a single decision word about whether a registry capability is worth using. It names the exact answer vocabulary (use, do_not_use, use_free_alternative, insufficient_evidence, blocked_by_constraints, no_match), so an agent can tell it apart from search_capabilities or evaluate_capability without opening a schema.

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

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

Explicit 'Use when' clause (you have a task and no capability name, and want one decision word) plus an explicit 'Not for' clause naming three alternatives and the condition that selects each: evaluate_capability for the full arithmetic, search_capabilities for a plain list, get_capability when the capability is already named.

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/non-destructive, so the bar is lower; the description still adds real value by disclosing that results are ranked by lexical relevance only, never by payment, and that an earlier call is not required. It also pre-empts a likely misreading by stating the output is 'no decision'. It does not discuss pagination or result-set limits beyond the schema.

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

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

Dense but tightly organized into purpose, Use when, Not for, Input, and Output blocks, with the core action front-loaded. A few phrases are redundant with the schema (the 500-character restatement), but nothing is truly 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?

With no output schema present, the description compensates by naming the return type (ak.search.v1) and its fields, and it closes the loop by stating no decision is produced. Combined with the explicit routing guidance, an agent has everything needed to select and invoke this 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 query and limit are already documented in structured form; the description largely restates the 500-character query constraint and adds only the useful note that no prior call is needed. The limit parameter is not mentioned in the description at all. Baseline 3 is appropriate when the schema carries the parameter 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?

States a specific verb (Search) and resource (capability names, summaries, tasks, use-when conditions) with a stated ranking rule. It explicitly distinguishes itself from named siblings get_capability, resolve_task, and evaluate_capability, so an agent can route without opening any schema.

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

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

Contains explicit 'Use when:' and 'Not for:' clauses, each with the alternative tool to call instead (resolve_task, evaluate_capability, get_capability). The condition that selects this tool versus its siblings is fully spelled out.

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

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

Goes well beyond the annotations: states the purchase requires operator approval, that the download link expires in at most 15 minutes, and that repeating with the same key is safe and never charges (a richer, more actionable statement of idempotency than idempotentHint alone). It also explains key handling via the privacy page and that purchase_ref feeds report_outcome.

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?

Front-loads the core exchange action, then scopes usage and I/O in clearly separated clauses. Slightly dense, with one awkward fragment ('How the key is handled: the privacy page at /legal/privacy/.') and a redundant restatement of input already in the schema, but overall efficient.

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

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

With no output schema, the description names the return payload (signed entitlement, purchase_ref, download link) and its expiry, plus the approval prerequisite and idempotency behavior. An agent has everything needed to call it correctly in sequence.

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

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

Schema coverage is 100%, so the baseline is 3, but the description adds usage guidance beyond the schema by clarifying that quote_id and evaluation_id are supplied 'when you have them' and linking them to prior steps (quote, evaluation). This adds conditional/relational meaning the flat schema does not.

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 precise verb+resource: exchanging a checkout license key for a signed entitlement and a time-limited download link. It also explicitly contrasts itself with get_quote and free capability downloads, so an agent can distinguish it from siblings.

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

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

Contains explicit 'Use when:' (operator completed hosted checkout and gave the license key) and 'Not for:' clauses naming the alternative tool (get_quote) and the free-download path. Nothing about when to invoke is left to inference.

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