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

Annotations already declare readOnlyHint, openWorldHint, idempotentHint, and destructiveHint=false, covering safety. The description adds context like 'stable anonymous' and 'accountless', which is useful but does not disclose behavioral details such as pagination, response ordering, or rate limits. With annotations present, 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 two sentences, front-loaded with the action and resource, and contains no fluff. Every word adds value, and it is easy to scan.

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 browsing tool with 3 optional parameters and no output schema, the description provides enough context for initial selection: what it does and when to use it. However, it omits mention of response format or pagination behavior, which would be helpful but is not critical given the parameters imply output shape.

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 provides 100% coverage with descriptions for all three parameters (limit, include_trust, include_schemas). The tool description does not add additional parameter-level semantics beyond reinforcing its catalog role, so it meets the baseline but does not exceed it.

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

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

The tool name and description clearly state the action ('Browse') and the resource ('stable anonymous x402 services' on x402.agoragentic.com). The phrase 'accountless buyer catalog for bounded paid resources' adds scope, but it does not explicitly contrast with sibling tools like agoragentic_search or agoragentic_categories, so it falls short of full differentiation.

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

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

The description includes a direct usage instruction: 'Use this as the accountless buyer catalog for bounded paid resources.' This provides clear context for when to apply it, but it lacks explicit exclusions or references to alternative tools, preventing 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 only indicate readOnlyHint false, openWorldHint true, etc., but the description discloses the critical payment behavior: an unpaid attempt yields a Payment Required payload, and a retry with payment_signature completes the call. It does not cover failure modes beyond payment but sufficiently reveals the tool's non-read-only, payment-gated nature.

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

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

Two sentences with minimal redundancy. The first sentence states the core purpose, and the second explains the retry mechanism. Every word earns its place; no filler.

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

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

The tool has a non-trivial payment flow, and the description explains the two-step invocation pattern clearly. It also notes the first response type (Payload Required) and the retry condition. While no output schema exists, the description conveys enough context for an agent to invoke it correctly. It could mention the final success response, but the phrase 'complete the paid call' implies the service result.

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 all four parameters, so the baseline is 3. The description clarifies that payment_signature is only for the paid retry, matching the schema's 'used on the paid retry.' It does not add extra meaning beyond the schema's descriptions, but the high coverage means no deduction.

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 'Call one stable x402 service by slug,' a specific verb and resource that clearly identifies the tool's action. It distinguishes from siblings like quote/browse by focusing on execution and the payment retry flow. The title 'Call x402 Service' reinforces this purpose.

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

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

The description provides clear guidance on the two-step payment flow: first unpaid attempt returns Payment Required, then retry with payment_signature. However, it does not explicitly compare to sibling tools or state when to choose this over quote_service/browse_services, though the 'call' vs 'quote' distinction is implicit.

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

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

Annotations already declare readOnlyHint, openWorldHint, idempotentHint, and destructiveHint false, covering the safety profile. The description adds behavioral context by specifying that it lists all categories and includes capability counts, which goes beyond the annotation metadata.

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

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

The description is a single, front-loaded sentence containing only essential information: what the tool lists and what it returns. No fluff.

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

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

For a zero-parameter, read-only list tool, the description fully specifies both the action and the expected result (categories with capability counts). The annotations and lack of output schema do not require additional disclosure.

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, so the baseline score is 4. No parameter explanations are needed, and the description doesn't attempt to add any.

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 the specific verb 'List' and identifies the resource as 'all available listing categories,' additionally specifying it returns the count of capabilities per category. This clearly distinguishes it from sibling tools like search or browse_services.

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 no explicit guidance on when to use this tool versus alternatives. It does not mention any exclusions or refer to sibling tools, so the agent receives no contextual decision support.

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 safety. The description adds the 'anonymous' qualifier and the source host, but does not explain return format, error behavior, or pagination. 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 a single, front-loaded sentence conveying action, resource, and identifier. No filler or redundant content.

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

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

For a simple one-parameter read-only fetch, the description, annotations, and schema are sufficient. There is no output schema, but the return value (a receipt) is self-evident from the purpose. Slightly more detail on the return format would improve completeness, but the current definition is adequate.

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

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

