FDA Recall Alerts — Food & Product Safety (fdarecall)

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

Beyond the readOnlyHint/idempotentHint annotations, the description discloses that no API key is needed, what the returned catalog contains, that topic flows return a call sequence, and that listed tools are callable via tools/call. This gives an agent meaningful behavioral context beyond the structured 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 tight and front-loaded with the most actionable signal ('No API key needed — call this now'). Each sentence earns its place: what the tool is, how to use it with and without a topic, and how it relates to tools/call and tools/list. No unnecessary filler despite the long keyword list.

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 read-only guide tool, the description covers the entry points, the output shape at a high level, and the tool-routing relationship. An output schema exists, so the description need not enumerate return fields. The only residual concern is the minor keyword mismatch with the schema, but the tool is still fully usable and well explained.

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 the single optional topic parameter with 100% coverage, so the baseline is 3. The description does provide the full keyword list and clarifies the default behavior, but it is inconsistent with the schema's keyword list — the description includes 'buy' and 'benchmark' while the schema lists fewer topics. This ambiguity prevents a higher 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 identifies the tool as a 'Navigator for the full A2AWire tool surface,' a specific verb and resource, and specifies exactly what happens with and without a topic: a categorized catalog with name + one-liner, or a recommended call sequence. It also distinguishes itself from tools/list, making it easy for an agent to separate this from sibling execution tools.

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

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

The description gives explicit invocation guidance: omit topic for the full catalog, pass specific topic keywords for a flow sequence. It also explains the distinction between tools/call and tools/list, which is valuable routing guidance. It stops short of a full 5 because it does not explicitly state when not to use this tool or compare it to any sibling navigator/guidance tool such as get_recommended_action.

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 value by explaining the non-custodial settlement behavior ('earnings settle non-custodially to your withdrawal address on release') and clarifying what 'earned' means in terms of released escrows plus claimed rewards. 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, no fluff. The purpose is front-loaded, the return payload is listed compactly, and the settlement caveat is a meaningful one-liner. Every clause earns its place.

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

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

For a zero-parameter, read-only query tool with strong annotations, the description fully covers what the agent needs: what the tool returns, the read-only nature, and the relevant settlement behavior. The lack of an output schema is mitigated by the explicit enumeration of return categories.

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

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

The tool has zero parameters and the schema documentation coverage is 100%, so there is no parameter burden for the description to carry. The description correctly implies the owner is derived from the authenticated context without needing to elaborate.

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

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

The description names a specific verb ('Check') and resource ('earnings'), then enumerates exactly what is included: lifetime USDC, pending amounts, unclaimed rewards, payout-address balance, buyer spend, and reputation. It is clearly distinct from sibling tools like get_agent_contract or find_paid_work without needing to reference them.

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 intended use is clear from the phrasing 'Check how much I have earned and what is pending,' but there is no explicit guidance about when to choose this tool over alternatives, no stated exclusions, and no mention of related tools. Usage is implied rather than explicitly framed.

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 safety, so the description need not restate those. It adds no-key and no-payment context, but the juxtaposition of 'Price 0.01 USDC/query' with 'FREE preview' is confusng, and the sample questions could be read as promises of free answers even though the schema says the question is merely echoed back.

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 important fact 'no API key needed' is front-loaded and the whole text is short. But 'no key, no payment' and 'call this now' are repeated in different forms, and the emoji/call-to-action tone adds noise without much 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 two-optional-parameter, read-only preview tool with no output schema, the definition is mostly usable: parameters are fully described and annotations cover safety. The main gap is that the description does not state what the preview actually returns (metadata fields/sample rows) and does not name the paid query alternative, so an agent must infer those details from the schema and sibling names.

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

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

Both parameters' schema descriptions already fully document the slugh default and the echoed-back question, so the baseline is 3. The description adds a concrete slug value ('fdarecall') and two realistic sample questions, giving the agent immediately usable examples. It stops short of mapping those samples explicitly to the question parameter, so not a 5.

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

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

The title and input schema description clarify that this is a free, guest-callable preview of a listing's public metadata, and the description names a concrete target listing (fdarecall). It could be more precise as a standalone statement because the first line only says 'call this now,' but the overall definition makes the purpose clear.

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

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

The description repeatedly signals that this is the free, no-key, no-payment entry point, which contrasts with the paid session/query siblings. However, it never explicitly says 'use this before data_session_query' or 'use a data_session tool for full data access,' leaving when-not-to-use to inference.

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 (readOnlyHint=false, idempotentHint=true, destructiveHint=false), the description adds useful behavioral context: required auth methods, REST endpoint, the preference for open_tx_hash over proof_escrow_id, and the non-guest restriction. It does not contradict the annotations.

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

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

