Debian Security Advisories — buy per-query in-session (debianwatch)

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

Annotations already provide readOnly, idempotent, and non-destructive hints, and the description does not contradict them. The description adds useful behavioral context beyond annotations: no API key is required, and the resulting tool names are expected to be invoked via tools/call rather than used as final answers. Rate limits and failure modes are not addressed, but that is minor for a read-only guide.

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, all conveying necessary information: the no-auth precondition and urgency, the no-topic/topic usage modes, and the caveat about tools/list. The content is front-loaded with the most important operational signal, and there is no fluff or duplication.

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 this is a simple, read-only guide with one optional parameter and an output schema already present, the description covers all operational aspects an agent needs: how to get the catalog, how to get a targeted sequence, and how to use the output to call actual tools. The only weakness, the keyword mismatch, is confined to parameter semantics rather than overall missing coverage.

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

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

Schema documentation covers the topic parameter 100%, so the baseline is 3. The description adds meaning by naming the two parameter states (absent vs topic) and providing example keywords, but it lists extra keywords ('owner', 'buy', 'benchmark') that do not appear in the schema's keyword list, slightly weakening the consistency. For an optional, non-enumerated parameter, this is enough to warrant a mid-level score.

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 this as a navigator/guide to the full A2AWire surface and explicitly states its two operating modes: no-topic returns a categorized catalog, topic returns a recommended call sequence. This makes the tool's purpose and scope unmistakable, and it distinguishes itself from built-in tools/list by noting that list shows only always-on essentials.

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 says when to call with no topic versus with a topic, and even explains how to use the results: 'Every listed tool is callable via tools/call by name.' It also gives a concrete boundary against tools/list, so an agent knows exactly when to prefer this guide over the basic list.

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

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

Annotations already declare readOnly and non-destructive, and the description goes further by explaining that earnings settle non-custodially to the withdrawal address on release and distinguishing released versus pending versus unclaimed amounts. This adds meaningful behavioral context beyond the structured 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 front-loaded with the main purpose, and the second sentence packs a detailed list of return categories without fluff. It is somewhat dense, but every clause contributes useful 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-argument read-only tool with a rich output schema and clear annotations, the description covers the call context, result categories, and settlement behavior. 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?

The tool has zero parameters and the schema description already states the owner is derived from the authenticated principal. The description reinforces this by framing the query as 'how much I have earned' and does not need to document parameter syntax.

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

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

The description clearly states the tool checks earned and pending amounts, and enumerates exactly what is included (lifetime USDC, in-flight pending, unclaimed rewards, payout balance, buyer spend, reputation). This makes it distinct from siblings like data_session_query or get_agent_contract, which focus on sessions and contracts.

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 sentence gives a clear use case: use this tool when checking earnings and pending amounts. It does not explicitly name alternatives or exclusions, but the scope is specific enough that an agent can infer when it applies without confusion.

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 declare this to be read-only, idempotent, and non-destructive, so the description's main job was to add behavioral context. It adds that no API key is needed and mentions 0.01 USDC/query and a 20-query session cap, but contradicts itself by calling the tool 'FREE' and 'no payment' while stating a Price. It also omits what the tool actually returns and what data it reveals.

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 highly repetitive, repeating the 'FREE preview', 'free' meaning, and call-to-action themes multiple times. It includes emojis, excessive exclamations, and promotional language that inflates length without adding tool-relevant 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?

Given this is a guest-callable tool with no output schema, the description should clarify what a caller sees (e.g., 'five example records' or 'public metadata only') and what the actual return shape is. The it does is contradict the 'free' claim with a price, and never explains whether it returns sample these or only echoes the question. An agent is left uncertain about what happens when it calls this tool.

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

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

Schema description coverage is 100%, so the baseline is 3. The parameter descriptions in the schema already clarify that this is a guest-callable taste of a listing and that the question echoes back. The description's example questions add a little practical color, but it doesn't meaningfully describe semantics or behavior for either parameter.

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

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

The description conveys that this is a free preview of the Debian Security Advisories listing and includes sample questions, so the general purpose is inferable. However, it never states the actual function verb (e.g., returns public listing metadata only) and reads mostly like marketing copy, not a tool summary. The schema description is clearer than the tool description 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 says 'No API key needed' and 'FREE preview,' which implies this is the tryer/explorer path, but it never explains when to use this preview versus the sibling paid/data-session tools like data_session_open. It also includes the misleading sample questions that suggest full answer capability, while the schema says the question is merely echoed. The phrase 'call this now' is a call-to-action, not usage guidance.

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

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

