CrossingKey MCP

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

Beyond the annotations, it discloses the cost ($0.10 USDC on Base via x402), that invoking it does not spend funds, and that it returns a PAYMENT-REQUIRED challenge plus the canonical paid endpoint. That is genuinely useful behavioral context for a paid tool. It does not conflict with readOnlyHint=false.

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, front-loaded with the cost and non-spending clarification, each carrying useful information. Slightly dense but no wasted filler.

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

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

With an output schema present, return values needn't be described, and the description covers the key payment model, cost, and the fact that calling is free. It omits when to prefer this over alternatives, but is otherwise complete for a single-param paid 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?

Schema description coverage is 100%, so the schema fully documents the artifacts array and its name/content fields. The description only restates 'supplied text artifacts,' adding no syntax or format detail beyond the schema, so the baseline of 3 applies.

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

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

The description states a specific verb+resource: 'Creates deterministic SHA-256 entries and a root manifest hash for supplied text artifacts.' This distinguishes it from the generic hash.encode sibling by emphasizing manifest/root-hash aggregation, though it never names alternatives explicitly.

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 explains the payment mechanics ('PAID $0.10 USDC... Calling this MCP tool does not spend funds') but gives no when-to-use guidance, no exclusions, and no routing to siblings like hash.encode or execution.preflight. The agent must infer when this paid manifest is the right choice.

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, destructiveHint=false and openWorldHint=false, so safety is covered. The description adds genuinely new behavioral context with 'FREE' (no cost incurred), which the annotations do not convey, plus the nature of the returned marketplace data.

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

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

A single dense sentence, front-loaded with the 'FREE' signal and then the parameter routing. Nothing is wasted, though the compressed phrasing makes the two modes slightly harder to parse than a short structured list would.

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 return values need not be explained. With zero required parameters, the description adequately signals that either name or capabilityId is the entry point, though it never states outright that at least one must be supplied.

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 would be 3. The description adds meaning beyond the schema by characterizing name as 'legacy deterministic' and capabilityId as 'public marketplace' metadata carrying rights and provenance, sharpening the distinction between two nearly identical-looking string parameters.

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

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

Names the resource (capability) and distinguishes the two lookup modes clearly: 'legacy deterministic capability metadata' via name versus 'public marketplace metadata, rights and provenance' via capabilityId. It does not explicitly differentiate itself from the sibling capability.search tool, which is the main gap.

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 routes the agent between the two parameters ('use name for X or capabilityId for Y'), which is useful selection guidance. However it gives no when-to-use context relative to alternatives such as capability.search or marketplace.describe, and no exclusions or prerequisites.

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, destructiveHint=false and a closed world, so safety is covered. The description adds genuinely non-obvious behavior: metadata search is free while purchased execution and deliverables are not, and results are limited to active public listings. It stops short of noting pagination limits, which the schema already documents.

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 tight sentences with the scope banner front-loaded and every prohibition paired with a redirect. No filler, and the routing information is placed where an agent will read it 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?

With an output schema present and annotations covering the safety profile, the description only needs to establish scope and routing, which it does completely. Nothing required to call this 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 description coverage is 100%, so all eight parameters (query, category, provider, deliveryType, price bounds, limit, offset) are already documented in the schema. The description enumerates the same filter dimensions without adding syntax, units, or format guidance beyond the schema, so baseline 3 is correct.

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 (search) and resource (active public marketplace capabilities) and immediately constrains the scope to filtered discovery. It explicitly distinguishes itself from catalog.list, offers.list, and capability.get by name, so an agent can route without opening schemas.

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 when-to-use ('when one or more filters are known') and two explicit when-nots with named alternatives (catalog.list for unfiltered browsing, offers.list for CrossingKey offers), plus a routing note to capability.get for exact IDs. This is the full when/when-not/alternative pattern.

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

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

Annotations already cover the safety profile (readOnly=true, destructive=false, openWorld=false), but the description adds substantive context the annotations cannot: metadata is free while execution, entitlement, delivery, and purchased output remain gated, and only 'active public' entries are returned. It does not describe pagination limits or result ordering, so it falls short of a 5.

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

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

Front-loaded with the key scope constraint in caps, then each subsequent sentence handles one concern (usage, gating, exclusions). Dense but every sentence earns its place; the all-caps opening is slightly heavy-handed.

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 paginated list tool with an output schema present, the description covers scope, gating semantics, and sibling routing, so return-value explanation is correctly omitted. Ordering/filtering guarantees on the returned list are the only notable 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% and both parameters (limit, offset) are fully documented with ranges and defaults, so the schema does the heavy lifting. The description's 'page through' phrase reinforces the pagination intent but adds no format or syntax detail beyond the schema. 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?

