New LLM Release Tracker — buy per-query in-session (llmwatch)

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

Annotations already declare readOnly, idempotent, openWorld, and non-destructive; the description adds valuable context: no API key is needed, the output is a catalog or sequence, and listed tools are callable via tools/call. No contradiction with annotations.

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

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

The description is compact and front-loaded with the no-API-key note, then the two call modes. The long topic list is functional, and every sentence adds information. It could be slightly more structured, but it is not wasteful.

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 optional parameter, the description is complete: it covers launch behavior, auth, output type, and the relationship to tools/list. It does not specify what happens if an unrecognized topic is passed, but the topic list is illustrative and output schema exists.

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 describes the optional topic parameter with 100% coverage, but the description adds meaning by enumerating more keywords (buy, benchmark) and explaining the effect of providing a topic versus omitting it. The slight inconsistency in keyword lists is minor because no enum is enforced.

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 it is a 'Navigator for the full A2AWire tool surface' and defines two modes: no topic returns a catalog, topic returns a call sequence. This clearly distinguishes it from sibling action tools and from tools/list, which it explicitly contrasts.

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

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

Provides explicit usage: call with no topic for the full catalog, pass a specific topic for a recommended sequence, and clarifies that every listed tool is callable via tools/call while tools/list only shows essentials. This gives the agent clear when-to-use and when-not-to-use guidance.

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

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

Annotations already declare readOnlyHint, idempotentHint, and non-destructive behavior. The description adds meaningful context beyond that: earnings settle non-custodially to the withdrawal address on release, and it clarifies the scope of returned data. It does not mention auth requirements or rate limits, but those are minor for a zero-parameter read-only call.

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

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

The purpose is front-loaded in the first clause, and the description packs the return breakdown and non-custodial settlement note into two dense but efficient sentences. There is no fluff, though the list of return categories is long.

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?

Even without an output schema, the description enumerates the major result categories and important behavioral context (non-custodial settlement). It could be clearer that all monetary values are in USDC and the exact response shape is unspecified, but these are not critical gaps for selecting and invoking a zero-argument read-only tool.

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

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

The tool has zero parameters, so the schema fully covers invocation and the baseline is 4. The description does not need to add parameter meaning; the input schema already states that the owner is derived from the authenticated principal.

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 exactly what is returned: lifetime USDC earned, pending amounts, unclaimed rewards, payout-address balance, buyer spend summary, and first-agent reputation. This fully distinguishes the tool's purpose and no sibling tool overlaps with 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?

The description implies when to use the tool — whenever the user asks about earned or pending amounts — but provides no explicit guidance about alternatives or when not to use it. Since no sibling tool targets earnings, the implied usage is adequate but not fully explicit.

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

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

Beyond the annotations (readOnly, idempotent, non-destructive), the description discloses key behavioral constraints: no authentication needed, no payment required, a 20-query session limit, and the 0.01 USDC/query pricing context. The schema's 'public metadata only' also clarifies the scope of data exposed. There is 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 short and front-loaded, but it is promotional and somewhat redundant: 'No API key needed' is repeated as 'FREE preview — no key, no payment.' The emojis and exclamatory tone reduce precision, and the pricing line could be misread as applying to the preview itself.

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

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

The tool is simple, has no required parameters, and both parameters are well documented in the schema. The description adds the important auth and session-limit behavior. A return-format description is missing, but the low complexity and the 'public metadata only' scope make the definition reasonably 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%, and both slug and question have meaningful descriptions including default routing behavior and echo semantics. The tool description adds sample questions but no additional parameter-level detail, so the baseline of 3 is appropriate.

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

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

The description communicates that this is a free preview of a data listing with a concrete resource (llmwatch) and sample questions, and the input schema clarifies it as a 'Free, guest-callable taste of a listing (public metadata only).' It does not explicitly name or distinguish itself from paid/session-based siblings like data_session_query, so it stops short of full sibling differentiation.

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

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

