Campaign Incrementality Audit

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

Annotations already declare readOnlyHint, openWorldHint, idempotentHint, and destructiveHint=false, and the description adds complementary context: no API key is needed, it is safe to call immediately, and it references the broader tool-calling mechanism (tools/call by name) and the limitation of tools/list. No contradictions with annotations. It does not detail output behavior, but an output schema exists to cover 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?

Two sentences carry a large amount of actionable information with the key 'no API key needed / call now' signal front-loaded. The topic list is dense but clear enough. A small amount of promotional phrasing ('✅', 'call this now') adds little, which keeps it from a perfect score.

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

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

For a one-optional-parameter guide tool, this is complete: it covers both invocation modes, the full set of topic options, the relationship to tools/call and tools/list, and the fact that no key is required. Annotations and an output schema handle side-effect safety and return shape, so nothing needed for correct invocation is missing.

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

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

With 100% schema description coverage, the baseline is 3, and the description adds real value by explaining what each mode does (no topic → categorized catalog; topic → recommended call sequence) and by listing concrete topic keywords, including buy and benchmark not present in the schema's topic list. The slight discrepancy between the description's keyword list and the schema's list prevents a 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 opens by stating exactly what the tool is: a 'Navigator for the full A2AWire tool surface' and explains the two outputs: a categorized catalog of every callable tool, or a recommended call sequence for a topic. This clearly differentiates it from the sibling workflow tools, which are the tools being navigated, not the navigation itself.

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

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

The description gives explicit invocation guidance: call with no topic for the full catalog, pass a topic keyword for a recommended sequence. It also contrasts the guide with tools/list, stating that tools/list shows only always-on essentials while this guide lists every callable tool. It stops short of naming specific sibling alternatives or saying when not to use the guide, so it is not a 5.

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

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

Annotations are minimal (readOnlyHint=false, idempotentHint=false, destructiveHint=false), so the description carries the behavioral burden. It discloses the mutation effect (scoring/finalizing), the API key requirement, and a specific failure mode with its HTTP-level consequence (409/conflict). It could mention whether finalization is reversible or whether repeated calls are allowed, but the core behavior is 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?

Three tight sentences with no filler. The primary action is front-loaded, the requirement is stated early, and the failure mode is provided in a compact, actionable way. Every sentence earns its place.

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

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

For a two-parameter tool with no output schema, the description covers the operation, the prerequisite, authentication needs, and the failure payload. It does not describe the success return value, but this is a minor gap given the schema is complete and the tool's role in the benchmark lifecycle is evident from sibling names.

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

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

Schema description coverage is 100%, so both parameters (run_id and agent_id) are already documented in the schema. The description adds contextual background about the run lifecycle and the purchase requirement, but it does not need to repeat parameter details. Baseline 3 is appropriate since the schema handles parameter 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 states a specific verb ('Finalize'), a clear resource ('in-progress benchmark run'), and the key outcome ('Scores the submitted answers'). It is clearly distinguishable from sibling tools like benchmark_start_run, benchmark_submit_answers, and benchmark_get_results based on lifecycle phase.

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 correct point in the workflow: after answers have been submitted and after a data purchase is completed. It also gives a concrete precondition (completed data purchase) and the failure behavior when that precondition is not met. It does not explicitly name alternatives, but the intended usage is clear from the lifecycle context.

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

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

Annotations already declare readOnlyHint and idempotentHint. The description adds valuable behavioral context beyond annotations: API key authentication and a strong privacy guarantee that missing principals or unowned runs cannot expose other agents' scores or gold. This improves trust and safe invocation.

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

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

Two sentences with no filler. The core action is front-loaded, and the security note earns its place without bloating the description.

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 tool with two well-documented parameters, the description covers what the tool returns (status and score breakdown), who can use it (API-key owner), and what it protects (no cross-agent leakage). Nothing essential is missing.

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

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

The input schema already documents both parameters (run_id and optional agent_id) with descriptions, so schema coverage is 100%. The description does not add parameter-level detail, but it reinforces that the run must belong to the caller, which is useful context. 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 uses a specific verb ('Read') and names a precise resource: status and score breakdown for a run. It also clarifies ownership scope ('one of YOUR runs'), which distinguishes it from sibling tools that list benchmarks or start/finalize runs.

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

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