States a specific verb ('page through') and resource ('active public marketplace capabilities'), and explicitly distinguishes itself from three named siblings (capability.search, offers.list, capability.get). An agent can route correctly without opening any schema.

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?

Explicitly states when to use it ('no search filters are needed') and when not to, naming the alternative tool for each exclusion (filtered discovery -> capability.search, CrossingKey offers -> offers.list, exact id -> capability.get). 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 already declare readOnlyHint=true, destructiveHint=false, openWorldHint=false, so the safety profile is covered. The description adds genuinely useful context beyond them: 'A quote grants no entitlement and performs no execution,' and it names the pricing components returned. It doesn't mention quote validity/expiry or refresh behavior, which would matter for a pricing artifact.

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?

Front-loads the scope in the first clause and is dense with routing information, but the 'Do NOT use ... use cost.estimate' pattern appears twice with the same alternative, which is mildly redundant. Slightly longer than needed but every remaining sentence carries routing 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?

With an output schema covering return values, full annotations, and a single fully documented parameter, the description covers everything an agent needs: the prerequisite (active capabilityId), the safety profile, the boundaries, and the next step for execution.

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?

Only one parameter and schema description coverage is 100%, so the schema already documents capabilityId fully. The description's 'active marketplace capabilityId' phrasing adds no syntax or constraint detail beyond the schema's 'Exact active public marketplace capability identifier.' 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?

States a specific verb and resource ('return authoritative gross price, CrossingKey fee, provider share, and x402 v1/v2 payment requirements' for a marketplace capabilityId). It explicitly distinguishes itself from cost.estimate and capability.purchase, so an agent can route without opening any schema.

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 when-to-use ('after selecting an active marketplace capabilityId'), two explicit when-not cases (first-party paid capabilities; generic price lookup) each paired with the alternative to use instead, plus the follow-on tool for execution. 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 already declare readOnlyHint=true, destructiveHint=false, and openWorldHint=false. The description adds that the tool is free and explicitly never creates checkout, reserves funds, or contacts a facilitator, which is useful behavioral context beyond the annotations.

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

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

Two sentences are efficiently used: the first front-loads the key qualifiers 'FREE read-only', and the second lists explicit negative side effects. No wasted words, and the most important information comes 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?

With a rich output schema and annotations, the description provides adequate safety and cost information. However, it omits when to choose this tool over quote-related siblings, leaving a minor gap for agent selection.

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 single parameter item_id is fully documented in the schema. The description adds no additional parameter meaning, making the baseline score of 3 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 verb and resource (cost estimate) but essentially restates the tool name; it does not explain what is being estimated or differentiate from siblings like commerce.quote. The added 'FREE read-only' is behavioral context, not purpose clarification.

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 on when to use this tool versus alternatives such as commerce.quote or offers.list. The description only offers negative constraints about what the tool does not do, leaving the agent to infer appropriate usage.

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 a write operation (readOnlyHint=false) with destructiveHint=true. The description adds valuable context beyond annotations: 'No ownership transfer' clarifies the scope of the write, and 'AI training defaults false' discloses a privacy default. These are specific behavioral traits that help set expectations, though the description does not explain what exactly gets created or destroyed.

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 with no wasted words. However, 'FREE WRITE' is cryptic and the fragmented sentences (sentence fragments) make it slightly less front-loaded and clear, but overall it is 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 (write operation, destructive hint, nested object parameter, and an output schema), the description is adequate but minimal. It covers privacy and ownership defaults but leaves the core action ('intake' process) and the meaning of 'capability model' unexplained. The output schema exists, so return values need not be described.

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 parameters are fully documented in the schema. The description does not add any meaning beyond what the schema provides (e.g., it never mentions 'provider' or 'summary'). Baseline 3 is appropriate when the schema does the heavy lifting.

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 presents 'private creator intake' as the purpose but uses a noun phrase rather than a clear verb+resource. It does not distinguish from sibling tools like provider.register or marketplace.describe, and 'capability model' is jargon that isn't defined. The action (submitting an intake) is implied but not stated explicitly.

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?

There is no guidance on when to use this tool versus alternatives, nor any prerequisites or context for invocation. The constraints ('No ownership transfer and AI training defaults false') describe behavior but not usage conditions.

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

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

Annotations already declare readOnlyHint=true, destructiveHint=false, and closed-world scope, so safety is covered. The description adds useful non-annotation context: that it is free, that new prepaid-credit sales are disabled in v4, and that historical credits are redeemable via a separate compatibility path — real behavioral/product-state context beyond the schema.

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

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

Two tight sentences with the 'FREE read-only' descriptor front-loaded and the compatibility caveat second. No filler, though the second sentence leans toward product-state trivia rather than tool behavior.

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

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