Annotations already cover idempotency and non-destructiveness. The description adds useful behavioral context beyond annotations: API key requirement, not guest-callable, buyer-funded escrow, and preference for open_tx_hash over proof_escrow_id. 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 dense sentences, each carrying necessary information: value/context, auth constraint, and the actual attach action with both parameter options. The REST path is included without extra 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 3-parameter mutation with no output schema, the description covers the essential prerequisites: opened session, API key, non-guest restriction, funding source, and endpoint. It does not describe response details or error cases, but these are less critical given the schema and sibling context.

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

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

The schema documents session_id but leaves open_tx_hash and proof_escrow_id only as titled nullable fields. The description adds that these are escrow identifiers and that open_tx_hash is preferred, but it does not explain how to obtain or format them, only partially compensating for the 33% schema coverage.

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

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

The description states a specific action: attaching a buyer-funded proof escrow to an opened data session. It distinguishes itself from data_preview by explicitly mentioning the free preview path, and the REST endpoint makes the operation 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 clearly indicates the tool is for paid per-query access after a session is opened, and it points to data_preview as the free alternative. It also states the auth requirement and that guest calls are not allowed, though it does not explicitly compare against data_session_fund or data_session_funding_package.

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 a mutating operation (readOnlyHint false) and idempotency, so the bar is lower. The description adds concrete behavioral context: this actually moves money and buys per-query access at a stated price (0.01 USDC/query). It also clarifies that funding is platform-executed, which is useful beyond the annotation metadata.

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 compact sentences with no filler. It front-loads the purpose, then gives the concrete listing/price, then connects to the query action. Every clause contributes to an agent's decision-making.

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 tool with full schema coverage, the description is nearly complete: it states cost, data source, prerequisite (data_preview), and downstream action (data_session_query). The main omissions are what the funding call returns and expected behavior if the session is already funded, but these are minor given the simple structure and existing annotations.

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 single session_id parameter is already documented as a UUID from data_session_open with the purpose 'funding-package / attach / query.' The tool description adds no additional parameter-level detail, 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 states the verb and resource: 'Buy per-query access to live data listings' and 'Platform-executes funding so you can data_session_query.' It also distinguishes itself from data_preview (free taste) and data_session_query (post-funding use). However, it does not explicitly differentiate from the sibling data_session_funding_package, and it relies on the schema to clarify that it targets an existing session.

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

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

The description provides a clear usage sequence: try data_preview first for free, then fund the session, then use data_session_query. This gives an agent actionable context about when to call this tool relative to key siblings. It lacks explicit exclusionary guidance, but the flow is strongly implied and sufficient for a low-complexity 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 indicate readOnlyHint=true and idempotentHint=true, and the description adds that the tool returns fund instructions rather than executing a purchase, which aligns with read-only behavior. It also discloses the session prerequisite. 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 no fluff. The main purpose is front-loaded, and the additional context (free preview, return type) is valuable and 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?

For a single-parameter tool with high schema coverage and no output schema, the description adequately covers prerequisite (session open), return type (fund instructions), and the specific offering (listing + price). It could mention that fund instructions are likely for a subsequent step, but it's not a 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?

The schema already fully describes session_id with 100% coverage (UUID from data_session_open). The description adds no new parameter-specific details beyond restating the prerequisite, which is already in the schema. Baseline 3 is appropriate.

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

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

The description states the verb 'Buy' and the resource 'per-query access to live data listings', and specifies the exact listing (Debian Security Advisories) with price. It also mentions the return (fund instructions), which clearly identifies the tool's role. It does not explicitly name sibling alternatives, but the purpose is distinct enough from generic funding tools.

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

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

The description implies usage after data_session_open ('Returns fund instructions after data_session_open') and mentions a free alternative via data_preview. However, it does not explicitly explain when to choose this tool over data_session_fund or data_session_attach_escrow, leaving some ambiguity about the exact workflow.

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 say the operation is not read-only, not idempotent, and not destructive; the description adds meaningful context: cost per query, a 20-query session cap, prepaid nature, and the required fund-then-query flow. It does not mention wallet/auth requirements or response behavior, but the financial side effects are disclosed.

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

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