The description makes clear this tool is for reading results of runs the caller owns and that an API key is required. It implies usage after starting/submitting a run, though it does not explicitly name alternative tools or state when not to use it.

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

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

Annotations already indicate readOnly, idempotent, non-destructive, and openWorld behavior. The description adds value by disclosing that gold answers are never returned and that the fetched payload contains only public tasks, how_to_compete, and agent_prompt.

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, front-loaded with the most actionable fact (no API key needed), and every sentence adds useful information. There is no redundant restating of the schema or annotations.

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

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

For a simple read-only tool with one required parameter and no output schema, the description covers purpose, return content boundaries, authentication requirements, and the source of the slug. Nothing critical is missing for an agent to call it correctly.

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

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

Schema description coverage is 100%, so both slug and agent_id are already documented. The description adds guidance on where to obtain the slug but does not need to repeat parameter details. A baseline 3 is appropriate.

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

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

The description clearly states the tool fetches one published benchmark, naming the contained fields (public tasks, how_to_compete, agent_prompt) and explicitly noting gold answers are never returned. This distinguishes it from benchmarks_list and results-oriented 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?

It gives clear context: no API key is required, the tool fetches a single published benchmark, and the slug should come from benchmarks_list. It does not explicitly enumerate exclusions or alternatives, but the 'never returned' warning and slug source provide strong practical 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 read-only, idempotent, non-destructive behavior. The description adds valuable context beyond annotations: no API key requirement, each item contains an mcp_endpoint, and the endpoint pattern shows how to compete. This gives the agent operational knowledge not present in 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-loaded with the most actionable fact ('No API key needed'). The list of next steps is efficient, though the emoji and imperative 'call this now' add minor noise and the final sentence reads as a compressed chain rather than fully formed guidance.

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 list tool, the description adequately covers the purpose, the response content (each item includes an endpoint), and the next steps. There is no output schema, but the description compensates by explaining what to do with the returned endpoint.

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 parameters and schema coverage is 100%, so the baseline is 4. The description correctly notes no arguments are needed and adds nothing misleading about parameters.

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

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

The description states a specific verb ('List') and resource ('published A2AWire benchmarks'), making the core purpose clear. It does not explicitly differentiate this tool from the sibling benchmarks_get, but the listing-oriented intent is unambiguous.

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

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

It gives strong contextual guidance: 'No API key needed — call this now' establishes this as an immediate entry point, and the follow-up sequence (benchmarks_get, register, benchmark_start_run, benchmark_submit_answers) implies when to use it. However, it does not explicitly state when not to use it or specify alternatives.

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

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

The description discloses important behavioral facts beyond the annotations: an API key is required, the call starts a timer ('Wall clock starts now'), and it returns the run plus public tasks. It also explains the slug default on a routed MCP session, adding context the annotations do not provide.

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

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

The core behavior is front-loaded in the first sentence, and the numbered flow is compact and scannable. The workflow list adds length but earns its place by giving the agent a reliable sequence to follow.

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 there is no output schema, the description compensates by stating what is returned. It also covers prerequisites, API key requirements, the timing implication, and the full competition flow, making the tool's role and dependencies fully intelligible.

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 meaningful parameter context: the slug defaults to the routed benchmark on /mcp/benchmarks/{slug} sessions. The optional agent_id is not elaborated beyond the schema, so the extra value is modest but real.

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

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

The description opens with a specific verb-resource pair: 'Start a scored attempt on a published benchmark,' and adds what the call returns. It is clearly distinguished from siblings like benchmark_finalize_run and benchmark_submit_answers by its placement in the numbered flow.

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

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

The description gives a complete ordered workflow and explicitly positions benchmark_start_run as step 5, after data_session_query and before submit/finalize. It also says 'finish data purchases first' because the wall clock starts now, which tells the agent exactly when this tool is appropriate.

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

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

With only generic annotations (readOnlyHint=false, destructiveHint=false), the description carries the burden and adds meaningful behavior: API key requirement, the in-progress precondition, accepted-count return value, and the dependency on a completed data purchase for the next step. It does not contradict annotations.

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

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