With zero parameters and a declared output schema, the description need not explain return values, and it supplies enough framing (legacy/compatibility status, free read-only) for correct invocation. It stops short of saying what the status enumerates, but nothing critical is missing for a parameterless read.

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

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

The tool takes zero parameters, so there is nothing for the description to disambiguate; the baseline of 4 applies. No misleading parameter claims are made.

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

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

The description communicates that this is a read-only status resource about legacy credit compatibility, and 'FREE' plus 'read-only' frame it as a query. However, it never states the actual verb or what the tool returns (a list of credit options? a status report?), leaving the precise purpose vague even if the general domain is clear.

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

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

There is no explicit guidance on when to call this tool versus siblings, nor any named alternative. The mention of 'legacy' and 'historical paid credits' implies the tool is only relevant in a compatibility scenario, but the agent must infer that condition rather than being told it.

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 destructiveHint=false, so the safety profile is covered. The description still adds useful context beyond them: it explicitly disclaims authorization, purchase, settlement, execution, and record creation, and names the sole return state. No output details are needed since an output schema 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?

Front-loaded and compact: the defining trait ('FREE read-only') and the return value come first, followed by a tight negation list. The list of five negative verbs is slightly redundant but each forecloses a plausible misreading of 'execution'.

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 annotations covering safety, an output schema covering the return, and full schema coverage on the only parameter, the description is nearly complete for the call mechanics. The remaining gap is ecosystem-level: no routing guidance among many closely related audit/check siblings in a 21-tool set.

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 single parameter item_id is fully documented in the schema, including its provenance from offers.list. The description adds no syntax or format detail beyond the schema, so the baseline of 3 applies.

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

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

The description states the tool is a 'read-only execution preflight' that returns READY_FOR_HUMAN_AUTHORIZATION, which conveys the gating/readiness function more than the name alone. However, 'preflight' is abstract and the description never clarifies what the check actually validates, nor distinguishes it from close siblings like requirements.check, result.preview, machine_commerce.readiness_audit, or x402.compatibility_audit.

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 never says when to call this vs. any of the ~20 sibling tools, nor what prerequisite state (e.g., a prior offers.list call) is needed before invoking it. The only implicit guidance is 'FREE' implying it is cheap to call, which is weak.

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 signal readOnly=false, openWorld=true, idempotent=true, destructive=false. The description adds substantial behavioral context beyond that: the exact cost ($0.01 USDC), the chain (Base), the protocol (x402), and critically that calling returns a payment challenge and does not autonomously spend funds. It stops short of describing the post-payment flow, but the safety profile is well covered.

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

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

Three compact sentences with zero filler, front-loaded with the payment terms and followed by purpose then the no-autonomous-spend guarantee. Efficient, though leading with the payment model before the function slightly delays the core verb+resource.

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 tool with an output schema (so return values need no explanation) and full schema coverage, the description supplies the essential payment and safety context. It is close to complete, with the only gap being how a challenge is fulfilled, which the x402 sibling tools can cover.

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

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

With one parameter at 100% schema description coverage, the schema already carries the constraint (maxLength 65536 UTF-8 bytes). The description alludes to 'supplied text' and the UTF-8 byte count but adds no format, encoding, or edge-case detail beyond what the schema 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?

States a specific verb and resource: 'Computes a SHA-256 digest and UTF-8 byte count for supplied text.' No sibling in the list performs hashing, so the operation is unambiguous and immediately distinguishable from the x402/audit siblings that merely inspect payment paths.

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 discloses that the call is paid and returns a payment challenge rather than spending funds, which is important context for deciding to invoke it, but it gives no explicit when-to-use or when-not guidance and names no alternative for obtaining a hash or handling x402 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?

With annotations already covering safety (readOnlyHint=false, openWorldHint=true, idempotentHint=true, destructiveHint=false), the description still adds real behavioral context: the $0.01 USDC cost on Base via x402, the fact that a payment challenge is returned, and the assurance that it does not autonomously spend funds. The only weak point is the vague 'May return supplied content' clause.

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

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

Three sentences with no padding. The pricing/payment sentence is front-loaded, though an agent might prefer the functional purpose statement before the commercial terms; still, every sentence carries 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?

An output schema exists, so return values need not be described, and annotations carry the safety profile. For a one-parameter tool, the description adds the material facts an agent needs — cost, payment-challenge behavior, and no autonomous spending — leaving nothing essential 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?

There is a single parameter with 100% schema description coverage ('Input text, maximum 65536 UTF-8 bytes'), so the schema fully documents it. The description adds no syntax, format, or edge-case meaning beyond that, so the baseline of 3 applies.

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

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