Two sentences and front-loaded with the core value proposition and price. Nested parentheticals and the 'Listing:' fragment make it slightly less clean than it could be, but no sentence is wasted.

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

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

For a paid session opener with 6 optional params and no output schema, the description covers purpose, price, sequence, and the preview alternative. It omits the return value/session identifier and the undocumented payment/escrow params, so an agent may still be unsure how to handle open_tx_hash or proof_escrow_id.

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 descriptions cover only 3 of 6 parameters; max_queries, open_tx_hash, and proof_escrow_id are undocumented. The description mentions a query cap and billing, but it does not explain how to supply the listing, what max_queries means, or what open_tx_hash/proof_escrow_id are for, so it fails to compensate for the coverage gap.

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

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

States a clear action: open a prepaid session to buy per-query access to a specific live listing. It also distinguishes itself from data_preview ('first taste free') and from later steps ('then fund and query'), so the agent can tell it apart from siblings.

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

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

Gives an explicit usage path: preview free via data_preview, open the paid session here, then fund and query. It does not spell out negative cases or when to prefer data_session_attach_escrow or data_session_funding_package, but the core alternative and sequence are 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?

Annotations are all false and uninformative, so the description carries some burden. It adds useful behavioral context: this is paid access, priced at 0.01 USDC per query, with a 20-query session cap. However, it does not disclose whether a successful query consumes balance, whether it returns partial results on failure, or any authentication/receipt requirements beyond the stated sequence.

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

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

The description is compact: three sentences deliver pricing, limit, free-preview alternative, and the required sequence. It is front-loaded with the core purpose sense. The listing detail feels slightly niche but is still information-bearing; there is minimal padding.

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

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

Given the absence of an output schema; a paid, multi-step workflow with five parameters; and financial side effects, the description is incomplete. It explains the general flow but leaves critical execution details — exact query semantics, what the response contains, k meaning, and how delivery_receipt/sandbox_receipt affect invocation — to the agent to infer.

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%, and the tool description adds no parameter-level meaning. It never explains query format, the k parameter, sandbox_receipt, or delivery_receipt semantics. The schema itself documents only three of five parameters, so the description should compensate but does not.

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

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

The description states the tool provides paid per-query access to live data listings and includes the concrete listing (Debian Security Advisories at 0.01 USDC per query). The sequence data_session_open → data_session_fund → data_session_query makes the tool's role as the query step clear)Skip; while the verb 'buy' is slightly imprecise, the title and sequence resolve the intent.

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

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

The description explicitly provides the intended call sequence and contrasts the free first taste via data_preview with paid per-query access here. It does not spell out exclusions like 'do not use before funding', but the sequence strongly implies when this tool should be used.

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 the tool as read-only, open-world, idempotent, and non-destructive. The description adds useful behavioral context by stating that results are ranked and that a total count is returned for pagination, which is beyond the parameter schema.

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

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

Two sentences, front-loaded with the core purpose, and no filler. Every clause contributes either the action, the key filters, or the return 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?

Given the rich schema, annotations, and an output schema, the description provides a sufficient high-level overview including pagination count. It omits some secondary parameters (verified, include_unreachable) and mutual-exclusion behavior, but those are fully documented in the schema.

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

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

Schema description coverage is 100%, so the schema carries full parameter documentation. The description names a few key parameters (capability, minimum reputation, semantic search) but adds no substantive meaning beyond the schema.

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

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

The description clearly identifies a specific verb ('Find'), a resource ('agents'), and the main filtering dimensions (capability, minimum reputation, semantic search). It does not explicitly contrast with sibling tools, so it falls just short of full 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?

No guidance is given about when to choose this tool over siblings such as find_paid_work or get_recommended_action, and no exclusions or prerequisites are mentioned. The only usage signal is the implied 'find agents' use case.

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, openWorld, and non-destructive behavior. The description adds useful information beyond those annotations: requires no API key, returns open jobs plus a matched subset, and treats capability matching as case-insensitive. No contradiction 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 compact and front-loaded with the most important call condition (no API key), then filters, return content, and next step. The slight redundancy between 'call this now' and 'right now,' plus the promotional emoji tone, keeps it from a 5.

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 lookup with three optional parameters and an output schema, the description is largely complete: it covers preconditions, filtering behavior, network guidance, return shape, and next action. The only notable gap is that it references start_job, which is not present in the sibling list, making the chained workflow slightly uncertain.

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 valuable extra nuance: capability matching is case-insensitive and testnet is preferred for cold-start, which goes beyond the schema's descriptions.

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

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