The description is compact and front-loaded: the main purpose appears first, followed by authentication, parameter preference, and the REST endpoint. Every sentence contributes meaningful information without fluff.

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

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

For a three-parameter tool with no output schema, the description provides sufficient context: purpose, auth, endpoint, parameter preference, and a pointer to the free preview. Minor gaps remain around how the escrow is consumed or how this relates to data_session_fund, but the core call is well specified.

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 only 33%, so the description must compensate. It does clarify that open_tx_hash is preferred and that proof_escrow_id is an alternative way to identify the escrow, and it connects session_id to an opened session. However, it does not explain proof_escrow_id's meaning in detail or the relationship between the two escrow identifiers beyond preference.

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 resource: 'Attach a buyer-funded proof escrow ... to an opened data session.' It also clarifies the commercial purpose (per-query access) and distinguishes itself from data_preview, making it clearly identifiable among siblings.

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

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

It gives clear context for when to use: after opening a data session, and it contrasts with data_preview ('first taste free'). It also states conditions like requiring an agent API key and not being guest-callable. However, it does not explicitly contrast with related siblings such as data_session_fund or data_session_funding_package.

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

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

Annotations already signal a state-changing, non-destructive, idempotent operation. The description adds useful context: platform-executes funding, per-query cost, and the free-preview path. It does not detail the mechanics of funds transfer or any prerequisites, but given the annotation coverage this is a reasonable but not rich disclosure.

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 dense sentences with no filler. The core action is front-loaded, and the listing detail plus workflow references to data_preview and data_session_query are all relevant.

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 a fully documented schema and reasonable annotations, the description covers the action, the specific listing, the cost, and the intended post-condition (can query). The prerequisite of opening a session is not in the description text, but the schema's parameter description supplies it, so the combined context is sufficient.

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

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

Schema description coverage is 100%; session_id is fully documented as the UUID from data_session_open. The tool description adds no session_id-specific meaning beyond the schema, so it meets the baseline without additional value.

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-resource pair: 'Buy per-query access to live data listings', and names the concrete listing (fdarecall) with its price. It references data_preview and data_session_query, but does not explicitly differentiate from closely related siblings like data_session_funding_package, so it is clear but not fully distinguishing.

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 conveys a workflow: try free via data_preview, fund this session, then use data_session_query. This gives clear context. However, it never contrasts this tool with the alternative funding-related siblings (data_session_funding_package, data_session_attach_escrow), leaving the selection among them implied rather than explicit.

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

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

Annotations already declare readOnlyHint and idempotentHint, and the description complements them by clarifying that the tool 'Returns fund instructions' rather than executing a purchase. It also adds the listing name, price, and prerequisite session, giving useful behavioral context beyond the annotations.

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

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

The description is two sentences with no wasted words. The main purpose is front-loaded, followed by concrete details about the listing and price, and the prerequisite is clearly stated.

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 strong annotations, the description is largely complete: it states what it does, the specific listing, the cost, when it returns instructions, and the prerequisite session. It could be slightly more explicit about the relationship to data_session_fund, but that is not essential for correct invocation.

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

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

The input schema has 100% coverage and already explains session_id as a UUID from data_session_open. The description's mention of 'after data_session_open' reinforces this but adds no new parameter-level meaning, so the baseline score applies.

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

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

The description clearly states the verb ('Buy') and resource ('per-query access to live data listings'), and it identifies the specific listing and price. However, it doesn't explicitly distinguish itself from the sibling data_session_fund, which could cause some ambiguity about which funding tool to invoke.

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 useful context: use data_preview for a free taste, and this tool returns fund instructions after data_session_open. However, it doesn't explicitly say when not to use this tool or contrast it with data_session_fund or data_session_attach_escrow, leaving the routing partially 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?

Annotations provide only default negative hints (readOnlyHint: false, etc.), so the description carries most of the behavioral burden. It adds useful context: pricing (0.01 USDC/query), a session cap (max 20 queries/session), and the workflow of opening then funding/querying. However, it does not disclose important behavioral details such as whether an on-chain transaction is required, what the return value/session identifier is, or what preconditions like open_tx_hash and proof_escrow_id imply.

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-loads the core purpose: 'Buy per-query access to live data listings.' The second sentence adds listing-specific pricing and a short workflow without excessive fluff. It is somewhat dense and mixes listing metadata with tool semantics, but every sentence earns its place.

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

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

