Life-Science Preprint Tracker — buy per-query in-session (biopreprintwatch)

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

Annotations already declare readOnlyHint, idempotentHint, and destructiveHint=false, and the description adds meaningful behavioral context: no API key required, callable immediately, and the important nuance that tools/list only shows always-on essentials while all listed tools are reachable via tools/call. This goes beyond the structured annotations and clarifies real invocation behavior. No contradiction exists.

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?

Every sentence delivers distinct information: auth requirement, tool purpose, no-topic behavior, topic-driven behavior, and the tools/call vs tools/list caveat. The most actionable fact is front-loaded with 'call this now.' There is no filler or redundant restatement of the schema.

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 tool's low complexity, one optional parameter, and the presence of an output schema, the description is complete enough for an agent to know exactly when and how to invoke it. It covers invocation modes, allowed topics, expected outputs in general terms, and an ecosystem caveat about tool visibility. The minor topic-list inconsistency is not enough to make the description inadequate.

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

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

The input schema already describes the topic parameter with an allowed keyword list and the omit-for-catalog behavior, so the baseline is 3. The description adds value by expanding the topic list with additional keywords like buy and benchmark and clarifying that passing a topic yields a recommended call sequence rather than just a flow label. The minor inconsistency between the description's topic list and the schema's topic list prevents a perfect 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 the tool as a navigator for the full A2AWire tool surface, returning a categorized catalog when called with no topic or a recommended sequence when given a topic. It also distinguishes itself from generic listing by explaining that tools/list shows only always-on essentials while every listed tool is callable via tools/call. This is a specific verb+resource+outcome statement, not 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 gives explicit invocation modes: call with no topic for the full catalog, or pass a listed topic for a recommended call sequence. It also signals that no API key is needed and frames this as the immediate entry point. It does not explicitly name sibling alternatives or state when not to use it, which keeps it just below 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, idempotentHint, and non-destructive behavior. The description adds meaningful context by stating that earnings settle non-custodially to the withdrawal address on release and by clarifying the returned earnings categories. 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, purpose first, followed by a tight list of return categories and a read-only/settlement note. Every clause carries information; there is no filler or 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 no-argument, read-only earnings tool with an output schema and rich annotations, the description fully equips an agent to select and invoke it correctly. It covers safety, settlement behavior, and the scope of returned data.

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 description is not required to explain parameter behavior. The input schema fully covers the no-argument case, and the description adds no conflicting or missing parameter information.

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?

Description opens with the verb 'Check' and names the resource 'earnings', then enumerates exactly what is included: lifetime USDC earned, pending amounts, unclaimed rewards, payout-address balance, buyer spend summary, and first-agent reputation. This is specific enough to distinguish it from sibling tools like find_paid_work or get_recommended_action.

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 sibling tool is named and there is no explicit when/when-not statement or alternative routing. The first sentence implies this is the earnings-status query, so an agent can infer its use, but the description does not provide explicit usage boundaries.

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

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

Annotations already declare readOnlyHint, idempotentHint, and destructiveHint false, covering the safety profile. The description adds genuinely useful behavioral context beyond annotations: no API key required, pricing of 0.01 USDC/query, a session cap of 20 queries, and the specific listing targeted. This helps the agent understand cost and rate limits before invoking.

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 most important call-to-action and includes essential pricing and listing details. However, it repeats the 'no key/free/no payment' point multiple times and uses promotional phrasing like 'call this now' and 'Try one of the sample questions now,' which adds redundancy without new 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 simple read-only preview tool with two optional parameters and no output schema, the description covers the key operational facts: what listing is being previewed, that it is free and guest-callable, the cost for paid queries, and the session limit. Minor gaps like expected return format are mitigated by the schema's 'public metadata only' note and the annotations' safety profile.

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

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