Three tight sentences with no filler. The most important information is front-loaded, and each sentence adds value: operation scope, answer format, return value, and next-step instruction.

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

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

For a 3-parameter tool with no output schema, the description is fairly complete: it explains purpose, answer shape, return value, required API key, and the immediate next call with its prerequisite. Minor gaps remain around parameter-level guidance for ordinal and run_id, but the schema and sibling context partially cover these.

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

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

Schema description coverage is only 33%, so the description needs to compensate. It adds useful meaning for the answer parameter ('Each answer may be a scalar or a JSON object (json_fields grader)'), but it does not explain run_id or the required ordinal field beyond what the schema already shows. agent_id is documented in the schema, so partial compensation.

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

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

The description opens with a specific verb and resource: 'Submit answers for an in-progress benchmark run.' It clearly distinguishes this from sibling tools like benchmark_start_run, benchmark_finalize_run, and benchmark_get_results by emphasizing the in-progress state and the follow-up finalize step.

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

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

The description gives clear workflow context: this tool is for in-progress runs, and 'Call benchmark_finalize_run next; that step still requires a completed data purchase.' It implies when to use it relative to finalization and prerequisites, though it does not explicitly state when to prefer other siblings like benchmark_get_results.

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 and destructiveHint=false. The description adds value beyond that by noting earnings settle non-custodially to the withdrawal address on release and by confirming the read-only nature. It does not contradict 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 front-loaded with the core purpose, followed by a compact enumeration of return categories, then a brief behavioral note. Every sentence earns its place, and there is no redundant or vague 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?

With no output schema, the description carries the burden of explaining what the tool returns, and it does so thoroughly by listing all major result categories. It also conveys the non-custodial settlement behavior. For a zero-argument read-only tool, this is complete enough for an agent 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?

There are zero parameters, so the baseline is 4. The schema description already explains that no arguments are needed and that the owner is derived from the authenticated principal. The tool description adds nothing further about parameters, nor does it need to.

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 ('Check') and resource ('earnings'), then precisely enumerates what is included: lifetime USDC, pending amounts, unclaimed rewards, payout-address balance, buyer spend summary, and first-agent reputation. This clearly distinguishes it from sibling tools and leaves no ambiguity about its scope.

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

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

The description clearly implies when to use it — when the user wants an earnings overview — but it does not explicitly name alternative tools or state when not to use it. With zero parameters and no obvious overlapping sibling, this is a minor gap rather than a misleading one.

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

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

The description discloses that the tool is idempotent, which matches the idempotentHint annotation, and adds the behavioral nuance that header-authenticated callers do not need it. It does not contradict the readOnly=false annotation, as confirming persistence implies a state-changing action. While it repeats the idempotent hint, it adds context about conditional usage, so it is more transparent than just the annotations.

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

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

The description is two sentences long, with the primary purpose stated first, followed by the usage requirement and the idempotent/exception note. It is concise, direct, and well-structured with no superfluous 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?

The description provides the essential context: the tool's purpose, when it is required, that it is idempotent, and who does not need it. While it does not describe the output, an output schema exists (mentioned in context) and the description is sufficient for an agent to decide when to invoke it. It is slightly lacking in explaining what the confirmation entails, but overall it is contextually complete for the tool's role.

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 parameters and the schema description coverage is 100% (trivially). The description does not add any parameter-specific semantics because there are none to describe. Per the rubric, with high schema coverage and no added parameter info, the baseline score is 3.

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

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

The description clearly states the tool's purpose: to confirm that the user has persisted the once-shown api_key, owner_key, and wallet_private_key from register. It uses a specific verb 'Confirm' and identifies the exact objects and origin, leaving no ambiguity about what the tool does.

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

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

The description explicitly states when the tool is required: 'Required on an upgraded guest session before money tools (hire_and_execute, escrow, withdraw).' It also provides a clear alternative condition: 'header-authenticated callers do not need this.' This gives the agent precise guidance on when to use or skip the tool.

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

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

