Ontario Protocol

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

Annotations already declare readOnlyHint, openWorldHint, idempotentHint, and non-destructive behavior. The description adds useful context that this is a free pre-payment check and reinforces that no actual spending occurs, which aligns with the annotations. No contradiction exists.

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

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

Two compact sentences, front-loaded with the core purpose. Every clause contributes to understanding the tool or its default usage, 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 the rich annotations, 100% schema coverage, and presence of an output schema, the description is largely complete for invoking the tool correctly. The only gap is the lack of explicit guidance distinguishing this preflight decision from sibling tools like x402_readiness_verify.

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

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

Schema description coverage is 100%, so the schema carries the parameter meaning. The description adds marginal value by clarifying the default result and when to set require_audit_receipt, but most parameter semantics are already fully documented in the schema.

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

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

The description clearly identifies the tool as a pre-payment policy decision for an x402 endpoint, using specific policy categories (strict, standard, permissive). It is distinct from the sibling tools in topic, though it does not explicitly name a counterpart to differentiate against.

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

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

The description gives clear context for when to use the tool—before paying an x402 endpoint—and provides a concrete default behavior: the free result is sufficient unless a settlement-backed receipt is required. It does not explicitly mention alternatives or when not to use the tool, 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.

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

Annotations already declare readOnly, openWorld, idempotent, and non-destructive behavior. The description adds useful context beyond those: rate limiting, liveness, the fact that it excludes paid evidence/attestation, and that it returns 'safe signals and issues'.

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

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

Two sentences with no filler. The core function, limitations, and routing guidance are all present and front-loaded. 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?

Given the strong annotations, complete input schema, and presence of an output schema, the description covers what the tool does, its limitations, and when to switch to the paid alternative. Nothing critical is missing for correct invocation.

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

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

Schema description coverage is 100%, so the schema already documents target_url and agent_id thoroughly. The tool description adds no further parameter-specific meaning, but the baseline of 3 is appropriate because the schema carries the full burden.

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 what the tool does: it provides a live, rate-limited preview for one public endpoint and returns safe signals and issues without the paid evidence bundle. It explicitly differentiates itself from the paid trust scan, so an agent can distinguish it from siblings.

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

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

The description gives direct usage guidance: use the free preview for one public endpoint, and use the paid trust scan only when the preview is insufficient. It also constrains inputs to public endpoints, providing clear selection criteria.

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 goes well beyond the annotations by stating that the audit 'never signs or settles' and that quality counts may include owner-funded calls and are not revenue. It also clarifies 'Free read-only provider audit,' matching the readOnlyHint and idempotentHint while adding meaningful caveats that annotations alone could not convey.

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 dense and front-loaded with the core 'read-only provider audit' purpose. While the first sentence is long and lists many output types in a run-on structure, every clause contributes useful information and there is 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?

For a complex tool with an output schema, annotations, and three parameters, the description covers purpose, safety guarantees, data-quality caveats, and the main operational boundary. It does not explain how this tool relates to siblings or when a caller should pick it instead, which leaves minor contextual ambiguity.

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

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

Schema description coverage is 100%, and the schema already explains target_url and buyer_query well. The tool description does not add substantial parameter-level meaning beyond the schema, so the baseline score of 3 is appropriate; the 'five variations' behavior is already documented in the buyer_queries schema 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?

Description clearly names a specific verb-and-resource pair: it runs a read-only provider audit against one public x402 endpoint across CDP Bazaar buyer-search variations. It also enumerates the concrete outputs (retrieval coverage, sample ranks, price bands, activation boundary), which distinguishes it from sibling tools like x402_readiness_verify or find_x402_tool.

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

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