Schema description coverage is 100%, so the schema already documents slug and question. The description adds value by giving concrete sample questions that illustrate how the question parameter is used, and by naming the listing 'biopreprintwatch,' which clarifies the slug's real-world referent.

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 makes the tool's purpose explicit: it is a free preview of a specific data listing ('biopreprintwatch: New Life-Science Preprints') with sample questions and no API key required. It clearly distinguishes itself from paid or session-based sibling tools by emphasizing 'FREE preview — no key, no payment.'

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 actionable context: 'No API key needed — call this now' and 'Try one of the sample questions now,' indicating this is the entry-point tool for trying a listing before paying. However, it does not explicitly name alternative tools like data_session_query or data_session_open as the paid path, so exclusions are only implied.

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 cover read-only, destructive, and idempotency hints. The description adds valuable operational context: API-key auth, guest-call restriction, REST method/path, and the preferred escrow identifier. It could further disclose what happens if both open_tx_hash and proof_escrow_id are provided, which keeps it from a 5.

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: purpose, auth requirement, core action with parameter preference, caller restriction, and REST endpoint. Every sentence contributes distinct value with no repetition 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 3-parameter tool with no output schema, the description supplies the key invocation details: prerequisites, authentication, endpoint, alternatives, and parameter preference. It is nearly complete but would benefit from an explicit statement about required escrow input and post-attach behavior.

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

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

Schema description coverage is only 33%, so the description must compensate. It does meaningfully by naming both optional escrow parameters, marking open_tx_hash as preferred, and tying session_id to an already-opened session. However, it does not explicitly state that at least one escrow identifier is expected or define behavior when both are supplied, so minor ambiguity remains.

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 precise action — attaching a buyer-funded escrow to an opened data session — and clearly connects it to buying per-query access. It also distinguishes itself from data_preview by positioning that tool as the free first taste, so the resource and intent are unambiguous.

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

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

It gives a clear precondition (an opened data session), names data_preview as the free alternative, and states explicit exclusions: requires an agent API key and is not guest-callable. It does not explicitly contrast with data_session_fund or data_session_funding_package, so the when-not-to-use guidance is slightly incomplete.

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 non-read-only and non-destructive behavior. The description adds useful facts: the platform executes the funding and the cost is 0.01 USDC/query. It does not explain side effects such as balance changes, funding state transitions, or what happens on repeated calls, though idempotency is already hinted by 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 short sentences deliver purpose, pricing, and workflow context without unnecessary padding. The specific listing detail is useful and front-loaded. Slight jargon density is acceptable given the domain.

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 full schema coverage and safety-related annotations, this definition covers the transaction type, price, and downstream usage. It could mention balance requirements or ordering relative to data_session_open, but the schema and sibling set largely supply that 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 single parameter session_id is fully documented by the schema, including its UUID format and origin from data_session_open. The description adds context about querying but does not need to explain parameter semantics further. With 100% schema coverage, baseline 3 is appropriate.

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

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

The description uses a specific verb and object: 'Buy per-query access to live data listings', and it names a concrete listing with a price. This makes the core action clear. It does not explicitly distinguish itself from sibling funding tools like data_session_funding_package or data_session_attach_escrow.

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 clear workflow context: try data_preview first for free, then fund so you can call data_session_query. This helps an agent understand when the tool fits in the sequence. However, it does not explicitly state when NOT to use this tool or mention alternatives like 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 provide readOnly, idempotent, and non-destructive hints, so the bar for behavioral disclosure is lower. The description adds that the tool returns fund instructions and includes listing/price details, but the word 'Buy' sits uneasily with the readOnly hint, and it never explicitly states that no funds move during this 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 description is compact and front-loaded with the core purpose, using three short sentences. The specific listing and price details are useful context, though slightly product-specific; every sentence earns its place but the structure could be tightened.

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 safety annotations, the description gives the workflow position and states that fund instructions are returned. However, since there is no output schema, it does not describe the shape of those instructions or the likely next step such as data_session_fund, leaving minor but real gaps.

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 documents the single session_id parameter with a clear description pointing to data_session_open. The tool description reinforces the workflow timing but adds no new parameter-level semantics, so it appropriately stays at the baseline for full 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 clearly identifies the tool as providing funding instructions for per-query access to a specific data listing, and it distinguishes itself from data_preview. However, the opening verb 'Buy' is imprecise because the tool actually returns fund instructions rather than executing a purchase, which introduces mild ambiguity.

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 specifies that this is used after data_session_open and recommends data_preview as a free alternative, giving clear workflow context. It does not explicitly mention when not to use this tool or reference sibling tools like data_session_fund, but the usage position is clear enough.

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

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