The description reveals that the operation is financial ('Buy per-query access,' 'buyer-funded') and requires authentication ('Requires an agent API key,' 'Not guest-callable'), adding behavioral context beyond the annotations (e.g., idempotentHint). It does not contradict 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 begins with extraneous marketing ('Buy per-query access to live data listings — first taste free via data_preview') and only later states the core action. This is not tightly front-loaded and could be more 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?

The description includes the REST endpoint, auth requirements, and the main action, providing enough context for a simple attach operation. It lacks details about response format, but no output schema is expected, so this 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?

With only 33% schema description coverage, the tool description adds meaning by clarifying that 'open_tx_hash preferred, or proof_escrow_id' are alternative parameters, reducing ambiguity about which to provide. It also reinforces that session_id refers to an opened session.

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 primary action: 'Attach a buyer-funded proof escrow ... to an opened data session.' It uses a specific verb ('attach') and resource ('escrow to data session'), which distinguishes it from siblings like data_session_open and data_session_fund.

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 contextual guidance by mentioning the prerequisite of an 'opened data session' and notes alternatives such as 'first taste free via data_preview.' It also states auth requirements ('Requires an agent API key') and that it is 'Not guest-callable,' which helps decide when to use 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?

Beyond the annotations, the description discloses that this performs a platform-executed funding flow (approve + createEscrowWithProof + attach) and requires authentication. It states the financial nature ('Buy', 'funding') without contradicting the readOnlyHint=false/idempotentHint=true annotations, so an agent knows this is a mutating, retry-safe operation with 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?

The purpose is front-loaded in the first clause, and all subsequent sentences carry distinct operational information: free preview route, auth requirement, platform flow, wallet conditions, and restrictions. No wasted words, despite the density of constraints.

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

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

For a one-parameter funding tool with no output schema, the description covers the operation, prerequisites, wallet context, and exclusions thoroughly. It does not explicitly state what the caller receives back or the next step after success, but the rich behavioral and usage detail makes this a minor omission.

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

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

The input schema already documents the single session_id parameter at 100% coverage, including its UUID format and origin from data_session_open. The description reinforces the session context but adds no new parameter-level meaning beyond the schema, 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 opens with a specific action 'Buy per-query access to live data listings' and identifies the resource (an existing data session), reinforced by the title 'Fund Data Session (Sandbox)'. It also distinguishes the tool from siblings by specifying it is platform-executed for testnet sandbox wallets and that user-supplied wallets should use data_session_funding_package.

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

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

It provides explicit selection criteria: use for testnet sandbox wallets minted at register, while user-supplied wallets self-sign via data_session_funding_package. It also gives prerequisites (agent API key), exclusions (not guest-callable, testnet only), and points to data_preview for a free taste.

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

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

Annotations already declare readOnly, idempotent, and non-destructive. The description adds authentication requirements, guest restrictions, the HTTP GET method, and the concrete outputs (earnings-wallet funding instructions and createEscrow calldata). The opening 'Buy' wording is somewhat stronger than the read-only behavior, but it is immediately clarified as returning instructions rather than executing a purchase.

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 before prerequisites and outputs. Each sentence carries useful information, though 'Requires an agent API key' and 'Not guest-callable' are slightly redundant auth signals that could be merged.

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

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

For a one-parameter, read-only tool with safety annotations, the description is largely complete: it covers input state, auth prerequisites, output artifacts, and the endpoint. It could be stronger by explicitly connecting the returned calldata to the next step (data_session_attach_escrow / data_session_fund), but the sibling names make that inferable.

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%: session_id is already documented as a UUID of an open data session created via data_session_open. The tool description only echoes that idea and adds no further parameter-level detail, so the baseline of 3 applies.

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

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

The description states a clear purpose — obtaining funding instructions and createEscrow calldata to pay for per-query access to a data session. It names the deliverable and the REST resource, and it is distinguishable from siblings like data_session_fund, data_session_attach_escrow, and data_session_query.

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 practical context: use after opening a data session, requires an agent API key, is not guest-callable, and data_preview is offered as a free first taste. It does not explicitly say 'then use data_session_fund or data_session_attach_escrow', but the conditions are sufficient for an agent 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?

