New MCP Server Directory (Agent Tools Index)

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

Annotations already declare readOnlyHint=true, idempotentHint=true, destructiveHint=false, openWorldHint=true, so the safety profile is covered. The description adds the behavioral fact that no API key is needed and that it returns a catalog or recommended call sequence. It doesn't explain the exact response structure beyond one-liners and sequences, but with an output schema present, that burden is lower.

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 'no API key' call-to-action, and packs a lot of useful behavioral guidance in a few sentences. Some redundancy exists between the description's topic keyword list and the schema's list, and the trailing garbled text in the schema description ('..returns the recommended call sequence for that flow') is not part of the main description, so no penalty for that. The main description is slightly dense but 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?

Given a single optional param, 100% schema coverage, rich annotations, and an output schema, the description is nearly complete. It explains the two calling modes, the keyword vocabulary, and the relationship to tools/call and tools/list. Minor gap: the schema description omits 'benchmark' from the keyword list while the main description includes it, which could cause an agent to miss that option. Also the description does not state what content the catalog entries contain beyond name + one-liner, but the output schema likely covers that.

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

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

Schema description coverage is 100% and the schema already documents the 'topic' parameter with a clear enum-like list in the description and default null. The description adds the same keyword list from the tool description and lightly maps topic to 'recommended call sequence.' But it fails to include 'benchmark' despite the main description mentioning it, creating a minor inconsistency in the parameter semantics.

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

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

The description states a specific verb ('call this now', 'navigator') and a clear resource: the A2AWire tool surface. It distinguishes itself from sibling tools by being a meta-tool that catalogs other tools with one-liners and recommended sequences. The 'Call with no topic for the categorized catalog' phrase clarifies the main use.

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 explains when to call it with no topic vs. with a specific topic, provides an enumerated list of topic keywords, and tells the agent that all listed tools are callable via tools/call by name — which directly addresses when to use this tool vs. invoking a specific sibling. Also notes tools/list shows only always-on essentials.

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, and the description agrees with them. It adds value by explaining that earnings settle non-custodially to the withdrawal address on release and by distinguishing released/claimable amounts from in-flight/unclaimed ones. 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?

Two sentences, front-loaded with the core purpose and no filler. The long second sentence is justified because there is no output schema and the return categories need to be listed for the agent.

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

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

For a zero-parameter, read-only summary tool, the description is nearly complete: it identifies the caller, lists the return quantity, and states the settlement behavior. It stops short of 5 because a few categories such as 'buyer spend summary' and 'first-agent reputation' are not elaborated, and no alternative tool is cross-referenced.

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 coverage, the schema already fully defines invocation. The description still adds contextual meaning by framing the implicit authenticated principal as the seller and clarifying what counts as 'earned'.

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 ('Check') and resource ('earnings'), then enumerates the exact return categories: lifetime seller USDC, pending amounts, claim-later rewars, payut balance, buyer spend, and reputation. This clearly distinguishes it from mission, policy, and profile tools by centering seller earnings and settlement status.

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 line makes the invocation context explicit: use this when the user asks about earned and pending amounts. It does not name alternative tools or state when not to use it, so it falls just short of a 5, but the intended use is unambiguous.

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

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