Schema coverage is 100% and includes a helpful description for receipt_id (returned in Payment-Receipt header). The tool description does not add semantic detail beyond the schema, so baseline 3 applies.

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

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

The description uses the specific verb 'Fetch' and clearly identifies the resource as 'one anonymous x402 edge receipt by receipt ID', distinguishing it from sibling tools like verify_receipt or settlement_check. This makes the tool's purpose unambiguous and distinct.

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 explicit guidance on when to use this tool versus alternatives such as interchange_verify_receipt. The description implies use when you have a receipt_id, but it does not state exclusions or name alternative tools, leaving context slightly 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?

With no annotations, the description fully discloses behavioral traits: potential USDC spending, non-idempotence, required environment variable, error handling (missing_api_key), and detailed success/failure response structures.

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?

Well-structured and efficient: key action upfront, critical warnings in bold, usage guidance, then return format. Every sentence adds value, and the length is appropriate for the tool's complexity.

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

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

Given no output schema, the description fully specifies success/error JSON structures. Parameter documentation is thorough, and sibling tool context is provided. The description adequately covers all necessary information for tool selection and 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?

Although schema coverage is 100%, the description adds valuable context beyond property descriptions: examples for each parameter, explanation of dependencies (e.g., quote_id links to agoragentic_quote), and clarifies that input shape depends on provider API.

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 verb ('Execute a task') and resource ('Agoragentic Router / Marketplace'), explaining the flow (selects provider, invokes, returns result with receipt). It distinguishes from sibling tools by advising to use agoragentic_match for preview and agoragentic_search for discovery.

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

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

Provides explicit guidance on when to use this tool vs alternatives ('Prefer agoragentic_match first...', 'Use agoragentic_search...'), and warns against using it for read-only discovery. Also notes potential USDC spending and non-idempotency, setting clear user expectations.

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?

No annotations are provided, so the description fully carries the burden. It states it is read-only, has no side effects or USDC spend, requires an environment variable, and describes error responses (missing_api_key, invalid_invocation_id). This is comprehensive.

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

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

The description is concise and front-loaded with purpose. It is a single paragraph that covers all necessary aspects. Minor improvement could be structuring the return JSON fields, but it is still effective.

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

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

For a simple one-parameter tool with no output schema, the description is remarkably complete. It covers purpose, usage, prerequisites, error cases, and return fields. No gaps remain for the agent.

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

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

Schema coverage is 100% with a description of invocation_id. The tool description adds context about the expected format ('inv_abc123def456') and validation errors, which enhances understanding beyond the schema.

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

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

The description clearly states the tool checks status, output, cost, and receipt of a previous invocation. The verb 'check' and resource are specific, and it distinguishes from siblings like agoragentic_execute (launch) and agoragentic_edge_receipt (edge receipts).

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

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

The description explicitly says to use this for polling async results or retrieving receipt metadata. It does not explicitly exclude other uses, but the context is clear. No sibling differentiation is stated, but the purpose 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 declare readOnlyHint=true and idempotentHint=true, so the safety profile is known. The description adds value by explaining the verification method (hash recomputation, signature tamper detection) and the anonymous operation mode, which are not obvious from annotations alone.

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 redundant information. It front-loads the action ('verify') and resource, then adds the operational details (anonymity, input modes) efficiently.

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

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

The tool has no output schema, so the description should explain what the result of verification looks like (e.g., valid/invalid, tamper status). It does not state the return value or behavior on tampering, leaving a gap in the agent's understanding of the tool's outcome.

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 described. The description adds meaning by clarifying the relationship: 'stored receipt_id' versus 'presented receipt JSON', and the 'and/or' usage implies that either one or both can be provided. This goes beyond the basic schema fields.

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: verify a minted interchange receipt using hash recomputation and signature tamper detection. It specifies the resource (interchange receipt) and differentiates from sibling tools like 'edge_receipt' or 'validation_status' by detailing the verification mechanism.

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 implicitly conveys when to use this tool (for verification of receipts) and states it works anonymously with either a receipt_id or a presented JSON. However, it does not explicitly mention alternatives or when not to use it, but the context is clear enough for an agent to decide.

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?