The description gives a specific verb+resource: 'Validates JSON and repairs a limited set of formatting errors.' It is clear what the tool does, but it offers no differentiation from the many sibling x402-related tools and never contrasts its scope with alternatives.

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 only implied: an agent can infer you call it when you have malformed JSON to fix. There is no explicit when-to-use, when-not-to-use, or named alternative, and the phrase 'May return supplied content' adds ambiguity rather than guidance.

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

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

Annotations declare openWorldHint=true and idempotentHint=true but readOnlyHint=false, which alone would not tell an agent that no money moves. The description resolves this by explicitly stating the call does not spend funds and returns a payment challenge plus the paid execution endpoint, which is the critical non-obvious behavior. Auth requirements and rate limits are still unmentioned.

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 tight sentences that front-load the price and payment rail before the operational detail. Every sentence 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?

An output schema exists, so return values need not be described, and the description usefully adds the payment flow and the no-spend guarantee. Given the tool is paid and gated behind x402, it is adequately complete, though it omits any hint of what a failed or unauthorized audit looks like.

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?

Only one parameter ('url'), documented at 100% in the schema with a clear description of what to supply. The description adds nothing about the url parameter or its format, so this sits at the baseline where the schema carries the semantics.

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 ('checks') and resource scope ('machine-commerce discovery and health surfaces'), so the intent is legible. It does not, however, differentiate itself from the many audit siblings (x402.compatibility_audit, mcp.launch_audit, openapi.quality_audit), and the phrase 'discovery and health surfaces' stays abstract about what is actually audited.

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

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

It clearly communicates the calling workflow: invoke this tool to receive the PAYMENT-REQUIRED challenge and canonical paid endpoint, without spending funds. That is genuine usage context, but no sibling alternative is named and no condition for choosing this audit over the other audit tools is 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?

Annotations already declare readOnlyHint=true, destructiveHint=false, and openWorldHint=false, so the safety profile is covered structurally. The description adds non-annotation context: the call is 'FREE' and it is an overview (not a deep query). It does not discuss rate limits or freshness, which is a minor remaining gap.

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

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

Two compact sentences, with the scoping and 'use first' cue front-loaded ahead of the alternative-tool routing. 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?

An output schema exists, so return values need not be described. For a zero-parameter read tool with full annotation coverage, the description supplies everything an agent needs: purpose, cost, when to call, and which sibling to prefer instead.

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

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

The tool takes zero parameters, so there is nothing for the description to disambiguate; the 4 baseline applies. The schema's additionalProperties=false is self-documenting.

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 and resource ('marketplace overview') and immediately names the sibling it is not ('use provider.describe for the broader CrossingKey provider and legacy offer surface'). An agent can distinguish it from provider.describe and the other 21 siblings without opening a schema.

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?

'Use this first for marketplace-specific capability commerce, fee policy, creator rights, payment rails, and active catalog counts' gives an explicit when-to-use condition, and the second clause names the alternative and its scope. 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 declare it is not read-only, idempotent, non-destructive and open-world, but they say nothing about cost. The description adds critical non-structured context: this costs $9.00 USDC on Base via x402 and that the audit itself attempts no payment. That pricing disclosure is exactly the kind of behavioral detail annotations cannot carry.

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 tight sentences with the cost (the highest-value fact) front-loaded, followed by the scope of checks and the non-payment clarification. No filler; only the first sentence's formatting ('PAID $9.00...') is slightly clipped.

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 not be described, and annotations cover the safety profile. The description supplies the missing pieces an agent most needs: price, mechanism (x402) and the reassurance that no payment is attempted. Adequate and well-targeted for a one-parameter audit 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?

There is a single parameter with 100% schema description coverage ('Public HTTP(S) MCP service base URL to audit'), so the schema already fully documents it. The description adds no syntax or constraint detail beyond that, so the baseline of 3 applies.

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

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

Clear verb (audits) plus resource (a public MCP endpoint) with an enumeration of the check types (discovery, health, transport, schema, receiver-only), which meaningfully separates it from a schema-only sibling like mcp.schema_audit. It never names those siblings explicitly, so the differentiation 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?

The phrase 'launch audit' and 'public endpoint' implies pre-launch use, but there is no explicit when-to-use/when-not-to-use guidance and no routing to alternatives such as mcp.schema_audit or x402.compatibility_audit. Usage context is implied rather than 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?