Annotations already establish readOnly, idempotent, and non-destructive behavior, so the meaningful additions are 'No API key needed' and 'max 20 queries/session'. These are useful operational traits. However, the text mixes 'Price 0.01 USDC/query' with 'FREE preview — no key, no payment', creating ambiguity about whether a call actually costs money, and it does not describe what the response contains.

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 promotional blurb rather than a structured tool specification. It repeats the 'no key / no payment / free preview' idea multiple times and buries the technical purpose under emojis, pricing, and sample questions. It is short, but not efficient for an agent to parse into actionable behavior.

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 zero required parameters, it does communicate free/no-auth access and gives sample questions, which is helpful. However, it omits what the response looks like and how slug/question affect results, and the 'Price' vs 'FREE' statements are confusing. With no output schema, these gaps are more significant.

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 covers both parameters 100% with descriptions: slug defaults to the routed session's listing and question is echoed back. The sample questions add illustrative examples for the question parameter, but no extra semantics for slug are provided. With high schema coverage, the description does not need to repeat parameter details.

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 frames the tool as a 'FREE preview' of a 'New MCP Server Directory (Agent Tools Index)' and provides sample questions, so the general resource and action are inferable. However, it never explicitly states that the tool returns preview listing data for a slug/question, and it does not distinguish data_preview from siblings like data_session_query or discover_agents. The marketing tone obscures the operational meaning.

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 says 'No API key needed — call this now' and 'FREE preview — no key, no payment', which gives some sense of when calling is cheap or safe. But it provides no explicit guidance on when not to use this tool or which sibling tools should be used for full data access or session queries. The imperative 'call this now' is promotional rather than a decision rule.

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, destructive, and idempotent hints. The description adds useful behavioral context: API-key authentication via Bearer or X-API-Key, guest-call restriction, and the preference for open_tx_hash over proof_escrow_id. Nothing in the description contradicts 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 compact and front-loaded with the value proposition, followed by auth, mechanics, and endpoint. Every sentence contributes information, though 'Not guest-callable' and the API-key requirement are mildly overlapping.

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 payment/escrow attach operation with no output schema, the description covers the main invocation facts: endpoint, required session context, escrow identifier choice, and auth. It does not explain how the buyer-funded escrow is created or what a successful response returns, but annotations supply the idempotency/safety profile.

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 must compensate for open_tx_hash and proof_escrow_id. It does this by identifying them as alternative escrow references and stating that open_tx_hash is preferred, which is not inferable from the bare schema. It could go further by saying where these ids come from, but the core semantic is present.

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

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

The description states the operation explicitly: 'Attach a buyer-funded proof escrow ... to an opened data session,' and gives the REST endpoint. It also positions the tool against free access via data_preview, making its role in the data-session workflow clear.

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

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

It establishes a clear precondition: the data session must already be open, and the escrow must be buyer-funded. It also directs free first tastes to data_preview and notes that guest calls are not allowed. It does not explicitly contrast with the sibling data_session_fund tool, so a small usage gap remains.

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 this is a paid action (0.01 USDC/query) and that the platform executes funding, which goes beyond the raw annotations. It does not contradict the idempotent or non-destructive hints.

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

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

The description is short and front-loaded with the core purchase action, and the cost and follow-on query tool are included without fluff. The 'Listing:' fragment is a bit awkward but every sentence contributes useful context.

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

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

For a single-parameter paid action the core details are present: cost, free preview alternative, and the resulting query capability. It is less complete regarding the escrow/funding-package siblings, failure behavior, and what platform-executed funding actually entails.

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 for the single session_id parameter is 100%, and the schema already states it is the UUID returned by data_session_open. The description adds no new parameter semantics, so the baseline 3 applies.

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

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

The description clearly identifies the action as buying per-query access to live data listings and names the related data_preview and data_session_query flow. It does not explicitly contrast with sibling tools like data_session_funding_package or data_session_attach_escrow, so it earns a 4 rather than 5.

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

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

It implies the intended order: try data_preview free, fund the session, then use data_session_query. However, it gives no explicit when-not-to-use guidance and does not explain how this differs from data_session_funding_package or data_session_attach_escrow.

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 mark it read-only and idempotent, and the description strengthens this by saying it 'Returns fund instructions' rather than actually executing a transaction. It also discloses the cost per query. No contradiction with annotations; the readOnlyHint is consistent because the tool provides instructions, not a purchase execution.

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

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

Three short, information-dense sentences with no filler. The primary action is front-loaded, and the listing, price, preresuisite, and return behavior are all stated efficiently.

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

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

For a single-parameter tool with no output schema, the description covers the purpose, prerequisite session, return type ('fund instructions'), pricing, and free alternative. It does not describe the exact structure of the fund instructions, but that gap is minor relative to 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?

Schema coverage is 100% and the session_id parameter is already fully described as a UUID from data_session_open. The description adds no new parameter-level details beyond the workflow mention, so the schema carries the burden and the baseline 3 applies.

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

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

States a specific action ('Buy per-query access') and resource ('live data listings'), then names the exact listing being purchased. It also distinguishes itself from siblings by referencing data_preview and data_session_open in the workflow, so an agent can tell it apart.

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?

Gives clear sequencing context: use after data_session_open, and that free access is handled by data_preview. It does not explicitly say 'do not use data_session_fund' or list all alternatives, but the workflow hint is strong enough for correct tool selection.

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

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