No annotations are provided, so the description fully carries the burden. It discloses that the tool is read-only, non-destructive, has no side effects, and describes error conditions ('missing_api_key'). It also details the output structure (matched providers, trust scores, estimated cost, routing rationale).

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 about 4 sentences, well-structured with the main purpose front-loaded. Every sentence adds value without redundancy. It is concise and informative.

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 complexity (4 parameters, no output schema, many sibling tools), the description is complete. It covers purpose, usage, behavioral traits, error handling, and expected output, providing an agent with all necessary context.

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

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

Schema coverage is 100%, so baseline is 3. The description does not add parameter-specific information beyond what the schema already provides. Each parameter is well-documented in the schema, including defaults for 'prefer_trusted'.

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: 'Preview which providers the Agoragentic Router would select for a given task, without executing or spending USDC.' It uses specific verbs and resources, distinguishing it from siblings like agoragentic_execute.

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

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

The description explicitly says 'Use this before agoragentic_execute to compare providers, check pricing, and verify availability.' It provides clear usage context and mentions the API key requirement, though it lacks explicit when-not-to-use instructions.

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 substantial behavioral context beyond annotations: mode-specific return types, anonymous vs authenticated execution, and specific auth setup for stdio and HTTP. The word 'Create' might suggest mutation, but readOnlyHint, idempotentHint, and the overall context make clear this is a compute/read operation. 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?

Four sentences with a front-loaded core action, followed by conditional usage and auth context. Every sentence is informative and there is no redundancy or 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 tool with 10 optional parameters, two modes, and auth requirements, the description covers the primary behaviors, return values, and auth setup. It does not cover edge cases like conflicting parameters, but the schema fills in parameter-level details adequately.

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?

All 10 parameters have schema descriptions, so baseline is 3. The description adds value by grouping parameters into modes (task constraints vs listing identifiers) and clarifying that slug is a listing alternative, which helps the agent understand which parameters to use together.

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

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

The description clearly states it creates a router-aware quote and explicitly distinguishes two modes based on parameters: task+constraints returns ranked providers, while capability_id/listing_id/slug returns a listing-specific price, trust snapshot, and next-step guidance. This specificity distinguishes it from sibling tools like quote_service and browse_services.

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 provides clear conditional usage: pass task+constraints for task mode, or capability_id/listing_id/slug for listing mode. It also explains auth requirements per mode (anonymous for listing, API key for task). However, it does not explicitly state what to do when multiple mode identifiers (e.g., task and capability_id) are passed together, nor name alternative tools.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true, and destructiveHint=false, so the bar is lower. The description adds value by confirming 'without spending' and enumerating key response fields (retry behavior, trust metadata, sample input, exact payable URL), which provides behavioral context beyond the annotations. It does not mention error cases or rate limits, but the added context is meaningful.

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

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

The description is a single, front-loaded sentence that immediately states the core action and then lists return contents compactly. Every word earns its place, with no filler or repetition.

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

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

Given that there is no output schema, the description compensates well by naming the key return components (price, retry behavior, trust metadata, sample input, exact payable URL). It could be more complete by mentioning error behavior if the slug is invalid, but for a simple read-only quote tool with strong annotations, the coverage is adequate.

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% for all four parameters, so the baseline is 3. The description only reiterates 'by slug' and adds no additional meaning to parameters like include_trust or max_price_usdc beyond what schema descriptions already provide. No credit beyond baseline is warranted.

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 ('Quote') and resource ('one stable x402 service by slug'), and lists the exact return type (price, retry behavior, trust metadata, sample input, payable URL). This clearly differentiates it from siblings like agoragentic_call_service (which would spend) and agoragentic_browse_services (which likely lists many services).

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 tool is for quoting a known slug before spending, and the phrase 'without spending' hints at a safe pre-call step. However, it does not explicitly state when to use this over agoragentic_quote or other siblings, nor does it provide exclusions or 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?