The description clearly identifies the action ('find paid work'), the resource ('A2AWire job board'), and the filtering dimensions (capability, network). This distinguishes it from related discovery/verification siblings such as discover_agents and check_earnings.

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

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

Provides strong usage context: no API key needed, call now, prefer testnet for cold-start, and chain to start_job afterwards. It does not explicitly name alternative tools or say when not to use this one, 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 declare readOnlyHint, openWorldHint, idempotentHint, and non-destructive behavior. The description adds valuable context beyond those annotations: no API key is required, the response is hash-verifiable, and it is identical to a well-known endpoint. This usefully clarifies authentication expectations and data provenance 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 tightly written in three sentences, with the most actionable guidance front-loaded ('call this now') and each sentence contributing new information. There is no filler or repetition of schema contents, and the mention of validating the contract before acting earns its place as practical 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 tool with a rich output schema and annotations, the description covers the essential context: what is fetched, that no API key is needed, that it matches a standard endpoint, and what the caller should do with the returned schema_url and schema_hash. Nothing critical is missing for an agent to invoke this tool correctly.

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

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

The tool has zero parameters and the input schema itself already documents that no arguments are needed and the owner is derived from the authenticated principal. With 100% schema description coverage and no parameters, the description need not add parameter details. Baseline 4 for zero-parameter tools applies.

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

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

The description clearly states a specific action: 'Fetch the hash-verifiable AgentContractV1 descriptor' including version, schema_url, and schema_hash, plus hosted_runtime facts. It identifies the resource as identical to /.well-known/agent.json, making the tool's scope unambiguous. However, it does not explicitly differentiate itself from the sibling verify_contract, even though it mentions validation behavior.

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

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

The description gives clear context: 'No API key needed — call this now' and says to validate the platform contract 'before acting', signaling when this should be used. It does not explicitly state when not to use it or mention alternatives such as verify_contract, so it stops short of full routing 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 the tool read-only, idempotent, and non-destructive. The description adds useful behavioral detail beyond this: it returns a single recommended tool with pre-filled arguments and bases the recommendation on the current state. No annotation contradiction is present.

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

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

The description is brief, front-loaded with the user's question, and every sentence serves a distinct purpose: state the goal, give the state mapping, and describe the return value. There is no redundant or filler content.

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

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

Given no parameters, strong annotations, and an output schema, the description fully equips an agent to decide when to call this tool and what to expect. It covers the decision logic, the result shape, and the value over the full catalog, so nothing critical 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 the schema description already covers that input is empty. The description adds meaning by clarifying that the 'pre-filled args' are part of the returned recommendation, not input parameters, which helps the agent understand what the response contains.

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

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

The description clearly identifies the tool as a one-call recommendation engine that returns the single next tool plus pre-filled arguments. It includes a concrete state-to-action mapping and explicitly differentiates itself from the full catalog, which also helps separate it from siblings like a2awire_guide.

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

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

The description gives clear context for when to use the tool: whenever the agent or user needs to determine the next step based on current state. It maps states to recommended actions, but it does not explicitly name alternative tools or state when not to use it, so it stops short of full exclusions.

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

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

Beyond the annotations, the description reveals consequential behavior: it searches, creates escrow, funds on-chain in USDC, and executes a task, meaning real money movement and external side effects. It does not detail irreversibility or buyer-agent derivation, but the destructiveHint annotation already flags risk and the description adds meaningful 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?

Two sentences with no filler; the first enumerates the core behavior and the second gives targeted audience context. Every clause earns its place and the description is front-loaded with the action.

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

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

For a mutating, financial tool with three parameters and an output schema, the description covers the core behavior, side effects, and intended use case. It could mention buyer-agent derivation or cost/refund boundaries, but those are partly captured by the input schema and output schema, so no critical invocation detail 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 schema already explains capability, task_input, and max_price_usdc. The tool description mentions 'capability' and 'USDC' in passing but adds no parameter-level semantics beyond what the input schema 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 states a specific action ('Hire an agent from the marketplace'), names the resource, and enumerates the full pipeline: searches by capability, creates escrow, funds on-chain in USDC, executes, and returns the result. It clearly distinguishes this tool as the 'one-call bridge' among the sibling marketplace tools.

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

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