Annotations only indicate a non-read-only write; the description adds meaningful behavioral context: the cost per query, the max 20 queries/session, and the prepaid/payment flow. It also implies a mutating, financially relevant action without contradicting the readOnlyHint=false flag.

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: the first clause states what the tool does, and the pricing/listing detail earn their place. Only minor ambiguity around 'Buy... access' versus the likely 'open session' action 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?

With five parameters, no output schema, and no parameter-level documentation, the description is too thin on outcome details. An agent cannot tell what a successful open returns, which fields are required for the payment/escrow flow, or how to use the returned session. It orients the workflow but not enough for reliable invocation.

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

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

Schema coverage is 0%, so the description must compensate for parameter semantics. It does not explain listing_id, buyer_address, open_tx_hash, proof_escrow_id, or the relationship between max_queries and the stated per-session cap. It adds high-level context about per-query billing but leaves required and optional fields largely to inference.

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 ('Open a prepaid session'), the resource ('live data listings'), and even the specific listing. It clearly separates this from the free data_preview and from later steps by saying 'then fund and 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?

The description tells the agent when to use data_preview instead ('first taste free via data_preview') and positions data_session_open as the first paid step: 'Open a prepaid session, then fund and query.' It does not explicitly enumerate all sibling alternatives, but the workflow is clear enough.

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 a non-read-only, non-idempotent, non-destructive operation; the description adds valuable context on top: each call costs 0.01 USDC, is capped at 20 queries/session, and requires prior open+fund steps. Failure/refund behavior and receipt-signing side effects are not disclosed, but the costly-and-metered nature is clearly conveyed.

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

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

Three tight sentences, each earning its place: the core action, the pricing/limits, and the required calling sequence. The most decision-relevant facts (paid, preview alternative, prerequisites) are front-loaded with zero 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?

For a 5-parameter tool with no output schema, the description covers the commercial model and prerequisite flow well, but leaves gaps: parameter semantics for k/delivery_receipt, what the response contains, and behavior on failed or unfunded queries. Adequate for the happy path, incomplete for a new agent that must 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?

Schema description coverage is only 40%, so the tool description carries the burden of explaining the undocumented parameters (query, k, delivery_receipt). It does not: nothing explains what the query string should contain, what k controls (result count), or what delivery_receipt/sandbox_receipt mean functionally. The only parameter-related hint is the word 'query' in the name and sequence.

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 to live data listings') and is reinforced by the schema description 'Run a prepaid query against a funded data session.' It names the exact listing, price, and per-session limit, and explicitly distinguishes itself from the free data_preview sibling and the data_session_open/data_session_fund steps in the sequence.

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 when-to-use context: use data_preview for the free first taste, then follow the explicit sequence data_session_open → data_session_fund → data_session_query. It does not exhaustively state when not to use the tool or name alternative tools for edge cases (e.g., unfunded session recovery), so it falls just short of a 5.

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

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

Annotations already cover read-only, idempotent, and non-destructive behavior. The description adds that results are ranked and include a total count for pagination, which is useful output behavior, but it does not explain ranking criteria or edge cases such as the unreachable-agent default.

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 action and primary filters are front-loaded, and the output/pagination note is 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?

With a rich schema, output schema, and safety annotations, the description is sufficient for an agent to understand the tool's role. It could add one sentence about when to use discovery versus task-specific actions, but nothing critical is missing for invoking it.

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

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

Schema description coverage is 100%, so the baseline is 3. The description restates capability, min_reputation, and query/search but adds little beyond the schema, and the schema already documents all nine 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 names a specific action ('Find agents') and resource, and identifies three key filtering dimensions: capability, minimum reputation, and optional semantic search. It does not explicitly differentiate from sibling tools like find_paid_work or get_recommended_action, so it falls short of a 5.

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

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

The description implies the use case: discovering agents by filters or semantic search. It does not explicitly state when to prefer this tool over siblings, nor does it list exclusions or alternative tool names.

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

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

Annotations alrady provide readOnly/openWorld/idempotent/hon-destructive, so the bar is lower. The description adds valuable behavior: no API key needed, returns a matched subset, case-insensitive filtering, and network preference. 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?

Three sentences, highly scannable, with the most urgent info ('No API key needed — call this now') front-loaded. Every sentence adds either action, filtering, or nex-step value with no fluff.

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

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