Beyond the annotations, the description discloses the returned key, the side effect of binding the key to the current session, and the conditional behavior for already-authenticated sessions. It also gives concrete key-persistence mechanisms, which is valuable operational context not available in 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 front-loaded with the core action and output, then adds necessary behavioral and persistence details. Despite being somewhat long, every sentence contributes meaningful information and there is no fluff or repetition of schema fields.

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 no output schema, the description compensates by explaining the return value (API key), the access implications, and authentication edge cases. It also tells the user how to persist the key for future sessions in both transport modes, making the tool fully usable end-to-end.

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

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

The input schema covers both parameters completely with descriptions and enum values (100% coverage), so the description does not need to repeat them. The description adds no extra semantic detail about agent_name or agent_type 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 ('Register') and resource ('as a new agent on Agoragentic'), and immediately states the return value (API key and access to authenticated surfaces). This clearly distinguishes it from sibling tools like browse, search, and call, none of which handle registration.

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

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

The description gives clear context for when registration is useful, including the session-bound behavior for unauthenticated vs already-authenticated sessions. It also provides explicit persistence instructions for stdio and remote HTTP, though it does not name alternatives or exclusions since no sibling tool offers registration.

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, openWorldHint=true, idempotentHint=true, and destructiveHint=false. The description adds context beyond that by specifying 'public capabilities' and 'directly,' and by clarifying that quoting/invoking are separate optional steps. This enhances behavioral understanding without contradicting annotations.

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

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

The description is two sentences long, with the first sentence front-loading the primary purpose and the second clarifying the usage context. Every sentence earns its place, and there is no 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 that the schema covers all parameters, annotations cover safety, and there is no output schema, the description is concise yet sufficiently complete for a search tool. It could optionally mention result format or pagination, but that's not essential given the schema's thoroughness.

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

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

Schema description coverage is 100%, and all four parameters have clear descriptions in the schema. The description does not add any additional parameter-level semantics. Baseline 3 is appropriate since the schema already handles parameter meaning.

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 construction: 'Search Agoragentic supply-side listings directly.' It distinguishes from external marketplace search by saying 'Agoragentic' and 'directly,' and from quote/invoke tools by mentioning those as optional follow-ups. This clearly identifies the tool's core function.

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

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

The description provides clear usage context: 'Use this when you want to browse public capabilities, then optionally quote or invoke a specific listing by ID.' It indicates a typical workflow but does not explicitly mention when not to use it or name alternatives. This is clear context without 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 already establish readOnly, idempotent, non-destructive, and closed-world behavior. The description adds a valuable behavioral guarantee—no paid service is invoked—and specifies the breadth of status information returned, which is not covered by 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 a single, front-loaded sentence with no redundancy. It packs the action, the list of resources, and a key qualifier into a compact form, making it easy for an agent to parse 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?

For a read-only listing tool with strong annotations and full parameter schema coverage, the description provides enough detail to invoke correctly. It omits return structure, but the low complexity and the explicit scope make it 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?

The single parameter include_inactive is fully documented in the schema with a clear description (100% coverage). The tool description adds nothing beyond that, so the baseline score of 3 is appropriate.

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

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

The description uses the specific verb 'List' and clearly enumerates the distinct resources: Agoragentic execution verifiers, Argent/Themis high-risk posture, lifecycle states, and optional external verifier readiness. This precise scope distinguishes it from sibling tools focused on quoting, receipts, settlement, or service calls.

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 'without invoking a paid service' gives a clear context for when to use this tool—as a cost-free readiness check before potentially paid operations. However, it does not explicitly name alternative tools or state when not to use it, falling just short of full exclusion 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?

Adds meaningful behavioral context beyond annotations: 'No auth, no spend', 'confirms settlement only', and explicitly lists what it does not verify. Annotations already declare readOnlyHint=true, idempotentHint=true, destructiveHint=false, and the description adds no contradictions.

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

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

Three sentences, each earning its place. Front-loaded with the core purpose, then scope expansion, then safety and limitation caveats. No redundant phrasing 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?

Comprehensive for the tool's complexity: covers scope, exclusions, parameter pairing rule, and behavioral limitations. Minor gap: no description of what the tool returns (e.g., simple boolean or structured details), but no output schema exists to fill that gap.

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

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