Annotations mark this as non-read-only but idempotent; the description resolves the apparent tension by clarifying that calling it does NOT spend funds and that it returns the PAYMENT-REQUIRED challenge plus the canonical paid execution endpoint. That is genuine behavioral context beyond the annotations (price, chain, asset, and two-phase payment flow), though error/rate-limit behavior is unstated.

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 tight sentences, front-loaded with the cost so the agent sees the payment implication first, followed by capability and the crucial 'no funds spent on call' clarification. No filler, though the payment sentence and the capability sentence could be compressed slightly.

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 explanation, and the description supplies cost, payment semantics, and input intent adequately for a one-parameter tool. The remaining gap is sibling disambiguation among the several audit tools, which matters given the crowded namespace.

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 there is a single required 'tools' array, so the schema already carries the parameter burden. The description's 'supplied MCP tool schemas' merely restates the parameter meaning without adding shape, size limits, or format guidance 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 states a specific verb and resource: it 'scores supplied MCP tool schemas for discoverability, descriptions, and bounded input contracts', and even enumerates the scoring dimensions. It does not, however, differentiate itself from the close sibling 'mcp.launch_audit' or from the other audit tools (openapi.quality_audit, prompt.audit), which an agent would need to disambiguate.

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 by the input ('supplied MCP tool schemas') and the payment-model framing reveals the calling pattern, but there is no explicit when-to-use/when-not statement and no routing to the sibling audits. The reader must infer selection criteria from the tool name.

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

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

Annotations already cover the safety profile (readOnlyHint=true, destructiveHint=false, openWorldHint=false), so 'read-only' is partly redundant. The description still adds value beyond them: 'FREE' (zero cost) and the explicit assurance that the tool will not initiate payment or execution flows, which matters in this commerce/payment-adjacent ecosystem.

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 short sentences, front-loaded with the tool's nature and then its hardest constraint. No filler, no restatement of the title, 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?

An output schema exists, so return values need no explanation, and annotations plus a fully documented schema cover behavior and inputs. The remaining gap is routing: with 28 siblings including several near-synonymous discovery tools, the lack of any disambiguation leaves the agent to guess.

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% — limit, query, and offset all carry their own descriptions, including the next_offset pagination hint. The description contributes nothing about parameters, so the 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?

States a specific verb (list/discovery) and resource (public offers and capabilities) and qualifies the scope as read-only and public. However, it never differentiates itself from close siblings like catalog.list, capability.search, or marketplace.describe, so an agent must infer which discovery surface applies.

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 clause 'never starts payment or execution' implicitly excludes the payment/execution siblings (commerce.quote, execution.preflight, x402.purchase_path_audit), which implies usage. But there is no positive when-to-use statement or explicit alternative named for the catalog/capability listing case.

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?

Goes well beyond the annotations by disclosing the cost ($1.00 USDC on Base via x402), the crucial non-obvious fact that calling it does not spend funds, and that it returns a PAYMENT-REQUIRED challenge plus the canonical paid execution endpoint. This reconciles the otherwise surprising readOnlyHint=false and fully explains the two-phase paid flow.

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 tight sentences with the price and payment model front-loaded, then purpose, then the non-spending clarification. Every sentence earns its place, though the leading price line is slightly jarring as an opener.

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 return values need no description, and the single param is fully documented. The description covers cost, funds behavior, and the payment challenge, but does not address how the agent fulfills payment (e.g., wallet/auth prerequisites) or differentiate among the x402 sibling audits.

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 is a single parameter ('spec') with 100% schema description coverage, so the schema already documents it as a parsed OpenAPI document. The description adds no format or syntax detail beyond the schema, 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?

States a specific verb and resource: 'Evaluates structural quality and required fields in an OpenAPI document.' The agent can tell this audits an OpenAPI spec. However, it never distinguishes itself from closely named siblings like x402.compatibility_audit, x402.purchase_path_audit, or mcp.schema_audit, so sibling differentiation is left to inference.

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 by the resource (audit an OpenAPI doc), and the description usefully notes that calling it does not spend funds and returns the payment challenge. But it gives no explicit when-to-use vs when-not guidance, nor does it point to an alternative audit tool when a different check is wanted.

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 give no reason; the description explains why this read-like operation is flagged as a write — it is paid via x402 ($0.01 USDC on Base) and returns a payment challenge instead of autonomously spending funds. It also discloses the heuristic/comprehensive limits and that matched values are withheld. This is exactly the extra context annotations cannot carry.

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 tight sentences, front-loaded with the cost and payment behavior — the single most decision-relevant fact — followed by output semantics and scope caveats. Minor redundancy between 'PAID $0.01 USDC on Base via x402' and 'returns a payment challenge', but nothing is wasted.

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

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

An output schema exists, so return values need not be spelled out, and the description still usefully characterizes them as classifications and positions. Cost, privacy behavior, accuracy limits, and the no-autonomous-spend guarantee are all covered; only the mechanics of satisfying the payment challenge (handled by sibling x402 tools) are left unstated.

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?