For a tool with five parameters, no output schema, and zero schema-level parameter descriptions, the description is incomplete. It establishes the high-level workflow and pricing but omits essential invocation details: how the buyer address is used, what open_tx_hash and proof_escrow_id represent, and what the tool returns after opening a session. An agent would still need substantial inference or external knowledge to call this correctly.

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

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

Schema description coverage is 0%, so the description must compensate by explaining parameters. It names the specific listing_id value 'fdarecall' and implies max_queries via 'max 20 queries/session.' It says nothing about buyer_address, open_tx_hash, or proof_escrow_id, leaving three of five parameters unexplained and making correct invocation difficult.

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

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

The description clearly identifies the action as opening or buying per-query access to a live data listing, and the domain is specific: 'fdarecall: FDA recall enforcement database.' The phrase 'Open a prepaid session' matches the tool name and distinguishes it from later workflow steps like funding and querying. It does not explicitly name sibling tools for differentiation, but the workflow contrast with data_preview is present.

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

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

The description gives a clear usage context: try data_preview first for free, then open a prepaid session, then fund and query. This implies when to use the tool relative to siblings such as data_session_fund and data_session_query. It lacks explicit 'do not use when' exclusions, but the sequential guidance is strong enough to orient 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 are sparse (readOnlyHint=false, idempotentHint=false, destructiveHint=false), so the description carries the burden of explaining the paid, consumptive nature of the call. It discloses the 0.01 USDC cost per query, the 20-query session cap, and the specific data listing. It does not cover what happens on failed queries or how results are returned, but the key consumption behavior is transparent and consistent with the annotations.

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

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

Three short sentences, each earning its place: the paid-access model, the listing/price/quota, and the required session sequence. Information is front-loaded and no filler is present.

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 is strong on selection and sequencing: which listing, what it costs, what to open/fund first, and the free preview route. But without an output schema and with 5 parameters only 40% covered, the missing semantics for k and delivery_receipt, plus unspecified query syntax, leave an agent with gaps for a fully confident call. It is adequate for a basic required-parameter invocation, not 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 40%, so the description needs to compensate for undocumented parameters, but it does not explain k, delivery_receipt, or the expected query format. The only parameter-related context is that the query targets the fdarecall FDA recall listing and that queries are paid/limited. This leaves the central 'query' parameter and the optional k/receipt parameters under-specified for correct invocation.

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 identifies a specific resource (the fdarecall FDA recall listing) and the commercial transaction (per-query paid access), and the sequence line makes clear this tool executes the query step. It is distinguishashable from data_preview, data_session_open, and data_session_fund. However, the core action 'run a query' is stated more in the sequence/schema than in the description's own verb.

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 an explicit prerequisite sequence: data_session_open -> data_session_fund -> data_session_query, and mentions data_preview as the free first-taste alternative. This tells an agent when to use this tool and what must happen before calling it. No comparable guidance is needed beyond that.

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 useful behavior beyond that by describing ranked matches and total count for pagination, which signals how results are ordered and how to page through them. It does not go into deeper edge cases, but the annotations lower the bar for disclosure.

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 sentence that front-loads the verb and resource, lists the key filters, and closes with the return behavior. There is zero wasted wording, and it is immediately scannable.

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 100% schema coverage and the presence of an output schema, the description is complete enough for an agent to correctly select and invoke the tool. It captures the essence of discovery, ranking, and pagination without needing to enumerate all nine parameters or the result structure.

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

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

Schema description coverage is 100%, so the baseline is 3. The description mentions capability, minimum reputation, and optional semantic search, which map to existing parameters but adds no information beyond what the schema already provides. Other parameters like limit, offset, verified, and include_unreachable are left entirely to 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 uses a specific verb ('Find') with a clear resource ('agents') and states the main selection criteria: capability, minimum reputation, and optional semantic search. This is enough to distinguish it from sibling tools like get_agent_contract or find_paid_work, since the target resource is unambiguously 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?

The description clearly implies when to use it: whenever the agent needs to discover or search agents by filters. It does not explicitly name alternative tools or state when NOT to use this tool, so it falls short of a 5, but the context is clear enough to guide selection against the listed 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 readOnlyHint, idempotentHint, and non-destructive behavior. The description adds useful behavioral context beyond that: no API key required, case-insensitive capability matching, testnet preference, and the fact that a matched subset is returned. 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 four short sentences with no wasted content. The most urgent detail ('No API key needed — call this now') is front-loaded, followed by purpose, filtering guidance, return behavior, and the follow-up action.

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

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

For a simple read-only lookup with three optional parameters and an output schema, this description is complete: it covers invocation requirements, filtering strategy, return content, and the next step. An agent has enough to call it correctly without further inference.

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

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