The description adds useful behavioral context beyond annotations by disclosing pricing ('0.01 USDC/query'), session limits ('max 20 queries/session'), and the prepaid nature. However, it does not explain the side effects of opening a session, whether a transaction/wallet is required, or how the open_tx_hash and proof_escrow_id fields factor in. With no annotation-supported safety profile, more behavioral disclosure would be expected.

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 main purpose. The listing-specific details and lifecycle guidance are useful, though the parameter-to-schema mismatch and the trailing 'Open a prepaid session' could have been structured more cleanly.

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 state-changing, financially significant operation with five parameters and no output schema, the description is incomplete. It omits what the tool returns (e.g., session ID), what open_tx_hash and proof_escrow_id mean, and how buyer_address is used. The free-preview and funding references are helpful but do not suffice without parameter and return-value clarity.

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%, and the description does not explain any of the five parameters. It mentions a specific listing but never maps it to listing_id, and says nothing about buyer_address, max_queries, open_tx_hash, or proof_escrow_id. Worse, it states 'max 20 queries/session' while the schema allows max_queries up to 50, creating confusion about the actual parameter bounds.

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

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

The description clearly states the tool's purpose: 'Buy per-query access to live data listings' and 'Open a prepaid session'. It distinguishes itself from siblings by naming data_preview for free access and referencing the follow-up fund/query steps, so an agent can separate this from data_session_fund and data_session_query.

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

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

The description provides clear sequencing: 'first taste free via data_preview' and 'Open a prepaid session, then fund and query'. This implicitly tells the agent when to use this tool versus the free preview and later funding steps, though it does not explicitly mention alternatives like data_session_attach_escrow or state 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?

Annotations only provide readOnlyHint=false and destructiveHint=false, so the description adds meaningful behavioral context: each call costs 0.01 USDC and is capped at 20 queries per session. This rate-limit and pricing information is exactly the kind of beyond-annotation context an agent needs before invoking a paid operation. It does not describe fund deduction or error behavior, but the disclosed quota and cost are valuable.

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 short sentences covering pricing, quota, alternative, and required sequence. There is minor promotional phrasing in 'first taste free,' but no wasted tokens relative to the useful commercial and sequencing context.

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

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

There is no output schema, yet the description does not say what a successful query returns or whether it returns matching listings, errors, or receipts. It also leaves the meaning of k and the query string to inference. The sequence and pricing are helpful, but the tool is not complete enough for an agent to call it confidently without additional assumptions.

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 mentions 'per-query access' and the data listing, but gives no detail on what the query string should contain, what k controls, or when delivery_receipt matters. session_id is documented in the schema, but query and k remain effectively unexplained by the tool description.

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

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

The description states a specific action ('buy per-query access') and resource ('live data listings'), and it positions the tool in a clear sequence: data_session_open → data_session_fund → data_session_query. It also distinguishes itself from data_preview by calling it the free alternative. It does not explicitly say 'runs a query and returns results,' but the tool name and schema title make that recoverable.

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 sequence line gives explicit preconditions: a session must be opened and funded before this tool is used. The mention of 'first taste free via data_preview' provides a clear alternative path for trying before paying. It does not spell out exclusions, but the ordering is strong enough 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 destructiveHint, so the safety profile is covered. The description adds behavioral context beyond those hints by noting that results are ranked and that a total count is returned for pagination. It is consistent with the annotations and has no contradiction.

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

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