Only one parameter, text, and schema description coverage is 100% with a documented 65536-byte cap. The description adds nothing about the input beyond what the schema already states, so the baseline of 3 applies rather than a penalty.

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 and resource: 'Detects selected personal-data patterns and returns classifications and positions, not matched values.' The output-privacy distinction ('not matched values') plus the 'heuristic, not comprehensive' scope note make the tool's behavior unmistakable. It does not, however, name or contrast itself with the adjacent secret.scan sibling, which is the nearest alternative.

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

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

Usage context is only implied ('detects personal-data patterns' → use when you need PII detection in a text blob), and no when-not-to-use or alternative (e.g. secret.scan for credentials) is given. It does supply one genuinely useful precondition — that invoking it returns a payment challenge rather than a result — but that is a cost/prerequisite note, not routing 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 substantial context beyond annotations: the $0.01 USDC on Base cost, the x402 rail, that calling returns a payment challenge, and that it does not autonomously spend funds. This directly addresses the auth/payment dimension that readOnlyHint=false implies but does not explain.

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 tight fragments with no waste; the payment cost and the purpose both land up front, followed by the critical no-auto-spend caveat. Efficient for the information conveyed.

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 return values need no explanation, and the payment/challenge behavior is covered. The only real gap is routing guidance against the numerous sibling audit tools, but the core call contract is 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 coverage is 100% for the single 'text' parameter, so the schema already documents format and the 65536-byte limit. The description adds no syntax or constraint detail beyond it, making the baseline 3 correct.

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: 'Scores selected prompt structure signals using deterministic heuristics.' The 'prompt' qualifier distinguishes it from the many other audit siblings (mcp.schema_audit, openapi.quality_audit), though it never names or contrasts those siblings directly.

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 statement of when to use this versus the other audit tools, and no prerequisites beyond the payment behavior. The agent learns the cost and challenge flow but nothing about appropriate contexts 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?

Annotations already declare readOnlyHint=false, openWorldHint=false, and destructiveHint=true, so the write profile is covered. The description still adds genuine outcome context beyond the schema: submissions always land in a pending state and never mint credentials or active capabilities, which is exactly what an agent needs to set expectations before calling. It stops short of explaining auth/permission needs for the write.

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 short sentences with zero filler, and the highest-value constraint ('Always pending, never creates credentials') is front-loaded right after the purpose statement.

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 5-parameter write tool with an output schema and full parameter documentation, the main gap left is usage routing. The description covers purpose and outcome state adequately, and return values are handled by the output schema.

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 every one of the five fields carries a formatted description (length bounds, slug pattern, private-vs-public framing). The description adds nothing about individual parameters, so the baseline of 3 is correct.

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 and resource ('public application intake' for providers) plus the outcome ('Always pending'). An agent can tell it creates an application record rather than an active provider. However, it never distinguishes itself from siblings like provider.get, provider.describe, or creator.apply, so the reader must infer the boundary.

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?

'FREE' signals the cost profile and 'public application intake' implies this is the entry point for new providers, but there is no explicit when-to-use or when-not-to-use guidance. Nothing routes the agent between this and provider.describe/provider.get or creator.apply; usage is only implied.

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

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

Annotations already declare readOnlyHint=true, destructiveHint=false, and openWorldHint=false, so the safety profile is covered structurally. The description adds one genuinely new fact — that the call is FREE (no cost/credits) — which is not in the annotations. It says nothing about rate limits, auth requirements, or what 'commerce policy' 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?

Two compact sentences, no filler, and the key qualifier (FREE read-only) is front-loaded before the routing hint. 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?

An output schema exists, so return values need not be described. But for a zero-param discovery tool the description leaves the domain ambiguous — 'provider' and 'commerce policy' are undefined, and no distinction from provider.get or marketplace.describe is drawn, which is the main thing an agent needs.

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

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

The tool takes zero parameters, so the baseline is 4 and there is no parameter meaning for the description to supply or omit.

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 concrete verb-resource pair ('provider and commerce policy discovery') and states the scope (read-only, free), which is more than a tautology of the title. However, it does not distinguish itself from close siblings like provider.get, marketplace.describe, or capability.search, so an agent cannot route on the text alone.

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?

'Use this before selecting an offer or capability' gives a sequencing cue, implying usage ahead of offers.list/commerce.quote. But it names no alternative tool and gives no when-not-to-use condition, so the 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?

Annotations already cover the safety profile (readOnly, non-destructive, closed-world), so the bar is lower, yet the description still adds real behavioral context: the call is free, it returns only active providers, and pending applications gate on owner/administrator authorization. That auth-condition disclosure is genuinely useful for an agent deciding whether the call will succeed.

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

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