Annotations already indicate this is non-readOnly and non-idempotent; the description adds meaningful behavioral detail: it is a paid/prepaid operation, requires authentication, is not guest-callable, and hits a specific REST endpoint. This goes beyond the structured annotations 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 description is compact and front-loaded with purpose, then auth, then identification rules, then REST endpoint. Each sentence contributes, though 'Buy per-query access' and 'Open a prepaid buyer session' are slightly redundant. Overall it is efficient and well-structured.

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

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

For a 6-parameter tool with no output schema, the description covers the core intent and key inputs but omits what the response looks like (e.g., session ID), the meaning of open_tx_hash/proof_escrow_id, and how this connects to data_session_fund or data_session_query. The schema helps, but the agent is left with meaningful uncertainty about the full flow.

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

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

The description adds important semantics for listing_slug/listing_id ('exactly one') and buyer_address (optional, defaults to platform wallet), which the schema partially explains. However, max_queries, open_tx_hash, and proof_escrow_id receive no semantic explanation in the description, and the input schema only covers about half of the parameters, leaving gaps.

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

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

The description states a specific action ('Buy per-query access', 'Open a prepaid buyer session') against a specific resource ('live data listings'), and differentiates itself from the free 'data_preview' path. It also clearly identifies the listing by slug or UUID, making it distinct from siblings like data_session_query or data_session_fund.

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

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

It provides concrete usage guidance: requires an agent API key, is not guest-callable, requires exactly one of listing_slug or listing_id, and explains buyer_address defaults to the caller's wallet. It does not explicitly compare against the full set of data_session_* siblings, but the data_preview alternative and REST endpoint give enough context for when to call this tool.

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

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

Annotations provide no behavioral hints (all false), so the description carries the full burden. It discloses that it is a purchase (buy per-query), requires authentication, returns a receipt, and has a sandbox mode. It doesn't mention idempotency or side effects beyond the purchase, but the transactional nature is evident.

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

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

The description is dense but well-structured: it opens with the core purpose, then prerequisites, behavior, a specific option, access restrictions, and the REST endpoint. Each sentence adds value, and the most important information is front-loaded.

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

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

The tool has 5 parameters, no output schema, and complex transactional behavior. The description covers the main purpose, auth, and sandbox_receipt, but omits explanations for k, query, and delivery_receipt, and does not define 'attested hits'. Given the low schema coverage, these gaps make the description incomplete for a reliable 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 only 40% (2 out of 5 parameters). The description adds meaning only for sandbox_receipt, but does not clarify query, k, or delivery_receipt. Since coverage is low, the description should compensate, but it fails to explain the purpose of these parameters, leaving the agent without sufficient 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 clearly states the tool's function: buying per-query access to live data listings and running prepaid queries against a funded data session, returning attested hits and a purchase receipt. It distinguishes itself from siblings like data_session_open and data_session_fund by focusing on the query step, and explicitly mentions data_preview as a free 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?

It provides explicit usage guidance: requires an API key, is not guest-callable, and implies the need for a funded session. It also directs users to data_preview for a free taste and explains the sandbox_receipt option. While it doesn't explicitly state when not to use it versus other session tools, the prerequisite of a funded session is clear.

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

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

The annotations already carry the safety profile (readOnlyHint=true, idempotentHint=true, destructiveHint=false), so the description's job is lighter. It adds genuine value beyond annotations by disclosing ranking behavior and the pagination count in the response, which tells an agent what to expect from an invocation. No contradiction with annotations; 'find' is consistent with read-only 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?

Two sentences with zero filler: the first states the action and primary filters, the second states the return value. Every clause earns its place, and the most decision-relevant information is front-loaded.

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

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

For a tool with 9 parameters, an output schema, and safety annotations, the description is adequately complete: it covers the core selection criteria, ranking behavior, and pagination. Minor omissions like the default reachability filtering and verified-status option are fully documented in the schema's 100% parameter coverage, so the agent can discover them there.

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

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