For a read-only lookup tool with an output schema, this is complete: it gives auth status, input guidance, output nature, and the next-step tool. Nothing an agent needs to invoke it correctly 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 coverage is 100%, so baseline is 3. The description extends this by adding case-insensitivity for capability and framing network selection as a cold-start preference, which helps an agent choose values beyond the schema's enumerations.

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 concrete action ('Find paid work') with a specific resource (A2AWire job board), the return value (open jobs plus matched subset), and the follow-up (start_job). This distinguishes it from generic discovery tools like discover_agents.

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?

Gives clear when-to-use guidance: 'No API key needed — call this now' and 'prefer testnet for cold-start'. It also names the next step (start_job) and filtering principles, though it doesn't explicitly describe alternatives or when-not-to-use scenarios.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true, and destructiveHint=false, and the description adds meaningful context beyond them: no API key required, hash-verifiable descriptor, and equivalence to the well-known agent.json endpoint. This gives the agent safety and provenance expectations without contradicting annotations.

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

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

The description is compact and front-loaded: the immediate 'No API key needed — call this now' signal is followed by a precise list of the fetched fields and a validation instruction. Every sentence carries actionable information with no filler.

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

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

For a zero-parameter, read-only, idempotent tool with an output schema and strong annotations, the description is complete. It tells the agent what data to expect (descriptor fields + hosted_runtime facts), where this data comes from, and how to validate the schema_hash before acting.

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 input schema fully documents this with 'No arguments — the owner is derived from the authenticated principal.' The description adds the auth-related context that no API key is needed, slightly reinforcing the parameter story. Baseline 4 for zero-parameter tools is appropriate.

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

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

The description clearly states the tool's function: fetch the hash-verifiable AgentContractV1 descriptor (version, schema_url, schema_hash) and hosted_runtime facts, equivalent to /.well-known/agent.json. It does not explicitly name or contrast sibling tools, so it stops short of full 5-level differentiation.

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

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

The description gives strong contextual guidance: 'No API key needed — call this now' and instructs to use it before acting to validate the platform contract. It does not mention explicit alternatives or when-not-to-use conditions, but the 'call this now' framing clearly positions it as the first read-only step.

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

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

Annotations already declare the tool read-only, idempotent, and non-destructive. The description adds genuinely useful behavior beyond that: it returns a single recommended tool, includes pre-filled args, and derives the recommendation from the current user state. This gives the agent a clear model of what the call will produce without contradicting the annotations.

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

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

The description is compact and front-loaded with the core question and purpose. Its state-transition parenthetical packs significant value into a short space. Slightly dense, but every clause earns its place, making it efficient rather than bloated.

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

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

Given the zero-parameter input, rich annotations, and the presence of an output schema, the description covers the essentials: what it does, when to use it, and what it returns (single tool + pre-filled args). It doesn't explain edge cases like invalid user state, but for a simple recommendation router this is a minor 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 ('No arguments — the owner is derived from the authenticated principal'), there is no parameter burden for the description to carry. The description adds no param-level detail, but none is needed; the baseline of 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 starts with a direct question and answer: 'What should I do next on A2AWire?' It names a specific verb ('get recommendation'), a specific resource (next action), and states the output is a single tool plus pre-filled args. This clearly distinguishes it from the broader tool catalog, so an agent can tell what it does without opening the 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 description gives explicit conditional routing ('unregistered → register; unverified → start admission; verified → accept matching paid work or explore the board'), which tells an agent precisely when to call it. It also frames it as a way to avoid reasoning over the full catalog. It stops short of naming sibling alternatives explicitly or saying when not to use it, so it loses one point.

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 key behavioral traits beyond the annotations: it creates escrow, funds it on-chain with USDC, executes the task, and returns the result. This meaningfully explains the expensive/mutating nature of the call and matches destructiveHint=true.

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

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

Two sentences, front-loaded with the core action, and every sentence earns its place. The one-call bridge context is concise and distinguishes the tool without redundancy.

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

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

Given the financial side effects and complexity, the description covers the full pipeline, return of results, and target audience. It doesn't explicitly describe failure/refund behavior or the price ceiling, but the schema already documents max_price_usdc and the output schema exists, so the definition is sufficiently complete.

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

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

Schema description coverage is 100%, so the baseline is 3. The description adds no per-parameter detail beyond the schema; it just says it searches by capability and sends the task. The extra context about price ceiling comes from the schema, not the description.

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

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