Three short fragments with zero filler, and the most decision-relevant fact (FREE) is front-loaded. It is arguably too terse given the sibling ambiguity, but nothing in it is wasted.

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

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

With an output schema present, return values need no explanation, and the parameter is fully documented in the schema. The remaining gap is sibling differentiation from provider.describe, which matters given the crowded toolset and is not 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?

There is a single required parameter with 100% schema description coverage, including a precise regex pattern and the 'CrossingKey marketplace provider identifier' definition, so the schema carries the full burden. The description adds nothing about providerId, 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 phrase 'Public active provider metadata' identifies the resource and scope (active providers only), which is more informative than the bare tool name. However it never states a retrieval verb and gives no signal distinguishing it from the sibling provider.describe, so an agent cannot tell which of the two to call.

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?

'FREE' tells the agent there is no cost barrier, and the authorization note tells it that pending applications require owner/admin rights, which implicitly routes it toward active providers. But there is no explicit when-to-use versus provider.describe, and no statement of what happens for non-existent IDs.

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 readOnlyHint=true and destructiveHint=false, so the safety profile is covered; the description still adds two pieces of context beyond them — that the call is FREE (no cost) and that it will never authorize or start payment or execution, drawing an explicit boundary against payment/execution siblings. It stops short of describing latency or result shape, but with annotations present this is solid added value.

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

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

Two short, front-loaded sentences with no filler; each carries a distinct fact (cost, negative capability boundary). It is efficient, though the terseness leaves purpose under-explained rather than being wasteful.

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

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

An output schema exists, so return values need not be described, and the sole parameter is fully covered. What is missing is the surrounding commerce context: what requirements are being checked and when in a purchase flow this should be called instead of execution.preflight or commerce.quote.

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 single item_id parameter is fully documented in the schema, including its source (offers.list). The description adds nothing about the parameter, 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?

"FREE read-only requirements check" largely restates the tool name (requirements.check); it never says what a "requirement" is, what resource is inspected, or how it differs from siblings like execution.preflight or commerce.quote. The only added content is a cost qualifier and a safety qualifier, not a statement of 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?

No when-to-use guidance and no named alternatives, despite a crowded sibling set (commerce.quote, execution.preflight, cost.estimate, offers.list) that plausibly overlaps. The agent must infer the trigger condition entirely.

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 destructiveHint=false, so the safety baseline is covered. The description goes further by naming the specific side effects it avoids — no capability execution, no entitlement, no receipt — which tells the agent this call consumes nothing and mutates no account state. It stops short of describing cost, rate limits, or what the preview 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?

Two short sentences, zero filler, with the most decision-relevant fact (FREE, read-only) front-loaded. Nothing is repeated from the structured 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?

An output schema exists, so return values need no explanation, and the single required parameter is fully specified by the schema. For a one-param read-only preview, the description supplies the essential non-side-effect guarantee; only the routing against sibling tools 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% and the single item_id parameter is fully documented in the schema (including provenance from offers.list), so the description is not obliged to restate it. It adds no format or constraint nuance beyond the schema, 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 names a concrete action (preview of a 'result-shape') and asserts a key property ('never executes'), but the object of the preview is left implicit — an agent must infer from the schema that it previews the result shape of the capability referenced by item_id. It does not clearly distinguish itself from execution.preflight or capability.get, which appear to live in the same problem space.

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?

Signaling 'FREE' and 'never executes' implies this is the cheap, safe alternative to actually running a capability, so the usage is implied rather than stated. There is no explicit when-to-use/when-not versus execution.preflight, capability.get, or requirements.check, which are the most plausible siblings an agent would weigh against it.

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?

Goes well beyond the annotations: it names the exact cost and network ($0.01 USDC on Base via x402), discloses a privacy-relevant output trait (positions/classifications, never matched values), flags the heuristic limitation, and explains the payment-challenge flow including that no funds are spent autonomously. That is exactly the kind of context annotations cannot carry. No contradiction with readOnlyHint=false, since payment/non-autonomous spend is consistent with a non-read-only call.

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

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

Four short sentences, zero filler, and the cost/payment gate is front-loaded so an agent sees the commercial requirement first. Every sentence carries distinct 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?

An output schema exists, so return structure needn't be described, and the description still usefully characterises the output (no matched values). For a single-parameter, paid, open-world scan tool, the agent has everything needed to decide and invoke.

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 the single 'text' parameter, so the schema already documents its type and 65536-byte limit. The description adds nothing about the parameter, which is the expected baseline when the schema does the work.

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 and resource ('Detects selected credential patterns') and pins down the return nature ('classifications and positions, not matched values'). It doesn't name the obvious sibling pii.scan or otherwise distinguish itself from it, so an agent must infer the boundary from the word 'credential' alone.

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

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