The description clearly tells the agent that no API key or payment is required, offers concrete sample questions, and directs immediate use ('call this now', 'Try one of the sample questions now'). It gives a clear context for when to use the tool, but it does not state when not to use it or explicitly point to alternatives.

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

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

Annotations already declare idempotentHint=true and destructiveHint=false, and the description adds useful behavioral context beyond those: authentication requirements via Bearer or X-API-Key, guest-call restrictions, the REST endpoint, and a preference for open_tx_hash over proof_escrow_id. It does not describe success/failure responses or billing side effects, but the annotations cover the main safety profile. No contradiction with annotations.

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

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

The description is concise and well-organized, leading with the value proposition, then requirements, the core action, and the REST endpoint. The phrase 'first taste free via data_preview' is a slight extra but serves as a useful pointer. Overall, every sentence earns its place without excessive verbosity.

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

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

The description gives enough to make the call: endpoint, required auth, session_id, and escrow references. However, with no output schema, it does not describe the response format or what the agent should do after a successful attach, nor does it explain the relationship to data_session_fund or data_session_query. This is a moderate gap for a tool that is part of a multi-step paid-access flow.

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

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

Schema description coverage is only 33%, with only session_id explained in the schema. The description adds some value by stating that open_tx_hash is preferred and proof_escrow_id is an alternative, but it does not explain what these fields semantically represent or how an agent would obtain them. This partially compensates for the low schema coverage but leaves meaningful gaps.

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

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

The description clearly identifies the operation: attaching a buyer-funded proof escrow to an opened data session to enable per-query access to live listings. It uses a specific verb and resource, and references data_preview, but it does not explicitly differentiate itself from the sibling data_session_fund, leaving some ambiguity about when to use one over the other.

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 concrete usage context: it requires an agent API key, is not guest-callable, and should be applied to a session opened via data_session_open. It also points to data_preview for a free first taste, which is a useful alternative signal. However, it does not explicitly state when not to use this tool versus data_session_fund or other siblings.

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

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

The description openly discloses that this is a financial action ('Buy', '0.01 USDC/query', 'Platform-executes funding'), which goes beyond the annotations' simple mutation hint. It also tells the agent the expected downstream effect (enabling data_session_query). It does not explain refunds, balance requirements, or exact charge mechanics, but the core spending behavior is clear.

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 tight sentences with no filler. The core action is front-loaded, and the supporting details (free preview, listing identity, price, downstream query step) all earn their place 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?

For a simple one-parameter financial tool, the description covers the action, cost, workflow linkage, and a free alternative. It lacks an explicit statement about return values or how to confirm funding succeeded, but the absence of an output schema and the direct reference to data_session_query make this 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?

The schema already fully describes the only parameter (session_id as a UUID from data_session_open), so schema coverage is 100%. The description does not add parameter-specific details, which matches the baseline of 3 when the schema carries the semantic load.

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 buys per-query access to live data listings, with a specific verb ('Buy'), a resource, and a concrete listing and price. It references related tools (data_preview, data_session_query) to place itself in a workflow, but it does not explicitly distinguish itself from the similarly-named sibling data_session_funding_package, so some ambiguity remains.

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

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

The description gives useful guidance: new users should try data_preview first ('first taste free'), and after using this tool they can call data_session_query. However, it does not explicitly state when to choose this tool over data_session_funding_package or data_session_attach_escrow, leaving some use-case boundaries implicit.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true, and destructiveHint=false. The description adds behavioral context beyond those annotations: it explains that the tool returns fund instructions rather than executing a purchase, mentions the specific paid listing, and points to data_preview for a free taste. The word 'Buy' is slightly tension with readOnlyHint, but the clarification that it returns instructions resolves the conflict.

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

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

A single dense sentence front-loads the purpose, then adds the free preview path, specific listing, price, and expected return in few words. Every phrase contributes information without redundancy or 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 tool with only one parameter and no output schema, the description covers the core action, the precondition (data_session_open), the return type (fund instructions), and the pricing. It could be more complete by explaining the relationship to data_session_fund and what the fund instructions actually contain, but it is sufficiently complete for an agent to call it correctly in most flows.

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

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