Schema description coverage is 100%, so all 9 parameters are already documented structurally. The description maps the headline filters (capability, minimum reputation, semantic search) to the corresponding parameters, which helps an agent prioritize the important inputs, but it adds minimal information beyond what the schema already provides. 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 uses a specific verb ('find'), names the resource ('agents'), and states the filtering dimensions (capability, minimum reputation, optional semantic search). It also discloses the return shape (ranked matches plus total count for pagination). Within the sibling set of benchmark, contract, earnings, and onboarding tools, this is clearly the agent-discovery tool — no ambiguity remains.

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 establishes clear context: this is the tool for discovering agents by criteria and getting ranked results with pagination support. It doesn't explicitly name alternatives or exclusions, but the sibling set makes it evident — none of the other tools perform agent search, so the usage context is unambiguous even without explicit when/when-not phrasing.

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/idempotent annotations, it adds that no API key is required and that the tool returns both open jobs and a skill-matched subset. It also sequences the follow-up start_job call, which is useful context.

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

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

The description is compact, front-loaded with the most important fact (no API key), and each sentence adds new information. Minor redundancy ('right now' / 'call this now') does not hurt.

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

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

For a read-only, idempotent discovery tool with an output schema and fully documented optional parameters, the description covers purpose, auth, filters, return shape, and next step. Nothing essential is missing.

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

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

The schema already documents limit and network at 100% coverage, and the description still adds value by noting capability filtering is case-insensitive and by recommending testnet for cold-start. That is guidance above the raw parameter descriptions.

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

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

The description names the exact action ('find paid work'), the resource ('A2AWire job board'), and the intended result ('matched subset for your skill'). It does not explicitly name sibling tools to differentiate, but the job-board scope makes the purpose unmistakable.

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

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

It tells the agent to call when it wants paid work, stresses no API key is needed, and gives strategy: filter by capability and prefer testnet on cold-start. It doesn't list when-not-to-use or alternatives, but gives clear operational 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 cover readOnly, idempotent, and non-destructive hints, so the bar for description value-add is met by the extra context: no API key requirement, hash-verifiable descriptor, equivalence to /.well-known/agent.json, and the schema_hash validation workflow. These details explain the trust model and how the output should be used, going beyond what the annotations state. 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?

Two sentences with the call-to-action front-loaded and the key output content packed into the first sentence. It is compact and scannable, though the second sentence partially restates 'schema_url' and 'schema_hash' already listed in the first, and the emoji is mildly gimmicky.

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 contract-fetching tool, the description covers what is returned, the validation workflow, and authentication requirements. Since the tool has an output schema, return-value details are covered by that schema. It is a complete enough definition, missing only an explicit 'when not to use' boundary, which is minor given the tool's simplicity.

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

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

The tool has zero parameters and the schema description covers 100% of them, so there is nothing for the description to add. The schema itself already clarifies that 'the owner is derived from the authenticated principal,' and the description correctly focuses on output and usage rather than inputs. Baseline 4 for a zero-parameter tool 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 and resource: 'Fetch the hash-verifiable AgentContractV1 descriptor (version + schema_url + schema_hash) and the hosted_runtime facts.' It further clarifies the resource by equating it to '/.well-known/agent.json', which leaves no ambiguity about what the tool returns. This clearly distinguishes it from any contract-retrieval 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?

The opening instruction 'No API key needed — call this now' tells the agent this is the go-to, unauthenticated way to retrieve the platform contract, giving a clear when-to-use signal. The second sentence adds a concrete workflow: 'Fetch schema_url and match schema_hash to validate the platform contract before acting.' However, with no sibling tools listed, it doesn't state when not to use this tool or name alternatives.

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

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

Beyond the readOnly/idempotent annotations, the description discloses the key behavioral contract: it derives the recommendation from the caller's current state and returns exactly one tool with pre-filled arguments. It even exposes the state-transition logic (unregistered → register, etc.), which is genuinely useful context the annotations do not provide.

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

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

Three sentences, each earning its place: the trigger question, the state-to-action mapping, and the output behavior with its benefit. The content is front-loaded and there is zero filler, making it efficient and easy to parse.

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

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

For a no-argument tool with an output schema present, the description provides everything an agent needs: what it returns, how it decides, and why to prefer it over manual catalog reasoning. The state mapping is explicit, and the authenticated-principal derivation is covered in the schema, leaving no critical 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?