Even though schema coverage is 100%, the description adds critical semantics not in the schema: the constraint that 'amount must be accompanied by a payTo or payer' and that amount is 'matched as >='. This directly affects how to set parameters together.

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

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

States a specific verb+resource+scope: 'check that a Base-mainnet USDC transfer settled on-chain' with optional matching. Explicitly distinguishes from siblings by saying 'not just Agoragentic invocations' and excludes non-USDC assets.

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

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

Provides clear context for when to use (any USDC-settled x402 payment on Base, yours or received) and exclusions (non-USDC assets out of scope). Does not explicitly name alternative tools, but the scope and limitations ('does not verify service delivery, output quality, or counterparty identity') help decide applicability.

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

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

The description discloses the 402 challenge-response behavior ('Returns the PAYMENT-REQUIRED challenge until you retry with a payment signature') and adds safety context ('without spending real USDC'). Annotations already provide non-destructive/idempotent hints, so the description adds valuable flow details without 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?

A single sentence that is front-loaded and packs essential information: purpose, cost-free nature, and the challenge/retry behavior. No wasted words or redundancy with schema fields.

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 simple two-parameter, no-output-schema design, the description covers the core behavior (what it returns, how the retry works) and safety (no real USDC). It omits potential edge cases or exact response structure, but for a test utility this 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 coverage is 100% for both parameters, so the schema already documents them. The description adds minimal extra meaning by referencing 'retry with a payment signature' and 'echo back once the test signature is supplied', but this is mostly restating schema intent. Baseline 3 applies.

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

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

The description clearly states the tool's purpose: to test the x402 402->sign->retry pipeline without spending real USDC. It uses a specific verb ('test') and resource ('x402 pipeline'), and the 'without spending real USDC' nuance differentiates it from production payment tools 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?

The description implies usage context by calling it a 'test' and highlighting 'free' and 'without spending real USDC', which indicates it is for experimentation. It does not explicitly name alternatives or exclusions, but the context is clear enough in this sibling set to guide selection.

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

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

With readOnlyHint, idempotentHint, and destructiveHint=false already provided, the description adds specific behavioral context by enumerating the no-operations (no-execution, no-spend, etc.), which clarifies the safety profile beyond generic hints. It aligns with annotations and enhances understanding of the tool's non-mutating nature.

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, concise sentence that is front-loaded with the verb and directly states the tool's scope. Every word contributes to the meaning, with 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?

This is a simple, no-parameter explanation tool. The description fully conveys the tool's purpose and behavior. While there is no output schema, the act of 'explaining' implies a textual answer, and the description is sufficient for a low-complexity tool.

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

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

The tool has zero parameters, so the baseline is 4. The description does not need to explain parameter semantics, and the empty schema covers all parameters with 100% coverage. No additional parameter information is required.

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 'Explain' and clearly identifies the resource: the boundary for external marketplace search, listing four precise constraints (no-execution, no-spend, no-settlement, no-trust-mutation). This distinguishes it from sibling tools that actually perform marketplace operations or searches.

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 that this tool is for understanding the boundaries of external marketplace search, but it does not explicitly state when to use this tool over alternatives, nor does it mention exclusions or when not to use it. The context is only implied by the nature of the explanation.

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

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

Annotations already declare readOnly, idempotent, and non-destructive. The description adds that it provides a 'no-execution handoff preview', which clarifies that no execution occurs. However, it doesn't elaborate on what the preview contains or any other behavioral traits.

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, compact sentence with no wasted words. It is front-loaded with the verb and resource. Minor jargon ('local public-safe', 'no-execution handoff preview') slightly reduces clarity but doesn't hurt conciseness.

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, single-parameter, read-only tool backed by strong annotations, the description provides enough context about what the tool does and that it includes a non-executing preview. There is no output schema, but the tool's simplicity mitigates the need for more 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?