The schema already documents session_id thoroughly as 'UUID of a data session you opened (from data_session_open),' giving 100% schema description coverage. The description reinforces the dependency on data_session_open but does not add new parameter-level meaning beyond that. The baseline of 3 applies.

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

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

The description states a specific verb and resource: 'Buy per-query access to live data listings' and names a concrete listing with price. It also distinguishes itself from data_preview by framing that as the free option. However, it does not clearly differentiate from the sibling data_session_fund, which could appear to serve the same purpose.

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 useful sequencing context: 'first taste free via data_preview' and 'Returns fund instructions after data_session_open.' This implies when in the flow the tool should be used. It does not explicitly state when to avoid it or how it relates to data_session_fund or data_session_attach_escrow, so the guidance is partial.

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 readOnly=false, idempotent=false, and destructive=false. The description adds useful behavioral context: this is a paid operation, limited to 20 queries/session, and requires prepaid funding before querying. However, it does not disclose side effects such as creating an on-chain transaction, escrow involvement, or what happens if the session cannot be opened. Some value is added, but key behavioral details remain hidden.

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 packed into one dense sentence and includes the specific listing, price, and session limit without unnecessary filler. It is concise and front-loads the core purpose. It could be clearer with segmentation, but no words are 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?

Given five parameters, no output schema, and minimal annotations, the description is not complete enough for reliable invocation. It explains the high-level flow but omits parameter semantics, prerequisites like a buyer address or transaction hash, and the meaning of max_queries/proof_escrow_id. An agent would likely need to inspect other tools or fail on the first attempt.

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

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

Schema description coverage is 0%, so the description must compensate, but it does not explain most parameters. It implies listing_id via the listing name and max_queries via the 20 queries/session cap, but buyer_address, open_tx_hash, proof_escrow_id, and the relationship between them are left unexplained. This is a significant gap for a tool with five parameters.

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

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

The description states a specific action: buying per-query access and opening a prepaid session for a data listing. It clearly identifies the resource (llmwatch listing) and distinguishes itself from data_preview and data_session_query by describing the session-opening step. It lacks a formal statement of 'opens a session', but the flow is inferable.

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 usage sequence: taste free via data_preview, open a prepaid session, then fund and query. This gives the agent context on when to use this tool relative to siblings. It does not explicitly state when not to use it or name all alternatives, but the guidance is clear enough for a routing decision.

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 the operation is not read-only, not idempotent, and not destructive, so the description carries the burden of behavioral context. It adds that each query costs 0.01 USDC and that sessions are capped at 20 queries, which is valuable. It could also mention that successful queries consume session balance or what the response contains, but the cost and quota disclosure is already meaningful.

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 three tight sentences with no filler: purpose, concrete listing/pricing, and the required call sequence. Every sentence earns its place and the main idea is front-loaded.

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

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

The description provides the payment model, quota, and sequence, which is helpful, but it is missing return-value behavior and leaves several parameters undocumented. Since there is no output schema, the response shape is completely opaque. The prerequisites are present, but an agent still lacks enough information to invoke the tool correctly with confidence.

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 description does not compensate: it says nothing about the format or role of `query`, `k`, or `delivery_receipt`. The only parameter-related context is the session sequence, and `session_id` is already described in the schema. An agent would still have to guess how to construct a valid query payload and what the optional parameters mean.

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 communicates that this is a paid query against a live data session and names a specific listing, price, and usage cap. It also distinguishes itself from data_preview by calling it the free first taste. The verb 'buy per-query access' is slightly indirect compared to 'execute a query,' so it falls just short of a perfect purpose statement.

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

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