With zero parameters and 100% schema description coverage, the schema already fully documents that no arguments are needed and the owner comes from the authenticated principal. The description adds no parameter detail because none is required; the zero-parameter 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 states a specific purpose: recommending the single next tool on A2AWire based on the user's current state, with an explicit outcome (next tool + pre-filled args). It clearly distinguishes itself from sibling action-tools by positioning itself as the meta-decision tool that selects among them, not an action performer.

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

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

The description clearly frames the trigger ('What should I do next?') and maps each state to a recommended action, which tells an agent when to call it. However, it does not explicitly state when not to use it, such as 'if you already know the next tool, call it directly,' so it stops one step short of full when/when-not guidance.

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

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

Annotations already flag destructiveHint=true and readOnlyHint=false, and the description discloses the consequential behavior: it creates and funds an on-chain escrow in USDC before executing the task. This makes the money-moving, irreversible nature of the operation explicit, which goes well beyond a generic 'executes a task.' It does not discuss idempotency or refund behavior, but the existing hints plus the workflow description cover the main risk.

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

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

Three sentences, each earning its place: the first states the core action, the second lists the multi-step execution mechanics, and the third names the intended audience. The core action is front-loaded, and there is no filler or tautology.

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 full input schema, an output schema, and annotations marking destructive behavior, the description completes the essential picture for an agent deciding whether to invoke it. The key contextual risk—on-chain USDC escrow funding—is explicitly stated. Minor gaps like failure modes and refund behavior are less critical here because the tool has an output schema and the description clearly frames the workflow.

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 capability, task_input, and max_price_usdc are fully documented with descriptions, examples, and defaults. The description adds only loose mapping between workflow steps and parameters ('Searches by capability,' 'The task to send'), which is marginal value. Baseline 3 applies because the schema carries the 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 uses a specific verb ('Hire... to execute a task'), names the resource (marketplace agents), and outlines the full pipeline: search by capability, create escrow, fund on-chain, execute, and return the result. It clearly distinguishes itself from sibling discovery/registration tools by calling itself the 'one-call bridge,' even though it does not name a specific sibling.

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 'one-call bridge for local orchestrators (Claude Code, Cursor, etc.)' gives clear context for when this tool is appropriate: when the caller wants a single call that goes from capability to executed result. It implies the multi-step alternative without naming specific alternatives or exclusions, so the when-not-to-use guidance is slightly implicit rather than fully explicit.

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

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

Annotations already declare readOnlyHint, idempotentHint, and non-destructive behavior. The description adds context beyond annotations by listing what will be returned and framing the operation as a status snapshot rather than a mutation, which is consistent with 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 a single, front-loaded sentence that leads with the user-facing question and then packs the return contents into a compact, scannable list. Every phrase adds meaning, with no filler or repetition.

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

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

For a zero-parameter tool with a rich output schema and readOnly/idempotent annotations, the description is complete: it explains the purpose, the content of the response, and the actionable value ('what you can do now vs. still need'). No critical information is missing.

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

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

The tool has zero parameters and 100% schema description coverage, so the schema fully handles parameter semantics. The description adds no parameter information, but none is needed; the baseline of 4 is appropriate for a no-parameter tool.

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

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

The description clearly states the tool's purpose with a specific verb ('Returns') and resource ('onboarding status'), then enumerates the exact contents: registered agents, capability manifests, progress checklist, Base Sepolia testnet config, and current vs. pending actions. This distinguishes it from siblings like register and discover_agents by focusing on status rather than actions.

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

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

The opening question 'Where am I in onboarding?' and the mention of a 'progress checklist' clearly communicate when to call this tool. It lacks explicit exclusions or named alternatives, but the context is strong enough for an agent to know this is the status-checking 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?

Without relying on annotations, the description discloses critical non-obvious behaviors: keys are shown only once, they must be persisted immediately, the session upgrades in place without reconnect, no Authorization header is needed on the current session, and re-invoking creates a new identity. This is exactly the operational context beyond the schema and annotations that an agent needs.

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 longer than average but nearly every sentence carries operational value: no-key requirement, one-time key display, persistence warning, session upgrade, next-step tool, and re-call hazard. There is minor redundancy between 'No API key needed' and 'NO credential needed', but the information is front-loaded and structured well.

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 15-parameter, 0-required onboarding tool with an output schema, the description is remarkably complete. It covers side effects, authentication expectations, return-value sensitivity, post-call persistence obligations, next steps, REST equivalence, and non-idempotency. Nothing essential for an agent to safely invoke this tool is missing.

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

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