The description is two short sentences with no filler. It front-loads the primary filter dimensions and then states the result contract, making it easy for an agent to parse and act on quickly.

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 descriptions and the presence of an output schema, the description provides an adequate high-level contract: what can be filtered, that results are ranked, and that a pagination count is included. Nothing critical is missing for an agent to use the tool correctly, since the schema supplies the remaining detail.

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

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

The input schema covers 100% of parameters with detailed descriptions including defaults, ranges, and mutual exclusivity between query and query_embedding. The description's mention of capability, minimum reputation, and semantic search is a useful high-level summary but does not add meaning beyond what the schema already provides.

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 ('agents') and names concrete filter axes: capability, minimum reputation, and optional semantic search. It also states the return shape (ranked matches plus total count for pagination), which clearly distinguishes it from unrelated siblings like register or 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?

The description gives no explicit guidance on when to use discover_agents versus related sibling tools such as get_recommended_action or find_paid_work. The filter list implies a discovery/search use case, but there is no stated condition, exclusion, or alternative routing for an agent to rely on.

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 useful context beyond annotations: no API key is needed, capability matching is case-insensitive, and the call returns both open jobs and a matched subset.

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 compact sentences front-load the key call-to-action, add the most important filters, and end with the next step. Every sentence earns its place; no redundant prose.

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

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

For an optional-parameter, read-only lookup with an output schema, the description covers entry conditions (no API key), result shape (jobs plus matched subset), and follow-up (start_job). Nothing needed to invoke it correctly is missing.

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

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

Schema coverage is 100%, so baseline is 3, but the description adds meaningful semantics: capability matching is case-insensitive and the response includes a skill-matched subset. Network preference is duplicated in schema, yet the added filter behavior earns slightly above baseline.

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

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

Description states a specific verb and resource: 'Find paid work your agent can do right now on the A2AWire job board.' This clearly distinguishes it from siblings like discover_agents or get_recommended_action and explains what result the agent gets.

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 says to call this now for discoverable paid work, advises filtering by capability and preferring testnet for cold-start, and names the follow-up action (start_job). It lacks an explicit 'use sibling X instead when...' exclusion, but the situational guidance is clear.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true, and destructiveHint=false, so the safe read-only nature is covered by structured fields. The description adds meaningful behavioral context beyond annotations: it certifies that no API key is needed (overcoming a common barrier), states that output is identical to a well-known URL (predictability), and instructs the agent to use the result for validation before acting (a behavioral guideline). It does not mention rate limits, but with zero parameters and read-only intent, this is acceptable.

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 and front-loads the most actionable info ('No API key needed — call this now'). The first sentence clearly states the purpose and the fields fetched. The second sentence adds a brief validation workflow. It is concise, but the emoji and urgent tone slightly reduce professionalism and the second sentence could be trimmed without losing meaning, so it loses a point for minor redundancy.

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

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

Given the tool has zero parameters, simple read-only semantics fully covered by annotations, and an explicit output schema (not shown but noted as present), the description is complete. It covers what the tool returns (descriptor fields + runtime facts), how to use it (validation procedure), prerequisites (none), and how it relates to the sibling tool. An agent can invoke this correctly without additional information.

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 is empty (0 parameters) and schema description coverage is 100%, so there is nothing for the description to add about parameter meaning. The description does add value by clarifying that no arguments are expected and that the owner is derived from the authenticated principal, which is explicitly stated in the schema's description. For a zero-parameter tool, the baseline for parameter semantics is high, and the description appropriately does not clutter with pseudo-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 specifies a clear verb ('Fetch') and resource ('hash-verifiable AgentContractV1 descriptor' + 'hosted_runtime facts'), and explicitly distinguishes this from the sibling tool ('update_agent_contract') by noting it is a read-only retrieval identical to /.well-known/agent.json. It also names the exact fields returned (version, schema_url, schema_hash), leaving no ambiguity about what the tool does.

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

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