The description names a specific verband resource: 'Hire an agent from the marketplace to execute a task.' It also lays out the full workflow (search, escrow, funding, execution, result) and positions itself as the one-call bridge, which differentiates it from granular sibling tools like discover_agents and data_session_open.

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

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

The description states when to use it: for local orchestrators like Claude Code and Cursor that want a single call into the marketplace. It doesn't explicitly list alternatives or when-not-to-use cases, but the context is clear enough to guide selection away from the multi-step sibling tools.

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

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

Annotations already declare readOnlyHint, idempotentHint, and destructiveHint=false, covering the safety profile. The description adds useful behavioral context: what the tool returns and the fact that it tells the agent what it can do now versus what is still needed. No contradictions.

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

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

The description is one compact, front-loaded sentence that conveys the tool's value proposition and key outputs without padding. The question opening is engaging and immediately orienting; every clause adds meaningful information.

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

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

For a zero-parameter, read-only status tool with an output schema and complete annotations, the description is fully sufficient. It enumerates the major return categories and the progress-related decision aid, so an agent knows exactly what to expect and can decide whether to call it.

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

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

The tool has zero parameters, so the baseline is 4. The schema already explains that no arguments are required and the owner is derived from the authenticated principal. The description correctly says 'your' to indicate the authenticated owner, which is sufficient.

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

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

The description uses a specific verb ('Returns') and a clear resource: onboarding status, including registered agents, capability manifests, progress checklist, and testnet config. The question phrasing frames the tool's purpose unmistakably, and it stands apart from siblings because nothing else addresses onboarding status.

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?' clearly signals the intended use case. It does not explicitly mention when not to use it or name an alternative tool, but the context is strong enough for an agent to recognize the right moment to invoke it.

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

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

Annotations already establish that this is not read-only, not idempotent, and not destructive; the description adds useful context that the call is free and wallet-free. However, it does not disclose side effects like creating an owner identity, provisioning keys, or what happens on repeated calls.

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

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

The description is one front-loaded, readable sentence that puts the urgent action and key constraints first. Some redundancy exists in 'Free — no wallet needed' and the emoji-heavy tone, but it does not harm comprehension.

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

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

Given the rich input schema, output schema, and 15 optional parameters, the description supplies the main missing context: why to call register, that it costs nothing, and that it unlocks purchase functionality. It could be stronger by addressing the relationship to onboard_start and explicitly noting that an empty call is valid, though the schema already says that every field is optional.

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

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

Schema description coverage is 100%, and all 15 parameters are optional with detailed descriptions in the schema itself, so the description does not need to repeat parameter details. The tool description adds no parameter-specific guidance, which is acceptable under the baseline.

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

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

The description clearly states the tool's purpose: calling register unlocks purchase tools and requires no API key or wallet. It is specific enough for an agent to recognize this as the onboarding/API-key tool, though it does not explicitly differentiate it from the sibling onboard_start.

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 concrete usage trigger: 'call this now' to unlock purchase tools, with clear context that no API key or wallet is needed. It does not state when not to use the tool or mention alternatives such as onboard_start.

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 readOnlyHint, idempotentHint, and non-destructive behavior, so the description does not need to repeat safety. It adds value by describing the independent on-chain verification nature and the specific output fields, helping the agent anticipate the tool's behavior. No contradictions exist.

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

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

The description is a single dense sentence that front-loads the primary action ('verify') and then efficiently lists all key return components. Every clause earns its place; there is no filler or repetition of schema content.

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

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

For a parameterless, read-only tool with a rich output schema and clear annotations, the description covers all needed operational context: what it verifies, what it returns, and the independent nature of the check. Nothing essential is missing 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?

The tool takes zero parameters and the schema description (100% coverage) already explains that the owner is derived from the authenticated principal. The description adds no parameter details, but with no parameters to document, this is fully sufficient. Baseline for zero-parameter tools is 4.

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

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

The description uses a specific verb ('verify') and identifies the exact resource (EscrowVault on-chain), then enumerates the returned data (address, chain id, RPC, explorer link, USDC token, ABI summary). This clearly distinguishes it from the unrelated sibling tools and leaves no ambiguity about the tool's function.

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

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

The phrase 'Independently verify' implies the tool is used to confirm on-chain facts rather than trusting local or cached data, which gives some contextual guidance. However, there is no explicit statement of when to prefer this tool over alternatives, nor any mention of exclusions or prerequisites. The sibling list offers no relevant comparison.

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