Schema coverage is 100% with a clear description for the single parameter, so the schema carries the semantic weight. The tool description does not add additional parameter meaning beyond what the schema 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 clearly states the action ('Inspect') and the resource ('one local public-safe external supply candidate'), and mentions a 'no-execution handoff preview' which suggests additional output. However, it does not explicitly distinguish itself from sibling tools like 'preview_external_handoff' or 'search_external_marketplaces'.

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 explicit guidance on when to use this tool versus alternatives. The description implies usage after search (for a specific candidate ID), but does not state when not to use it or mention alternative tools.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true, and destructiveHint=false, covering the safety profile. The description adds that the output includes 'normalized source snapshots,' which hints at the response content but does not describe pagination, ordering, or other behavioral details. This is adequate but not rich, given 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 a single, concise sentence that starts with the action verb 'List' and immediately states the resource. There is no redundant wording, and every phrase contributes meaning.

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, parameterless list operation with strong annotations, the description is mostly complete. It states what is listed and hints at the output type, but without an output schema, some ambiguity remains about the exact structure of 'normalized source snapshots.' Still, for this level of complexity, it 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?

The input schema has zero parameters, so the schema itself provides full coverage (100%). The description does not need to explain parameter semantics, and the baseline for zero parameters is 4.

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

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

The description uses the specific verb 'List' followed by a clear resource: 'local public-safe external supply sources and normalized source snapshots.' This states the tool's domain and scope, and it is distinct from sibling tools like 'search_external_marketplaces' and 'inspect_external_supply_candidate.' However, it does not explicitly call out those alternatives or their relationship, so it falls short of a 5.

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

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

The description implies the tool is for retrieving a specific subset of external supply sources (local public-safe) and normalized snapshots, but it gives no explicit guidance on when to prefer this over searching or inspecting other marketplaces. There is no mention of exclusions or alternative approaches, making the usage context clear only by 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?

Annotations already declare readOnlyHint=true, idempotentHint=true, and destructiveHint=false. The description adds valuable behavioral context by specifying that the receipt is 'redacted' and explicitly rules out writing, opening external services, and executing payments—details beyond the annotations. 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 a single sentence with no redundant words. It is front-loaded with the core action ('Preview a redacted external marketplace handoff receipt') and includes only essential constraint 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?

The tool has no output schema, but the description sufficiently indicates that it returns a redacted receipt preview and that it is side-effect-free. Given the read-only annotations and all optional parameters, this is adequate for an agent to invoke it correctly, though the return structure is not detailed.

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% description coverage for all three parameters, so the baseline is 3. The tool description itself adds no parameter-specific meaning; it neither reinforces nor supplements the schema's parameter descriptions.

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

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

The description uses a specific verb 'Preview' and a clear resource 'redacted external marketplace handoff receipt'. It explicitly contrasts with side-effecting actions by stating 'without writing a receipt, opening an external service, or performing execution/payment', effectively distinguishing it from sibling tools that write or execute.

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 conveys when to use this tool: when a side-effect-free preview of a handoff receipt is needed. The three 'without' clauses provide useful exclusion criteria. However, it does not explicitly name alternative tools or state when not to use it, missing the full 'when/when-not' structure.

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. The description adds value by detailing the specific non-performed operations and the 'public-safe' qualification, enriching the behavioral context without contradicting any 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 a single, front-loaded sentence that efficiently communicates the core action and its safe boundaries. The long negation list is information-dense and earns its place by preventing misuse.

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 9 optional parameters, full schema coverage, and no output schema, the description clarifies the tool's metadata-only scope and explicitly excludes raw payload exposure. It could benefit from describing the return structure, but the simple read-only search nature makes it reasonably complete.

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

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

Schema description coverage is 100% for all 9 parameters, so the schema fully documents parameter semantics. The description adds no extra parameter-level detail, aligning with the baseline score of 3.

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 the specific verb 'Search' with a clear resource: 'local public-safe external marketplace supply metadata'. It also distinguishes itself from action-oriented siblings by explicitly listing what it does not do (call, execute, submit, etc.), making its purpose 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?

The negative list ('Does not call, execute, submit, spend, settle, rank, trust, verify, ready, publish, or expose raw payloads') provides explicit when-not guidance, implying this tool is for safe, read-only metadata exploration. It doesn't name alternatives but gives clear exclusions to guide tool selection.

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