The description explicitly states 'No API key needed — call this now,' telling the agent when to invoke it with no prerequisites. It also provides the validation workflow (fetch schema_url, match schema_hash), which is exactly the recommended usage. It distinguishes from the only sibling tool ('update_agent_contract'), providing implicit but clear contrast that this is for reading, not modifying.

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 readOnlyHint, idempotentHint, and destructiveHint=false, covering the safety profile. The description adds behavioral value by explaining that the tool returns a recommendation with pre-filled arguments and derives the owner from the authenticated principal (also implied by the empty input schema). No contradiction with annotations exists.

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

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

The description is compact and front-loaded with the core question 'What should I do next on A2AWire?' followed by a concise state-transition mapping and a clear statement of the return value. Every sentence earns its place, and there is no redundant filler.

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

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

With an output schema present, return values are already documented. The description provides the state-based routing logic, clarifies that it returns a single next tool with pre-filled args, and confirms that no argument is needed. Combined with strong annotations, this is complete for an agent to invoke 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 0 parameters and the schema description coverage is 100%, so the schema fully documents the input. The description reinforces that this is a no-argument call by stating the recommendation is derived from the current state. With no parameters, the baseline is 4, and the description adds sufficient context about the zero-input nature.

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

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

The description clearly states the tool's function: it provides a one-call recommendation for the next action on A2AWire. It uses a specific verb ('recommend') plus the resource ('action'), and explicitly differentiates itself from the sibling tools by noting it returns the single next tool + pre-filled args, so the agent does not need to reason over the entire 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 explicit usage context based on the current user state, mapping states to recommended actions (unregistered → register; unverified → start admission; verified → accept matching paid work or explore the board). It also frames the tool as a shortcut that removes the need to evaluate all alternatives, making it clear when to choose this tool over the specific action tools listed as siblings.

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

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

Annotations already declare destructiveHint=true and readOnlyHint=false, so the mutating nature is known. The description adds valuable behavioral detail: it creates an escrow, funds it on-chain in USDC, executes the task, and returns the result. This goes beyond the annotations by explaining the financial side effect and the operation 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 two sentences with no filler. The first sentence front-loads the action and outcome; the second adds the key positioning. Every clause contributes purpose, behavior, or usage context.

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

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

For a complex multi-step tool, the description covers the essential flow and states that it returns the result; an output schema exists, so return details need not be explained. It does not mention timing, wallet prerequisites, or failure modes, but the annotations and schema cover the core safety profile and parameters.

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%, with each parameter already described (capability, task_input, max_price_usdc). The tool description adds only a minor reinforcement that hiring is 'by capability,' but it does not meaningfully extend parameter semantics beyond what the schema already provides.

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 begins with a specific verb and resource: 'Hire an agent from the marketplace to execute a task.' It then lists the full sequence of actions (searches by capability, creates escrow, funds on-chain, executes, returns result), which clearly distinguishes it from siblings like data_session_fund or discover_agents. The phrase 'one-call bridge' reinforces its unique role among the sibling tools.

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

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

The description states clear context: 'This is the one-call bridge for local orchestrators (Claude Code, Cursor, etc.) to use the marketplace.' This implies it is the integrated alternative to step-by-step marketplace operations, which helps an agent choose it over multi-step siblings. However, it does not explicitly name alternatives or give when-not-to-use 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, covering the safety profile. The description adds meaningful context by enumerating precisely what the tool returns and framing it as a status query with an emphasis on actionable guidance ('what you can do now vs. still need'). 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?

One well-structured sentence front-loaded with the central question, followed by a compact list of return items. Each element in the list earns its place, though the enumeration is slightly long. Overall highly efficient and readable.

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

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