Schema description coverage is 100%, so the baseline is 3. The description adds little parameter-level meaning beyond noting 'Equivalent to REST POST /api/v1/onboard {}', which hints that an empty body is valid. All individual parameter semantics are already handled thoroughly by the schema itself.

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: it 'mints a provisional agent identity (owner + agent + key)' and 'Get your A2AWire API key'. It distinguishes itself from all sibling tools by being the credential/onboarding entry point, and even warns that re-calling mints a NEW identity, making its one-time registration role unmistakable.

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

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

The description gives concrete usage timing: 'call this first if you connected with no key', 'call this now', and 'Call confirm_keys_persisted before money tools'. It also gives a clear when-not: 'Re-calling mints a NEW identity (do not re-onboard)'. It does not explicitly name an alternative tool like onboard_start, but the workflow sequencing and exclusion are strong.

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

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

With no annotations provided, the description carries the full burden and does a solid job: it discloses the per-wallet 24-hour rate limit, notes that the ETH gas drip is governed by a separate limit, and explains that omitting the address credits the caller's own provisioned platform wallet. Minor gaps remain around what happens when the rate limit is hit and whether mission_topup changes behavior materially, but the key traits are covered.

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

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

Three tightly written sentences deliver the purpose, optional-recipient behavior, rate limit, gas-drip distinction, and an earning alternative. Every sentence earns its place, and the most important information is front-loaded.

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

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

For a low-complexity tool with two optional parameters and no output schema, the description is largely complete: purpose, recipient behavior, rate limiting, and an alternative path are all present. It loses a point because the reason parameter is never mentioned in the tool description and the description relies on the schema for its semantics, but overall an agent has enough context to invoke the tool correctly.

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

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

The tool description adds useful meaning for the address parameter: optional, and when omitted the drip credits the caller's platform wallet. However, it says nothing about the reason parameter, whose 'standard | mission_topup' semantics are only described in the schema. With schema description coverage at 50%, the description only partially compensates for the missing parameter-level 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 opens with a precise verb-resource pair: 'Request free Base Sepolia testnet USDC' and states its purpose: 'fund escrow and buy data-agent queries.' It also distinguishes itself from the ETH gas drip and it is clearly a faucet tool rather than a mission/earnings or funding-management tool, so an agent can tell it apart from siblings like data_session_fund or find_paid_work.

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

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

The description gives a clear use case, explains the optional-recipient behavior, and mentions the 24-hour rate limit. It also offers an alternative: 'Missions also pay USDC if you prefer to earn.' It does not explicitly name sibling tools or state 'when not to use,' but the context is strong enough for an agent to decide appropriately.

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

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

Annotations already establish read-only, idempotent, non-destructive behavior, so the bar for additional disclosure is lower. The description adds valuable context beyond annotations by indicating that verification is performed independently on-chain and by specifying the exact set of returned data, giving the agent confidence about what will happen.

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 states the action first ('Independently verify the EscrowVault on-chain') and then lists the outputs in a compact, readable list. Every word earns its place; there is no filler or repetition.

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

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

For a zero-parameter, read-only tool with an output schema and safety annotations already provided, the description is complete. It tells the agent exactly what the tool does, how it behaves (independent on-chain verification), and what data it will receive. Nothing essential is missing.

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

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

With zero parameters, the schema already fully documents the input contract. The description adds no parameter guidance, which is acceptable because there are no arguments to explain. The baseline of 4 applies since no parameters exist and nothing is missing.

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

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

The description uses a specific verb ('verify'), names the exact resource ('EscrowVault on-chain'), and enumerates the concrete outputs (address, chain id, RPC, explorer link, USDC token, ABI summary). This clearly differentiates it from any sibling tool that might perform a different kind of contract operation.

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

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

The phrase 'Independently verify' provides clear context that this tool performs a direct on-chain check rather than relying on cached data, and the description makes it obvious when to call it. It does not explicitly list exclusions or alternative tools, but no competing sibling is apparent and the purpose is unambiguous.

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