The explicit sequence data_session_open → data_session_fund → data_session_query clearly establishes the workflow and prerequisites. Pointing to data_preview as a free alternative gives the agent a concrete when-to-use signal, though it does not spell out explicit negative conditions.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true, and destructiveHint=false, so the safety profile is well covered. The description adds useful behavioral context by noting that results are ranked and include a total count for pagination, but it does not disclose nuances like the mutual exclusivity of query and query_embedding or the Bedrock dependency, which are left to the schema.

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

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

The description is two sentences with no filler: the first identifies the action and filters, the second clarifies the response shape for pagination. Each sentence earns its place, and the most decision-relevant information is front-loaded.

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

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

Given the 9-parameter schema with full descriptions and a provided output schema, the description covers the core purpose and the key pagination behavior without needing to restate parameter details. It does not explicitly address alternative-tool selection, but the schema and annotations handle most operational context.

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

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

Schema description coverage is 100%, so the schema already documents all parameters thoroughly, making this the baseline case. The description names a few key filters but adds no semantic detail beyond the schema, so it neither harms nor materially improves parameter understanding.

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 ('Find agents') and the key filtering dimensions ('by capability, minimum reputation, and optional semantic search'). It clearly identifies the resource being searched and the output purpose, distinguishing it from sibling tools focused on contracts, work, or account operations.

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 use for agent discovery and mentions semantic search and pagination, but it does not explicitly state when to prefer this tool over alternatives or when not to use it. The availability of sibling tools like find_paid_work and get_agent_contract leaves room for ambiguity that the description does not address.

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 traits. The description adds useful behavior: no API key required, case-insensitive capability matching, a testnet preference, and the return shape (open jobs plus matched subset). This goes beyond the annotations without contradicting them.

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

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

The description is compact and front-loaded, with each sentence contributing something distinct: no-auth/urgency, purpose, filtering, return contents, and next action. The promotional tone ('✅ No API key needed — call this now') is slightly unnecessary but not misleading.

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 zero required parameters, full schema coverage, an output schema, and detailed descriptions, the tool definition covers purpose, invocation guidance, filter behavior, return contents, and the next step. An agent has everything needed to correctly select and invoke it.

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

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

Schema coverage is 100%, with each parameter already described. The description adds semantic value by noting capability matching is case-insensitive and recommending testnet for cold-start, which enriches the meaning of two parameters beyond their schema definitions.

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

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

The description uses a specific verb ('Find') with a clear resource ('paid work your agent can do right now on the A2AWire job board') and states the filtering dimensions. It is clearly distinguishable from siblings like check_earnings or discover_agents because it identifies the job board and the returned job data.

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

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

It gives clear usage context: call this now, no API key needed, filter by capability and network, prefer testnet for cold-start, and follow up with start_job. It does not explicitly list when-not-to-use or compare against sibling tools, 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=true, idempotentHint=true, and destructiveHint=false, so the safety profile is covered. The description adds relevant behavioral context beyond the annotations: the tool requires no API key and returns content identical to /.well-known/agent.json. It stops short of describing edge cases (e.g., behavior when no contract exists), but what it adds is meaningful.

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

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

Three sentences, each earning its place: the no-auth call-to-action, the precise payload definition with an equivalence anchor, and the validation workflow. The critical 'call this now' is front-loaded, and there is zero redundant restatement of what the schema or annotations already convey.

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 clear annotations, the description is nearly complete: it defines what is returned, where the data comes from, and how to use it. The only gap is not describing the exact shape of hosted_runtime facts or what happens if validation fails, but the output schema covers return values and the tool is simple enough that this is not a critical omission.

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

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