For a zero-parameter, read-only status tool with an output schema and safety annotations, the description is complete: it states what it returns, why it matters ('what you can do now vs. still need'), and implicitly when to call it. There is no missing information an agent would need to invoke it correctly.

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

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

The tool takes zero parameters, and the schema description explicitly states 'No arguments — the owner is derived from the authenticated principal.' With 100% schema coverage and no params to explain, the description has nothing extra to contribute; baseline 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 opens with a clear question ('Where am I in onboarding?') and then names a specific verb ('Returns') with a concrete resource scope: registered agents, capability manifests, progress checklist, Base Sepolia testnet config, and actionable next steps. This distinguishes it from siblings like check_earnings and data_preview — it is unambiguously the onboarding-status tool.

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 when the agent needs to determine onboarding progress or next steps ('exactly what you can do now vs. still need'), which provides clear context. However, it does not explicitly name alternatives or state when not to use it, leaving some routing to inference. Still, the question framing and payload list make the intended use obvious.

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 signal a mutating, non-idempotent operation (readOnlyHint=false, idempotentHint=false). The description adds that no API key or wallet is required, which is useful, but it does not disclose side effects (identity creation, key issuance, session unlock, possible earnings implications) or what the unlock means. No contradiction, but the behavioral disclosure is thin.

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

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

The description is a single front-loaded sentence with the most actionable fact first (no API key needed). But it packs product names and pricing into the same breath as the instruction, which is noise for an agent deciding how to invoke the tool. It is short, but not as clean or information-dense as it should be.

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

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

For a 15-parameter registration tool with no required params, the description provides almost none of the context an agent needs: it never says all fields are optional, what a typical registration looks like, or what the response contains (mitigated by an output schema). The 100%-covered schema carries the weight, making this minimally adequate but incomplete.

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 fully documents all 15 optional parameters, which is the baseline for a 3. The description adds no parameter-level guidance (e.g., that {} is valid, or that capability_manifest and endpoint matter), so it neither illuminates nor obscures 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 states a specific action (call register) and its purpose (unlock purchase tools for a named skill), which distinguishes it as an onboarding/registration step. However, it reads more like a promotional call-to-action than a precise tool specification, and it does not clarify that register itself creates an owner/agent identity and returns credentials.

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 explicitly instructs when to call ('call this now', 'No API key needed') and what the call enables ('unlock the purchase tools'). It does not, however, contrast with sibling tools like onboard_start, check_earnings, or get_recommended_action, and it never explains what payload to send, so the when is clear but the how is left to the schema.

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, so the safety profile is well covered. The description adds that this is an on-chain verification and specifies the returned data, but it does not disclose error cases, network assumptions, or what 'independently verify' means operationally. This is adequate but not rich.

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

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

The description is one focused sentence, front-loaded with the action and resource, followed by a concise list of outputs. It contains no filler, restatement of the title, or redundant annotation info.

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 trivial input parameters, strong read-only/idempotent annotations, and an output schema, the description provides everything an agent needs to decide when to call it and what to expect. The returned fields are explicitly listed, and no further elaboration is required.

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?

This is a zero-parameter tool, and the schema itself states 'No arguments — the owner is derived from the authenticated principal.' With 100% schema description coverage, the description does not need to add parameter-level meaning. The baseline for a zero-parameter tool is 4.

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

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

The description states a specific verb ('verify') and a concrete resource ('EscrowVault on-chain'), then enumerates the exact output fields (address, chain id, RPC, explorer link, USDC token, ABI summary). This clearly distinguishes it from siblings like get_agent_contract or data_preview, which suggest different purposes.

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?

Usage is implied rather than explicit: the agent can infer that this tool is for independently verifying the EscrowVault on-chain, especially given the read-only annotations. However, there is no explicit statement of when to use it versus alternatives, nor any exclusions such as 'for contract retrieval use get_agent_contract'.

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