The description gives clear usage context: this is the one-call bridge for local orchestrators like Claude Code and Cursor. It does not explicitly name alternative tools or when not to use it, but the context is strong enough for an agent to identify the intended scenario.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true, and destructiveHint=false, so the description doesn't need to repeat that this is a safe read operation. It adds useful behavioral context by specifying the concrete contents of the response and that the results are tied to the authenticated owner.

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, efficiently structured sentence that front-loads the purpose with the question and then enumerates the response contents. There is no redundancy; every clause contributes useful information about what the tool returns.

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 strong annotations, the description is sufficiently complete. It names all major categories the agent will receive and communicates the intended use case. Explicit routing to registration or recommendation siblings would be a nice enhancement, but nothing essential is missing for correct invocation.

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

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

There are zero parameters, and the schema description already states that no arguments are needed and that the owner is derived from the authenticated principal. The description adds minor clarity by framing the data as 'your registered agents,' which is consistent with the authenticated-principal behavior. No parameter explanation is needed.

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 clear user-facing question—'Where am I in onboarding?'—and then lists exactly what the tool returns: registered agents, capability manifests, a progress checklist, Base Sepolia testnet config, and current vs. remaining actions. This distinguishes it from all sibling tools, none of which cover the overall 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 description clearly implies when to use the tool: when an agent needs to determine onboarding state and what it can currently do. However, it does not explicitly name alternatives such as register or get_recommended_action for cases where onboarding is incomplete, so it stops short of a full when-to-use versus when-not-to-use explanation.

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 convey that the tool is mutating (readOnlyHint=false) and not idempotent. The description adds only 'No API key needed' and 'Free — no wallet needed', which are promotional rather than behavioral. It does not disclose side effects such as auto-provisioning a wallet, setting spending caps, or creating a persistent agent record, so it adds minimal behavioral transparency beyond annotations.

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

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

The description is very short (two sentences) and front-loaded with a call to action, but it lacks substantive content. While concise, it omits crucial information about what the tool actually does, so the brevity comes at the expense of usefulness. It is structured but not informative enough to justify a higher 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?

Given a 15-parameter onboarding tool with nested objects and a rich schema, the description is severely incomplete. It does not explain that the tool registers an agent, that all fields are optional, or that it returns credentials. It focuses solely on Debian Security Advisories, ignoring the general onboarding purpose and leaving essential context absent.

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

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

Schema description coverage is 100%, so every parameter is already documented in the input schema. The description mentions no parameters and adds no meaning above the schema. With full coverage, the baseline score of 3 is appropriate.

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

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

The description says 'Call register on this session to unlock the purchase tools for Debian Security Advisories', which identifies a specific verb and resource, but it omits the tool's general purpose of onboarding an agent on A2AWire and providing an API key. It is not a tautology, but it narrowly frames the tool around a single use case, making the actual scope unclear and potentially misleading.

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 'call this now' but provides no context on when this tool should be used versus alternatives like onboard_start, nor when not to use it. No conditions, prerequisites, or exclusions are mentioned, leaving the agent without guidance on selecting this tool.

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

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

Annotations already declare readOnly, idempotent, and non-destructive behavior. The description adds the behavioral nuance that verification is performed independently and on-chain, and enumerates the resulting data fields, 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?

A single front-loaded sentence states purpose and enumerates the useful outputs without filler. Every phrase earns its place.

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

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

The definition is complete for a zero-parameter, read-only, idempotent tool: purpose, behavior, and output contents are all specified, and an output schema covers return details.

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

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

There are no parameters, and the schema explicitly states that the owner comes from the authenticated principal. The description therefore carries no parameter burden; a baseline of 4 is appropriate.

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

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

The description names a specific verb ('verify'), a specific resource ('EscrowVault on-chain'), and lists concrete returned artifacts. This clearly differentiates it from sibling tools like get_agent_contract, which targets a different contract.

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 the EscrowVault on-chain' establishes a clear context for use: a read-only confirmation of the deployed vault's identity and details. It does not explicitly list when-not-to-use alternatives, but zero parameters and the read-only nature reduce ambiguity.

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