The description implies usage context: this is for auditing buyer visibility of an x402 endpoint and explicitly positions itself as free and read-only. However, it never explicitly states when to choose this tool over its siblings, nor does it name any alternatives or exclusion criteria, so the agent is left to infer routing.

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 readOnly/openWorld/idempotent annotations, the description discloses ranking behavior (task relevance plus bounded source-reported activity), the non-influence of paid Ontario publication on ranking, and the important caveat that the tool is not a safety certification. It also notes the search is free, providing cost semantics.

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 dense but efficient: the primary function is front-loaded, and every clause adds useful context (ranking criteria, budget filtering, safety caveat, provider-side routing). It could be slightly more readable due to heavy jargon, but there is 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 the output schema exists and annotations cover safety, the description provides the complete operational context an agent needs: what the tool searches, how rankings work, cost implications, non-certification warning, and explicit routing to alternative workflows. No critical selection or invocation information is missing.

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

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

Schema description coverage is 100%, so the schema already fully documents all five parameters. The description adds only light context such as 'Base/USDC budget filtering' mapping to network and max_usdc, but does not significantly enhance parameter understanding beyond the schema, yielding 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 states a specific action ('free buyer-side search'), names the concrete resources searched ('Ontario's fresh strict-ready paid profiles, Agentic Market, and Coinbase CDP Bazaar'), and distinguishes the tool from provider-side publication workflows. It also clarifies the tool's nature as discovery rather than certification, leaving no ambiguity about what it does.

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

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

The description explicitly says when to use this tool ('buyer-side search') and when not to ('provider-side publication intent'), and instructs to skip the marketplace search and instead return the listing validator and publication workflow. It also directs users to run readiness and can-pay checks before spending, mapping to sibling tools x402_readiness_verify and agent_can_pay.

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

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

Annotations already declare readOnlyHint, openWorldHint, idempotentHint, and non-destructive. The description adds meaningful behavioral context beyond these: it specifies the scan scope (what it checks), the output form (paths and remediation), and the key guarantee of never exposing source contents. This reassures an agent about safety and output boundaries.

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 filler. The first sentence front-loads the purpose and scope; the second clarifies outputs and a critical safety constraint. Every word adds value.

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 covers what the tool scans, what it returns, what it never returns, and its public-repo requirement. An output schema exists for return values, so no further explanation of the response shape is needed. Complete for an agent 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 100% for the single parameter repository_url, with a clear format and description. The tool description does not add extra semantic detail about the parameter (e.g., URL validation rules or expected format), but the schema already covers it adequately. Baseline 3 is appropriate.

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

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

The description states a specific verb ('scan'), a specific resource ('one public GitHub repository'), and enumerates the exact categories checked (x402 implementation, HTTP 402 tests, payment configuration, buyer documentation, discovery metadata, CI gates, sensitive filenames). It also clarifies what it returns (paths and remediation) and what it never returns (source contents). This distinguishes it from sibling audit/verification tools, which likely target broader or different scopes.

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 a pre-deployment use case but does not explicitly contrast this tool with the sibling tools like ontario_x402-implementation-audit or x402_readiness_verify. An agent would need to infer when to pick this over those. No exclusions or alternative-routing guidance is provided.

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 (readOnlyHint=false, openWorldHint=true, idempotentHint=false, destructiveHint=false) only hint at the tool's nature. The description carries the full burden and delivers: it discloses the paid cost (0.002 USDC via x402 on Base), the two-step payment protocol, the 'Readiness evidence is not a safety guarantee' caveat, and the budget/policy constraint. 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?

Purpose is front-loaded and the description is logically structured (purpose → inspected fields → returns → usage guidance → payment flow). However, the [PAID:...] block is a dense run-on sentence mixing payment protocol, legacy argument support, and signing cautions; it could be tightened without losing content.

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

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

For a complex paid tool with a two-step payment flow, an output schema, and policy constraints, the description is remarkably complete. It covers purpose, inputs, payment mechanism (both _meta and legacy _x402_payment paths), sequencing, budget/policy guardrails, and caveats. Nothing an agent needs to call it correctly is missing.

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

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

Schema coverage is 100%, so baseline is 3. The description adds meaningful value beyond the schema: it explains the _x402_payment legacy base64 support, the two-step retry mechanism with _meta['x402/payment'], and ties max_usdc/agent_policy to the concrete policy (0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913 and 0.002 USDC). This elevates it above the baseline.

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

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

States a specific verb+resource: 'Live x402 endpoint readiness check before payment' – it probes and verifies an x402 paid API before an agent pays. It enumerates what it inspects (HTTP 402 challenge, payTo address, price, Base USDC network/asset, manifest freshness, buyer budget, spend policy) and what it returns (ALLOW/DENY, readiness score, report ID, settlement metadata, SHA-256 evidence receipt), distinguishing it from siblings like find_x402_tool and x402_readiness_verify as the paid pre-payment verification service.

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 sequencing guidance: 'Run free can-pay and readiness checks first' and 'pay only when policy allows base 0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913 and 0.002 USDC is inside the agent budget.' It also names the two-step payment flow (call without payment, receive MCP PaymentRequired, retry with _meta['x402/payment']) and warns to 'Sign only after explicit budget and policy approval.' Nothing is left 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?

Annotations are sparse (readOnlyHint false, openWorldHint true, idempotentHint false, destructiveHint false), so the description carries the burden of behavioral disclosure. It transparently discloses that the tool is paid, the exact cost (0.01 USDC via x402 on Base), the two-step flow (call without payment to receive MCP PaymentRequired, then retry with payment), and the legacy parameter alternative. It also clarifies it is a point-in-time scan, not a readiness check. This goes well beyond the annotations and gives the agent essential operational detail. It does not, however, mention any rate limits or concurrency behavior, which is a minor gap given the context.

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

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

The description is long but densely packed with necessary operational details: purpose, usage order, payment mechanism, two-step flow, and legacy support. It front-loads the primary purpose and usage, then dives into payment specifics. While it could be trimmed slightly, every sentence carries critical information for a paid tool with a nontrivial flow. It is not bloated; the length is justified by the 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?

For a paid, two-step tool, the description covers the essential call sequence (without payment → PaymentRequired → with payment) and the legacy path. It also specifies the payment amount, token, and network. It does not describe the report content, but an output schema exists (per context signals), so that is handled. It also omits any mention of rate limits or idempotency, but annotations already flag idempotentHint false. Overall, the description is complete enough for an agent to successfully invoke the tool, with minor gaps that are unlikely to cause errors.

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

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

Schema description coverage is 100%, so the schema already explains all three parameters. The description adds minimal new parameter-level meaning: it repeats the target_url description, mentions the _x402_payment parameter's role in the two-step flow, and references agent_id as optional. The payment flow context is useful but is more about overall behavior than parameter semantics. Per the rubric, when schema coverage is high, the baseline is 3, and the description does not substantially enhance parameter understanding 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 opens with a clear, specific purpose: 'structured trust report for a public agent card or A2A endpoint before routing money or user work to it.' It also distinguishes itself from siblings by stating it is 'a paid point-in-time scan, not an endpoint-readiness check,' and references the free alternatives (can-pay, readiness checks). This leaves no ambiguity about what the tool does and how it differs from nearby 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 when-to-use guidance: 'Use when an agent needs a structured trust report... before routing money or user work to it.' It also prescribes a usage order: 'run free can-pay and readiness checks first; pay only when policy allows,' and explains the two-step payment flow. This is comprehensive and actionable, clearly steering the agent toward the correct workflow and away from premature payment.

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 mark this as a mutating, open-world operation, and the description aligns with that while adding critical context: the payment requirement, the two-step PaymentRequired flow, the legacy parameter support, and the explicit caveat that payment doesn't guarantee outcomes. This goes well beyond the annotations by disclosing the actual side effects and external dependencies.

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 longer than average but information-dense. The main use case is front-loaded, and the payment mechanics are bracketed for clarity. Each sentence serves a purpose—ownership condition, caution, payment workflow. No fluff, though it could be slightly tightened without losing 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?

With an output schema present, return values need no description. The description covers the prerequisite validation, the payment flow, and the risk caveat, making it sufficient for correct invocation. It doesn't elaborate on post-listing behavior or failure modes, but given the complexity of payment, the core requirements are addressed.

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 parameter meanings are already documented. The description adds substantial value for the payment parameter by explaining the two-step flow, the alternative legacy arg, and the signing condition. It does not explain the other parameters, but since the schema already does that, the baseline 3 is exceeded by the payment-specific guidance.

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 precise verb-object pair: 'submit a public directory listing' and explicitly states the ownership condition. It clearly separates this tool from siblings like ontario_validate-agent and ontario_agent-pay-query-v2 by describing the submission act, not validation or payment checks. The agent can immediately understand this is the tool to actually list an owned agent.

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 explicit when-to-use ('only when the caller owns the agent') and when-not (payment does not guarantee approval). It instructs the agent to run free can-pay and readiness checks first, implying alternative tools for those steps, and outlines the payment flow prerequisites. This is actionable guidance for routing to the correct tool.

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

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

Beyond the annotations, the description discloses the 0.50 USDC paid requirement, the x402 two-step flow, 30-day freshness maintenance, and explicit non-guarantees about Coinbase placement, ranking, traffic, purchases, readiness, and safety. No statement contradicts 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 organized into clear sections: main action, deliverables, eligibility, limitations, and payment guidance. It is dense but every sentence earns its place, and the most important purpose statement is front-loaded.

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

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

For an 18-parameter, paid, non-idempotent publication tool, the description covers prerequisites, fee, payment mechanics, outputs, eligibility, limitations, and agent payment policy. The rich schema and output schema handle remaining parameter-level detail, 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?

Schema coverage is 100%, so the baseline is 3, but the description adds meaningful payment semantics: the two-step call-without-payment flow, params._meta['x402/payment'] containing the signed PaymentPayload, and legacy _x402_payment base64 support. This goes beyond the schema's field-level 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?

Opens with a specific verb-resource pair: 'Publish a provider-owned x402 API so AI agents can discover and buy it.' It then details concrete outputs such as a signed public HTML/JSON profile, readiness evidence, badge, and MCP/catalog records, clearly distinguishing publication from validation or refresh sibling tools.

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

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

Gives explicit sequencing: run free can-pay and readiness checks first, pay only when policy allows, and retry with a signed PaymentPayload after receiving MCP PaymentRequired. It does not explicitly name sibling alternatives, but the context makes the when-to-use conditions 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 declare readOnlyHint=true, idempotentHint=true, and destructiveHint=false. The description adds critical behavioral details beyond this: 'This tool never invokes another tool, signs a payload, or spends funds.' It also states that empty calls return safe guidance rather than guessing a purchase. This provides strong transparency about side-effect-free behavior, exceeding what annotations alone convey.

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 long but each sentence carries meaningful information. It front-loads the core purpose and then expands on routing conditions and exclusions. No filler is present, and the structure logically flows from purpose to use cases to safety guarantees. It is slightly verbose but appropriately so given 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?

The tool has 5 parameters, an output schema, and 20 siblings. The description covers the main routing scenarios, the conditions for each path, and the no-side-effect guarantee. It does not explicitly enumerate all sibling tools, but it provides enough routing guidance for an agent to know which path to take. The output schema exists, so return details are not required in the description.

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 the schema already documents all parameters. The description adds value by connecting parameters to the routing logic: it mentions 'wallet, Base network, and explicit budget gates' which map to wallet_enabled, network, and max_usdc. It also clarifies max_usdc is a ceiling and not spending authority. This goes beyond the schema descriptions and helps the agent understand how parameters influence routing.

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: deterministic pre-purchase routing for Ontario tools. It specifies the verb (route), the resource (tasks across Ontario tools), and the decision outcomes (free-only, preflight, or paid). It distinguishes itself from siblings by focusing on routing before any paid tool, and explicitly notes it never invokes another tool, which is a unique differentiator.

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 any paid Ontario tool' and gives clear examples of when to use it for different task types (verification, publication, refresh). It also explains the conditions for each routing path (wallet, Base network, budget gates). However, it does not explicitly name alternative tools or state when not to use it, though the context implies it is a prerequisite.

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 clearly discloses the paid two-step x402 flow, PaymentRequired retry behavior, legacy _x402_payment support, and budget/policy approval requirements. This goes well beyond the annotations' false readOnlyHint and false idempotentHint, and nothing contradicts 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 scope and purpose, then restrictions, then payment guidance. It is dense and contains slight redundancy in the payment approval instructions, but every major detail serves a real decision: when to pay, how to pay, and what not to expect.

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

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

For a paid, state-changing refresh tool with an output schema present, the description covers the essential agent knowledge: eligibility, non-goals, included maintenance caveat, free-check-first workflow, exact payment amount/chain, two-step retry protocol, and approval gating. Nothing critical for correct invocation is missing.

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

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

Schema coverage is 100%, so the baseline is 3. The description adds meaningful payment-flow semantics beyond the schema: calling without payment first, retrying with params._meta['x402/payment'], and the legacy _x402_payment base64 argument. This improves agent understanding of how to populate and use the payment-related parameter.

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

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

The description names a specific verb/resource ('fresh live readiness observation attached to canonical HTML, JSON twin, and badge') and limits use to 'an existing paid Ontario provider profile.' It also differentiates from siblings by listing what the tool cannot do: edit metadata, improve grade by payment, or buy ranking/traffic.

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 explicit when-to-use ('existing paid Ontario provider profile' needing a fresh readiness observation), when-not-to-use ('cannot edit provider metadata... Do not pay while the launch passport's 30-day included maintenance is active'), and alternative behavior ('run free can-pay and readiness checks first'). The paid flow conditions are clearly stated.

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 goes well beyond the annotations by disclosing the paid nature, exact cost, two-step payment flow, the MCP PaymentRequired response, supported payment parameter locations, and the directive to sign only after budget/policy approval. This is substantial behavioral context that annotations alone do not provide.

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 dense but justified by the payment flow complexity. It front-loads usage and alternatives before payment mechanics. It is longer than ideal, but each section earns its place, and the bracketed payment details are clearly separated from the core usage guidance.

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

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

An output schema exists, so the description need not explain return values. The description covers when to use it, when not to, the alternative tool, payment prerequisites, the exact two-step invocation flow, and policy constraints, leaving no critical gap 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?

Schema description coverage is 100%, so the schema already documents both parameters. The description adds value by explaining how _x402_payment is obtained, that it supports a legacy base64 form, and that the modern flow uses params._meta['x402/payment'], which the schema alone does not convey.

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: a 'cheapest accumulated reputation lookup' for an agent with a stable agent identifier. It explicitly contrasts with 'Agent Trust Scan' for fresh scans, so an agent can distinguish this tool from its 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 explicit when-to-use guidance ('Use when an agent already has a stable agent identifier'), a clear alternative with the condition that selects it ('Use Agent Trust Scan instead when there is no usable history or a fresh card scan is required'), and even ordering advice for payment checks ('run free can-pay and readiness checks first').

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?

Discloses data flow: with allow_typesafe=true, task and tool descriptions go to TypeSafe; warns not to supply secrets; states Ontario does not persist task text; mentions TypeSafe policies and zero retention not promised; says never executes tools or authorizes payment; fallback on quota exhaustion. This is rich behavioral disclosure beyond annotations.

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

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

The description is a single dense paragraph with all sentences contributing safety, mode, or behavior details. It's longer than minimal but each clause is necessary.

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?

Covers purpose, data handling, safety, return value, and fallback. With an output schema present and thorough parameter descriptions, 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?

Schema descriptions are exhaustive for all six parameters (100% coverage), and the tool description does not add further parameter semantics beyond what the schema already states.

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

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

Description states 'Free task-to-tool matching with an optional Jev second opinion' and clarifies it 'Returns a callable tool and input schema, or abstains.' This clearly defines the action and resource, and distinguishes it from sibling tools that target specific functions (e.g., find_x402_tool, ontario_purchase_router).

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 implies usage as a generic matcher but doesn't explicitly contrast with siblings. Mentions optional Jev second opinion and deterministic router, giving context on when each mode is used, but no explicit 'use this when...' guidance. However, the clarity of its role as a matcher is sufficient.

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 readOnlyHint=false and destructiveHint=false, but the description adds meaningful behavioral boundaries: 'Never publishes, signs or spends' and 'for free.' These clarify side-effect risks beyond the structured flags. It does not discuss other potential side effects, but the key safety constraints are disclosed.

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

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

The description is two short sentences with no redundant phrasing. The primary action is front-loaded, and the critical exclusion ('Never publishes, signs or spends') is stated immediately. Every word adds value.

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

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

The tool is moderately simple with a complete input schema and an output schema, so the description need not cover return values. It covers the purpose, timing, cost, and key side-effect constraints. It does not mention prerequisites like authentication, but for a validation tool this is not a significant 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?

Schema description coverage is 100%, so all six parameters are already fully documented. The description only refers to them collectively as 'an agent listing payload' and adds no additional meaning beyond the schema. Baseline 3 is appropriate.

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

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

The description names a specific verb ('Validate') and resource ('agent listing payload') and adds the scope 'before publication.' The sentence 'Never publishes, signs or spends' clearly differentiates it from sibling tools such as ontario_list-agent or payment-related tools, even without naming 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 phrase 'before publication' gives clear timing context for when to use the tool. However, it does not explicitly mention alternatives or state when not to use it, nor does it name any sibling tools. The usage guidance is 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?

The description explicitly claims the tool 'Never refreshes, signs or spends,' which implies a read-only operation. However, the annotations set readOnlyHint to false, directly contradicting that claim. Per the rubric, any contradiction between description and annotations results in a score of 1.

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 extremely concise and front-loaded: the core purpose is stated in the first sentence, and the second sentence adds an essential safety clarification. There is no filler or redundant repetition of schema or 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?

Given the output schema exists and the parameter schema is well-covered, most invocation details are present. However, the contradiction between the read-only claim and readOnlyHint=false creates critical uncertainty about whether this tool can have side effects, which prevents the description from being fully contextually 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 both listing_id and paid_refresh_tx already described in the input schema. The description does not add parameter-level meaning beyond the schema, which matches the baseline of 3 for high schema coverage.

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

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

The description clearly states a specific action ('Check') on a specific resource ('an existing paid provider profile's refresh eligibility') and includes distinguishing details like 'for free' and 'including cooldown.' It also explicitly differentiates itself from refresh/sign/spend operations, making it easy to distinguish from sibling tools such as ontario_refresh-listing.

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 context for when to use the tool: when you need to check refresh eligibility and cooldown status without performing a paid action. The phrase 'Never refreshes, signs or spends' acts as an exclusion, indicating this is a validation-only step, although it does not name specific sibling 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?

The description discloses nontrivial side effects and limitations: no listing publication, no signing or spending, verify_now optionally creates a public readiness report, and a valid payload alone does not establish readiness or Bazaar placement. This goes well beyond the annotations, which only provide general hints.

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

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

Three sentences are packed with necessary information and no filler. The main purpose is front-loaded with 'Free provider listing preflight,' followed by timing, return behavior, and explicit safety exclusions. 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 tool with 18 parameters, the description gives the essential decision framework: when to call, what happens, what does not happen, and how verify_now changes behavior. The output schema covers return values, and the 100% schema coverage covers parameters, so nothing critical is missing. It could still briefly point to the named sibling publishing tool, but the guidance is otherwise 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%, so the input schema already documents all 18 parameters. The description adds useful context about the overall flow, such as the 0.50 USDC fee and the preflight role, but it does not add per-parameter meaning beyond the schema. Baseline 3 is appropriate.

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

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

The description states a specific verb and resource: validate public service metadata as a free preflight before the Ontario launch passport purchase. It clearly distinguishes the tool from the listing/publishing siblings by saying it never publishes a listing, signs, or spends.

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 timing context: use it before buying the 0.50 USDC launch passport. It also explains the conditional use of verify_now and explicitly excludes publishing/signing/spending. It does not name the sibling tool ontario_list-service as the alternative for actually publishing, but the exclusion 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 declare readOnlyHint false and openWorldHint true, but the description goes far beyond by disclosing the paid nature, the exact payment amount and token address, the two-step flow (call without payment → MCP PaymentRequired → retry with payload), and the legacy _x402_payment argument. It also discloses a key limitation: 'omission does not establish independence.' No contradiction with annotations; it adds substantial behavioral context about payment and caveats.

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 dense but well-organized: purpose first, then payment guidance in brackets. Every sentence carries necessary information; no filler. It is longer than average because the payment mechanics are complex, but the structure front-loads the core purpose and separates operational details. It could be tightened slightly, 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 the tool's complexity (payment, two-step flow, classification logic), the description covers purpose, usage conditions, payment details, and behavioral constraints. It does not describe the output format, but an output schema exists (has output schema: true), so that is covered elsewhere. For an agent to know when and how to call this tool, everything needed is present. 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%, so each parameter already has a description. The tool description adds value beyond the schema by explaining the payment workflow for _x402_payment (two-step flow, signed payload, legacy base64 alternative) and clarifying that related_addresses omission has no independence implication. This is extra semantic detail that helps an agent correctly construct parameters. Baseline 3 is elevated to 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 opens with a specific verb-resource pair: 'separate observable Base USDC settlement evidence from unsupported independent-demand claims.' It enumerates concrete actions (detect direct self-payments, classify receipts, measure payer concentration) and explicitly states a negative ('does not call unknown wallets customers'), which distinguishes it from siblings like ontario_agent-trust-scan or x402_verification_reports. The purpose is unambiguous and actionable.

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 begins with 'Use when...' which is explicit context. It gives clear prerequisites: run free can-pay and readiness checks first, and pay only under policy and budget conditions. It does not name specific alternative tools or state 'do not use when X', but the conditions and the two-step payment flow are sufficient for an agent to decide when to invoke it. The guidance is concrete and tied to policy.

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 thoroughly discloses the paid nature, the two-step payment flow (call without payment, receive PaymentRequired, retry with payment payload), and the legacy argument support. It also clarifies that it returns findings without source contents or secret values. This adds substantial context beyond the annotations, which only provide generic hints (readOnlyHint false, etc.) and do not cover payment specifics.

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 longer than typical but front-loads the core purpose and then details payment flow. Every sentence contributes necessary operational information for a paid tool, so the length is justified. It could be trimmed slightly, but it is well-organized with the primary use case first.

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 (paid, two-step flow, multiple focus areas, two input modes), the description covers all essential aspects: when to use, how to pay, what it returns (and doesn't return), and the parameter relationship. The output schema exists, so return format is already specified, and the description doesn't need to repeat that.

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 the baseline is 3. The description adds value by explaining the payment workflow tied to the _x402_payment parameter and clarifies the either/or relationship between endpoint_url and repository_url through the anyOf constraint. This goes beyond the schema's individual 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 clearly states the tool performs a bounded, task-specific x402 code review for a public endpoint or GitHub repository, listing the areas of findings (payment, discovery, security, debugging, launch). It is specific enough to distinguish from generic code review tools, but does not explicitly name or contrast with sibling tools like github_x402_repo_scan or x402_launch_kit, so it misses 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 advises when to use it ('provider or developer needs a bounded, task-specific x402 code review') and gives ordering guidance ('run free can-pay and readiness checks first; pay only when policy allows'). It implies using other tools first but does not explicitly name alternatives or exclusions, leaving some inference to the agent.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true, openWorldHint=true, and destructiveHint=false. The description adds meaningful context by specifying that the output is 'validated' and scoped to 'one paid endpoint,' and its 'Generate' wording is consistent with a non-destructive, read-only drafting operation. No contradiction exists.

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

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

A single dense sentence that front-loads the action and then lists the specific outputs. Every word earns its place, and the scope constraint 'for one paid endpoint' adds precision without padding.

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

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

Given the rich input schema, output schema, and safety-revealing annotations, the description is largely complete: it names all artifact types and the scope. The only notable gap is the lack of relationship to sibling tools and workflow timing, which is partially captured under usage guidelines.

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 input schema already documents all ten parameters thoroughly. The description adds no additional parameter-level semantics beyond framing the tool as producing artifacts for one paid endpoint, which is appropriate given the schema already carries the burden.

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

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

The description begins with a specific verb, 'Generate,' and enumerates six concrete deliverables (listing payload, x402 resource draft, MCP descriptor, GitHub readiness workflow, README snippet, registry copy) for a paid endpoint. This makes the tool's purpose immediately distinguishable from generic or sibling operations.

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

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

The description provides no guidance on when to use this tool versus alternatives such as ontario_list-service, ontario_validate-service, or x402_readiness_verify. It states what is generated but not the intended workflow position, prerequisites, or situations where another sibling would be more appropriate.

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 carry the safety profile (not read-only, not idempotent, not destructive), and the description adds useful behavior: the check is free, it returns two handoffs, and payment/publication should wait until readiness. It does not explain any side effects that may follow from readOnlyHint=false, so the behavioral picture remains partial.

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, but it packs jargon like 'end-to-end buyer-path diagnostic handoff' and 'grade-aware provider handoff' into one dense sentence. Every sentence contributes, but the phrasing is harder to parse than it needs to be.

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

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

With one well-documented parameter, an output schema, and annotations present, the description covers the essential purpose, sequence, and payment caution. It is complete enough for call selection, though it could refine the meaning of 'ready-grade' or name sibling tools to make routing easier.

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 target_url is already described in the schema at 100% coverage, including the warning about credentials and private hosts. The main description adds little parameter-specific detail beyond calling the endpoint 'paid' and tying it to publication, so the schema earns the baseline 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 opens with a specific purpose: 'Free check for whether a paid endpoint is ready for agent discovery and x402 payment.' This names a verb, resource, and condition, and the added context about publication places it before payment steps. It does not explicitly name or contrast any sibling tool, so it stays one step below the clearest possible purpose statement.

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

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

The description explicitly tells the agent to 'validate listing metadata free before any optional 0.50 USDC publication' and to 'not pay for publication while the endpoint is not ready-grade.' This gives clear when-to-use and when-not-to-pay guidance, though it never names alternative tools or states when to switch to them.

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

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

Annotations already declare readOnlyHint, openWorldHint, idempotentHint, and non-destructive behavior, so the safety profile is well covered. The description adds that the data is public and recent, which is mild contextual value, but it does not describe pagination or what a report contains.

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

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

One short sentence with no filler; 'public' and 'recent' add meaningful scope and the description is front-loaded. It could be improved by an explicit verb, but as written it is economical and to the point.

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 simple read-only tool with one fully documented parameter and an output schema does not require extensive prose, but the description is too terse to fully orient an agent among many x402-related siblings. Some usage context or a pointer to a complementary tool would complete it.

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

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

The single parameter limit is fully documented in the schema, including a default and description. The tool description repeats 'recent public readiness reports' but adds no semantic detail beyond the schema's parameter description, so the baseline 3 applies.

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

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

The description characterizes the tool as a public ledger of recent x402 readiness reports, making the resource and scope clear and separating it from action-oriented siblings like x402_readiness_verify. It lacks an explicit verb such as 'list' or 'retrieve,' so the operation is inferred rather than stated.

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

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

No guidance is given about when to use this tool versus sibling tools such as x402_readiness_verify, x402_launch_kit, or ontario_x402-implementation-audit. An agent must infer the use case entirely from the resource description and the readOnlyHint.

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