The description gives a scope caveat ('Heuristic, not comprehensive') but no when-to-use instruction and no comparison against pii.scan or the other scan/audit siblings. The agent is left to guess which scan tool fits a given input.

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

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

Beyond the annotations (readOnlyHint=false, idempotentHint=true, destructiveHint=false), the description discloses a non-obvious two-phase payment flow: the call itself is free and returns the PAYMENT-REQUIRED challenge plus the canonical paid execution endpoint. This is exactly the kind of behavioral detail annotations cannot express, and it contradicts nothing.

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 tight sentences with zero filler; the cost and the no-spend reassurance are front-loaded before the audit behavior. 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?

With one fully documented parameter, an output schema present, and complete annotations, the description covers everything remaining: what it costs, that invoking it is free, and what the invocation returns. No gaps an agent would need to resolve before calling.

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 'url' parameter, so the schema already carries the meaning ('Public HTTP(S) x402 endpoint to audit'). The description adds no format or constraint detail beyond the schema, 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?

States a specific verb and resource ('Audits an x402 endpoint') with a precise scope ('v1/v2 compatibility defects'), which clearly separates it from siblings like x402.purchase_path_audit, mcp.launch_audit, and openapi.quality_audit. An agent can pick this tool without opening the schema.

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

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

The description gives strong context: it is a paid tool ($1.00 USDC on Base via x402) and explicitly states that calling it does not spend funds, which frames the usage model well. It does not, however, name when to choose it over the closely-named sibling x402.purchase_path_audit, leaving that comparison 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 already declare openWorldHint=true, idempotentHint=true, destructiveHint=false, and readOnlyHint=false, so the safety profile is partly covered. The description adds genuinely useful behavior (cost of $19 USDC on Base, bounded scope, no-payment semantics of the audited challenge), but it creates real ambiguity about whether the caller is spending $19 or merely auditing a $19 challenge, and readOnlyHint=false is never reconciled with the phrase 'no-payment'.

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, but the first is a cost banner whose referent (the tool's own price vs. the audited amount) is unclear, and the second is a dense compound clause. It is compact but not cleanly front-loaded on the action the agent is choosing.

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 return values need no explanation, and both required parameters are fully documented in the schema. What is missing is the routing context (why this audit rather than siblings) and a disambiguation of the payment statement, which matters for an open-world, non-read-only tool.

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

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

Schema description coverage is 100% for both parameters (url as public HTTP(S) x402 base URL, capability as the name of the no-payment challenge to audit), so the schema carries the parameter burden. The description adds no syntax, format, or constraint detail beyond restating 'a selected capability', leaving the baseline 3 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 second sentence names a specific verb and resource ('purchase-challenge audit') and enumerates exactly what is validated (status, requirements, destination, amount, receiver-only controls). It does not differentiate itself from close siblings such as x402.compatibility_audit or execution.preflight, and the leading 'PAID $19.00 USDC on Base via x402' sentence is about cost rather than purpose, which blurs the opening.

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 never states when to choose this audit over the sibling audits (x402.compatibility_audit, requirements.check, execution.preflight) or what precondition triggers it. 'For a selected capability' is the only contextual hint and it is implicit at best.

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 cover idempotency (idempotentHint=true), safety (destructiveHint=false), and openness, but say nothing about cost or payment mechanics. The description fills that gap by disclosing the $0.10 USDC price, the x402/Base rail, and that the initial call only emits a challenge without spending. It stops short of describing what happens on the paid call or whether failed validations incur cost.

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

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

Three short sentences, with the cost and network front-loaded before the functional claim and the no-spend guarantee. Every sentence earns its place; nothing is restated from the schema.

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

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

An output schema exists, so return values need not be explained, and annotations carry the safety/idempotency profile. The description adds the payment-lifecycle context that structured fields omit. Minor remaining gap: no hint about the sequence after the challenge is paid or how errors surface.

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 both parameters (raw_intake, idempotency_key) are already fully documented with formats and bounds. The description's phrase 'one bounded XKEY intake payload' loosely echoes the size limit but adds no syntax or format detail beyond the schema. Baseline 3 is correct.

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 pair and a tightly bounded resource: 'Validates and normalizes one bounded XKEY intake payload.' Combined with the upfront price line, an agent immediately knows what this does and what it costs. No sibling tool covers XKEY intake validation, so disambiguation is effectively built into the specificity.

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 crucial operational context: the call returns a PAYMENT-REQUIRED challenge and does not spend funds, which tells the agent this is a safe pre-flight step in a paid flow. It does not, however, name any alternative or state a when-not condition (e.g., what to do after payment, or when to skip validation).

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