Schema description coverage is 100%, so the baseline is 3. The description adds meaning beyond the schema by noting case-insensitive matching and advising testnet preference for cold-start, which helps the agent choose parameter values correctly.

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: 'Find paid work... on the A2AWire job board.' It also explains what the tool returns—'open jobs plus a matched subset for your skill'—which clearly distinguishes it from earnings or agent discovery siblings.

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

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

The description gives strong usage context: call now, no API key needed, prefer testnet for cold-start, and then call start_job to begin earning. It lacks explicit when-not-to-use guidance or named alternatives, but the discovery-to-execution flow 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, idempotentHint, and non-destructive behavior. The description adds value beyond annotations by stating that no API key is needed, that the response is identical to /.well-known/agent.json, and that the schema_hash should be matched for validation. 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-loads the most important guidance ('No API key needed — call this now'). The second sentence repeats 'fetch' but adds the validation workflow, so it earns its place. Slightly more could be trimmed, but it remains efficient.

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 parameters, a full output schema, and annotations that cover side effects and idempotence, the description is complete: it tells the agent when to call, what it returns, how it maps to the standard agent.json, and how to use the hash for validation.

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 schema description coverage is 100%, so the schema already fully documents the empty input and the authenticated-principal derivation. The description has nothing to add about parameters, so the baseline 4 applies.

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

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

The description clearly states the operation: fetch the hash-verifiable AgentContractV1 descriptor with version, schema_url, and schema_hash, plus hosted_runtime facts, and equates it to /.well-known/agent.json. It is specific and readable, though it does not explicitly name verify_contract as the sibling for the separate verification step, so it stops just 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?

No API key needed — call this now is an explicit when-to-use signal, and 'before acting' tells the agent to invoke this early. There are no exclusions or alternatives named, but for a zero-parameter discovery tool the usage context is clear enough.

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

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

Annotations already indicate readOnly, openWorld, idempotent, and non-destructive behavior. The description adds meaningful behavioral context by revealing the internal state-machine logic and stating that the tool returns pre-filled arguments. This goes beyond simply repeating annotation metadata, though it does not delve into edge cases or variability of the recommendation.

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 opening question immediately communicates the tool's purpose, and the state-based examples are packed into a parenthetical that is easy to scan. Every sentence earns its place.

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

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

Given the zero-parameter schema, the presence of an output schema, and annotations covering safety, the description is complete. It explains what the tool returns, how the recommendation is derived, and why it is useful. Nothing essential is missing for an agent to call it correctly.

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

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

The tool has zero parameters, and the schema description explicitly states that the owner is derived from the authenticated principal. With no parameters to document, the description does not need to add parameter-level detail; the baseline for zero-parameter tools is appropriate.

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

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

The description clearly states a specific verb and resource: it returns a single recommended next tool with pre-filled arguments. It differentiates itself from sibling tools by positioning itself as a meta-level advisor that reasons over the user's current state rather than performing a domain 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?

The description gives explicit context for when to use the tool: whenever the user asks 'What should I do next?' and provides a state-based mapping (unregistered → register; unverified → start admission; verified → accept matching paid work or explore the board). It also explains the benefit over manually reasoning through the catalog, though it does not name specific sibling tools as 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 destructiveHint=true and readOnlyHint=false, and the description adds meaningful process detail: it creates escrow, funds it on-chain with USDC, executes the task, and returns the result. It also conveys that this is a real on-chain financial action, which is important context. It does not contradict the annotations, though it stops short of discussing irreversibility or failure/refund behavior.

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 with no filler: the first states the core action, the second details the operational steps, and the third identifies the target integrator. The most important information is front-loaded, and every sentence earns its place.

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

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

For a complex, money-moving tool, the description covers the essential behavioral flow and audience, while annotations cover the side-effect profile and the output schema covers return values. The only notable gap is explicit discussion of failure cases, escrow refunds, or what happens if the hired agent cannot complete the task.

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

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

Schema description coverage is 100%, so the baseline is 3 and the schema already documents all three parameters. The tool description adds some context—'searches by capability' and 'funds the escrow on-chain (USDC)'—but it does not meaningfully compensate beyond the schema. The schema's own top-level note about the buyer agent being derived from the authenticated principal is also important but is part of the schema, not 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 opens with a specific verb and resource: 'Hire an agent from the marketplace to execute a task.' It then enumerates the concrete steps (search, escrow, funding, execution, result), making it unambiguous what the tool does. The 'one-call bridge' framing also helps distinguish this integrated operation from the more granular data_session_* and discover_agents siblings.

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

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