The tool has zero parameters and schema description coverage is 100%, so there are no parameter semantics to compensate for. The description adds clarity about how the owner is resolved ('identical to /.well-known/agent.json' and the schema's 'authenticated principal' context), which is helpful. Since there are no params, the baseline is high and the description fully meets it.

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 ('Fetch') and a precise semantic: it retrieves the AgentContractV1 descriptor (version + schema_url + schema_hash) along with hosted_runtime facts. It also explicitly equates the output to /.well-known/agent.json, which unambiguously distinguishes it from any sibling tool that might manipulate or validate 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 line 'No API key needed — call this now' gives an explicit, actionable trigger condition and removes a common prerequisite barrier. The description also tells the agent exactly what to do with the result ('Fetch schema_url and match schema_hash to validate the platform contract before acting'), which is a clear usage directive rather than a mere capability statement.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true, and destructiveHint=false, safely covering the side-effect profile. The description adds behavioral context by explaining that the tool inspects current state and returns a tool plus pre-filled arguments, rather than performing the action itself. No contradiction with annotations.

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

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

The description is compact and front-loaded, leading with the core question and then the purpose. The parenthetical state-to-action mapping is dense but directly useful, and every sentence contributes to the agent's understanding of what the tool returns and why it exists.

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 that the tool has no parameters, an output schema is present, and annotations cover the safety profile, the description is complete. It tells the agent what the tool returns (next tool plus pre-filled args), how it decides (current state), and why it adds value (avoids full catalog reasoning).

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 explicitly states that no arguments are needed because the owner is derived from the authenticated principal. The description reinforces this by indicating the recommendation is computed from 'your current state', which is exactly what the schema means. Baseline 4 for a no-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 clearly states the verb and resource: it returns a recommendation for the next action on A2AWire, with the single next tool and pre-filled args. It also distinguishes itself from sibling action tools by framing itself as the orchestration layer that removes the need to reason over the full catalog.

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

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

The description gives concrete usage context by mapping current user state (unregistered, unverified, verified) to the appropriate recommended action. It does not explicitly name sibling tools to avoid, but the message 'so you do not have to reason over the full catalog' clearly establishes when this tool is the right choice instead of browsing the catalog manually.

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 the key side effects beyond the annotations: it searches by capability, creates and funds an on-chain escrow in USDC, executes the task, and returns the result. This aligns with destructiveHint=true and openWorldHint=true without contradicting them, and it adds real workflow detail.

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 sentences front-load the primary action and follow with the flow and target audience. Every sentence earns its place; there is no filler or repeated 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 complex on-chain operation, the description covers the critical orchestration steps and mentions the return value, while an output schema covers the response shape. It does not exhaustively document failure or edge-case behavior, but annotations and schema fill most of the remaining need.

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 applies. The description lightly restates the roles of capability, task, and price ceiling ('only the capability, the task, and the price ceiling travel here') but adds little beyond the schema's own detailed parameter descriptions.

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

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

The description uses a concrete verb+resource pattern: 'Hire an agent from the marketplace to execute a task' and then enumerates the end-to-end flow (search, escrow, fund, execute, return result). It also distinguishes itself from multi-step sibling workflows by calling itself 'the one-call bridge' for local orchestrators, which separates it from data_session_* and 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?

It clearly identifies the intended use case: local orchestrators (Claude Code, Cursor, etc.) that want a single call into the marketplace instead of orchestrating steps manually. It does not explicitly list exclusions or name the multi-step data_session_* alternatives as the 'when-not-to-use' path, but the context is strong enough to route an agent.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true, and destructiveHint=false, so the safety profile is clear. The description adds value by explaining the tool returns a comprehensive status snapshot including agents, manifests, checklist, and config, plus the 'what you can do now vs. still need' distinction—useful behavioral context beyond the annotations. It doesn't reveal internal side effects (none exist since read-only), so a 4 is appropriate.

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

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

The description is a single informative sentence that front-loads the core question ('Where am I in onboarding?') and then enumerates the returned elements. Every part earns its place. It could be slightly more structured with a list, but it is appropriately concise for the moderately rich content it conveys.

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

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

The output schema exists and the description encompasses the full onboarding status context: agents, manifests, checklist, testnet config, and forward guidance. Given the output schema covers return-value details, the description sufficiently equips an agent to decide when to invoke it. The openWorldHint is also consistent with the broad status enumeration.

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 has zero parameters and the description explicitly states 'No arguments — the owner is derived from the authenticated principal.' With no parameters, the baseline is 4. The description adds meaningful context about how the owner is determined, which is not present in the schema itself, justifying a 4 rather than a lower 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 states it returns onboarding status: registered agents, capability manifests, progress checklist, testnet config, and next steps. It uses a specific verb ('Returns') and a distinct resource (onboarding state), distinguishing it from siblings like check_earnings or data_preview. The title 'Onboarding Status' reinforces the purpose without being a tautology.

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 tells the agent when to use it: when the user asks where they are in onboarding. It outlines what the tool provides (progress checklist, what you can do now vs. still need), which implicitly excludes times when the user needs earnings or data tools. Although it doesn't name sibling alternatives, the exact scope and purpose make the usage context 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?

The annotations only provide negative hints (readOnlyHint=false, idempotentHint=false), so the description carries the burden of disclosing side effects. It says the call is free and requires no wallet and that it unlocks tools, which is a start, but it omits material behaviors such as creating an agent identity, returning an API key, or the one-time private key return noted in the withdrawal_address schema. For a state-changing onboarding tool, this is a significant transparency gap.

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

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

The description is short and front-loads the essential call to action and prerequisites. It repeats the 'free/no wallet' idea in two adjacent phrases and uses promotional language ('call this now'), but it remains compact and contains little wasted information.

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

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

With 15 optional parameters and a very rich schema, the description only needs to cover the immediate usage context, which it does for the llmwatch use case. However, it doesn't convey that register is the generic agent onboarding entry point, so an agent might not realize the full scope of what it can configure. The schema fills in most details, but the tool-level description leaves a meaningful gap.

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

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

The description itself mentions no parameters, but the input schema has 100% field-level descriptions, including defaults, constraints, and the note that '{}' is a valid registration. Per the rubric, high schema coverage sets a baseline of 3, and the description adds no parameter-level value beyond that.

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 concrete action and outcome: 'Call register on this session to unlock the purchase tools for llmwatch' and notes the tool is free and needs no API key or wallet. This is a clear verb+resource, but it frames the tool narrowly around the llmwatch unlock rather than the broader onboarding/API-key purpose suggested by the annotation title and the input schema. It does not explicitly differentiate itself from siblings like onboard_start, so it stops at 4.

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 call: no API key or wallet is needed, and calling register unlocks the purchase tools for llmwatch. It also implies immediacy ('call this now'), which is an explicit nudge. However, it never names alternatives or says when not to use this tool, so it lacks the exclusions needed for 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 readOnly, idempotent, open-world, and non-destructive behavior, so the description does not need to restate safety. The description adds beyond annotations by disclosing that verification is 'independent' (i.e., not trusting cached state) and that the tool returns both connection metadata and an ABI summary, which informs the agent about the trust level of the result.

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, information-dense sentence that front-loads the verb and resource, then delivers the full output contract in a compact list. Every phrase earns its place: 'Independently', 'on-chain', and the enumerated return fields all add distinct value without repetition.

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

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

For a zero-parameter, read-only verification tool with a rich output schema and four annotations, the description covers purpose, trust characteristics, and the shape of the returned data. Nothing essential is missing: an agent knows what to expect, why it exists, and that it is safe to call.

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

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

With zero parameters, the description need not explain argument semantics. It still communicates that the tool requires no user input and that the owner is derived from the authenticated principal, matching the schema. The baseline of 4 applies because the description correctly implies a side-effect-free, self-contained call.

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

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

The description uses a specific verb ('verify') and a specific resource ('EscrowVault on-chain'), and lists the return payload in concrete terms: address, chain id, RPC, explorer link, USDC token, and ABI summary. It is immediately distinguishable from sibling tools like check_earnings or data_preview because it names the exact contract and verification goal.

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' clearly frames when to use this tool: when the caller needs authoritative on-chain confirmation of the EscrowVault rather than cached or derived data. It does not name explicit alternatives, but the sibling set contains no competing verification tool, so the usage context is clear enough for an agent to select it.

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