The description gives clear usage context by positioning this as 'the one-call bridge for local orchestrators (Claude Code, Cursor, etc.) to use the marketplace.' This implies it is the integrated path versus step-by-step alternatives, though it does not explicitly state when not to use it or name which sibling tools should be used instead for finer-grained control.

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 behavioral detail beyond annotations by specifying exactly what data is returned and the fact that the owner is derived from the authenticated principal (from the input schema description). This gives the agent a clear model of what the call will do without side effects.

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 with no filler words. It front-loads the purpose question and then lists the returned components in a readable sequence. It could be slightly overlong with the compound list, but every clause contributes meaningful information, so it earns a high score.

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

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

For a read-only, zero-parameter status tool with an output schema present, the description is fully sufficient. It tells the agent what it will receive, that no arguments are needed, and how the ownership context is determined. Annotations cover the mutation/safety profile, so nothing essential is missing.

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

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

The tool accepts zero parameters, so there are no semantic gaps to fill. The schema description explicitly states 'No arguments' and clarifies that the owner is derived from the authenticated principal, which is helpful context. The baseline of 4 for zero-parameter tools applies here.

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 direct question that anchors the tool's purpose, then states a specific verb ('Returns') and the resource (onboarding state). The return items are concrete and detailed: registered agents, capability manifests, progress checklist, testnet config, and actionable next steps. This clearly distinguishes it from siblings like register, discover_agents, 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?

The phrasing 'Where am I in onboarding?' plus 'exactly what you can do now vs. still need' gives a clear context for when an agent should call this tool: whenever it needs a current status of the onboarding process. It does not explicitly name alternatives or say when not to use it, but the purpose is narrow enough that the context is unambiguous.

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

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

Annotations are nearly empty (readOnlyHint false, no idempotency/destructive info), so the description carries the burden. It honestly discloses that registration is free, requires no wallet, and that it unlocks paid tools with a specified price (0.01 USDC/query). It doesn't describe side effects (e.g., creating keys, provisioning wallet) in detail, but the schema descriptions cover those well. 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 short and front-loaded with the most actionable information ('call this now', 'no wallet needed'). The emoji and promotional tone add noise but don't obscure the message. Every sentence conveys either a requirement (none) or a benefit (unlock tools, price). It's appropriately sized for a registration tool.

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 15 optional parameters and a very rich input schema (100% coverage), the description doesn't need to explain parameters. The output schema exists and the sibling list includes related onboarding tools. The description tells the agent this is free and now, and what it unlocks. It could mention that all parameters are optional (though the schema implies it), but the context is sufficiently complete.

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

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

Schema description coverage is 100% with rich per-parameter descriptions, so the baseline is 3. The tool description itself adds little parameter-level meaning beyond telling the agent no wallet or API key is needed to call it. The schema does the heavy lifting; the description doesn't need to compensate.

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 ('call register') and the resource (this session) and what it unlocks: 'purchase tools for fdarecall'. It also conveys the purpose as an onboarding/registration step. However, it doesn't explicitly contrast with sibling 'onboard_start' or 'get_api_key' semantics, so it lacks explicit sibling differentiation. The title 'Register / Get API Key' reinforces but the description itself doesn't name a sibling alternative.

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

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

The description gives strong when-to-use context: 'No API key needed — call this now' and 'call register on this session to unlock the purchase tools.' It implies this is the first step before using paid query tools, and the context signals plus schema (0 required params) support that. It does not explicitly name alternative tools or state when NOT to use it, but the guidance is clear enough for an agent to know this is the onboarding action.

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 what the agent can expect: the returned fields and the fact the ABI summary covers deposit/release/verify signatures. 'Independently' also hints at a direct on-chain call rather than a cached value.

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 action ('Independently verify'), then lists the concrete return details in a compact, readable form. There is no filler or repetition of schema/annotation 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 zero parameters, no input guidance is needed. The description states exactly what is returned, the output schema covers structured details, and annotations handle the safety profile. The tool definition is fully adequate for correct invocation.

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

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

The tool has zero parameters and schema description coverage is 100%, so the baseline 4 applies. No parameter explanation is needed; the description's focus on return values 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 ('verify') and resource ('EscrowVault on-chain'), then enumerates the exact return items: address, chain id, RPC, explorer link, USDC token, and ABI summary. This clearly sets it apart from sibling tools like data_session_attach_escrow or get_agent_contract.

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

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

The phrase 'Independently verify the EscrowVault on-chain' establishes a clear context: use this tool when you need to confirm contract details directly from the chain. It does not explicitly name alternatives or exclusions, so it stops 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.