x402-gateway

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

The description adds the cost per call, which is useful behavioral context beyond the annotations. However, it does not mention the response format, any rate limits, or what happens if the payment is omitted beyond what the schema description already covers. Annotations already declare readOnly, openWorld, idempotent, and non-destructive, so the description does not need to repeat those, but more detail on the returned data would be helpful.

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

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

The description is a single sentence that leads with the cost, immediately conveying the most important operational detail, followed by a clear purpose. No filler words; every element 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?

The tool is simple with one optional parameter and no output schema, so the description is mostly adequate. However, it does not describe what the search returns (e.g., list of agent metadata, addresses, etc.), which could leave an agent unsure of the output structure. Given the lack of an output schema, this is a 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 coverage is 100%, and the single parameter 'payment' already has a thorough description covering the x402 proof and the two-step call pattern. The tool description adds no additional semantic detail, so it meets the baseline for high schema coverage but does not exceed it.

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

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

The description uses a specific verb ('Search') and names a precise resource ('ERC-8004 registry') and target ('on-chain AI agents'). It clearly differentiates from generic tools, though it does not explicitly contrast with siblings like agent_research, so it stops short of a 5.

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

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

No guidance on when to use this tool versus alternatives. While the tool's purpose is distinct, the description never states when it should be preferred or excluded. The sibling list includes agent_research, which might overlap, but no comparison is made.

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. The description adds value by disclosing a $0.05 per-call cost, execution against a local LLM, and text return type—none of which appear in the annotations. It doesn't cover rate limits or auth details, but the payment flow is already in the schema and the annotations mitigate safety concerns.

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 front-load the cost and then give examples plus output details. There is no filler or repetition of schema content, so 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 broad research tool with 13 siblings and no output schema, the description leaves the agent to infer how to route between this and related tools. It covers cost, execution, and output type, but is thin on distinguishing scope and scenario.

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's task examples largely repeat the schema's parameter descriptions (summarize, compare, extract, draft/critique) and don't add new meaning to task, topic, or payment.

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

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

Description states a clear action ('on-demand AI agent research and analysis') and gives concrete task types, so an agent understands what it does. It doesn't differentiate from sibling tools like agent_discovery or market_intelligence, leaving room for ambiguity when multiple research-ish tools exist.

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?

Task examples imply common use cases, but there is no explicit 'use this for X, use sibling Y for Z' guidance. The description does not mention when not to use it or which alternative to prefer, so the agent must infer applicability from examples.

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

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

Annotations already declare readOnlyHint, idempotentHint, and destructiveHint=false, so the safety profile is covered. The description adds the per-call cost and external engine identity, which is useful context for call decisions, but it does not clarify output shape or update cadence.

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

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

The description is a single compact phrase with no wasted words. The cost qualifier is front-loaded, and the domain plus engine are stated efficiently.

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

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

For a tool with only one optional parameter and strong annotations, the description provides enough context to select and call it. The lack of an output schema means return-format details are missing, but the narrow scope makes this a minor 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 coverage is 100%, and the single optional payment parameter is fully documented in the schema. The description mentions cost but does not add further meaning to the payment parameter beyond what the schema already provides.

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

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

The description names the resource (game deals), the actions (tracking, price-watch, release radar), and the underlying engine (CheapShark), which distinguishes it from NFT, token, and wallet-focused siblings. It lacks an explicit verb but is specific enough for an agent to understand the tool's domain.

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 use-case context: game deal tracking, price-watching, and release radar. It implies when to use this tool versus finance/NFT/research siblings, though it does not explicitly name alternatives or exclusions.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true, and destructiveHint=false, so the safety profile is covered. The description adds the efficiency scoring behavior and the DexScreener data source, which is useful context. However, it doesn't disclose the two-phase payment flow (call without payment to receive requirements, then retry with proof) that the schema hints at, nor any rate limits or data freshness characteristics.

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

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

The description is a single, compact sentence that front-loads the pricing and core purpose. It's efficient and earns its place, though it could arguably include a bit more behavioral detail without becoming bloated.

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 analysis tool with full schema coverage and no output schema, the description is mostly adequate. However, the payment flow is a notable gap: the schema mentions an optional payment proof with a two-step process, and the description's pricing note doesn't explain that the first call will return payment requirements. An agent could get stuck without this context.

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

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

Schema description coverage is 100%, so the schema already documents both parameters well. The description adds the 'efficiency scoring' context that helps understand what the address parameter is used for, but doesn't add meaning beyond the schema's parameter descriptions. Baseline 3 is appropriate given full schema coverage.

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

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

The description states a specific verb ('analysis') and resource ('DeFi LP pool') with a distinctive feature ('efficiency scoring via DexScreener'). It clearly identifies what the tool does, though it doesn't explicitly differentiate it from sibling tools like wallet_analysis or score, which could overlap in an agent's mind.

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 for LP pool analysis and efficiency scoring, but provides no explicit guidance on when to choose this over alternatives like wallet_analysis or score. The pricing note ('$0.02 USD per call') is a useful context signal, but there are no exclusions or alternative routing instructions.

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

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

Annotations already declare readOnlyHint, openWorldHint, idempotentHint, and destructiveHint false, covering safety. The description adds valuable behavioral context: a per-call cost of $0.005, that it is live-RPC sourced, and that no API key is required. This goes beyond the annotations and helps the agent understand the operational nature, though it does not detail rate limits or exact response format.

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

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

The description is a single, front-loaded sentence that packs the cost, purpose, chains, source, and key requirement into a compact format. Every element earns its place, and the most critical operational detail (cost) is placed first. There is no fluff 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?

The tool is simple and the description covers the core information: what it returns (gas prices in gwei), for which chains, and the source. It does not explicitly state the output structure (e.g., a JSON object with per-chain prices), but given the simplicity and the fact that no output schema is provided, the description is sufficient for an agent to understand how to call and interpret the result. The payment flow is described in the 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?

The input schema has one optional parameter 'payment' with a comprehensive description explaining the x402 proof and the retry pattern. Schema description coverage is 100%, so the description does not need to add parameter details. The main description mentions cost but does not clarify that payment proof is needed; that is left to the schema. Thus the description adds no extra semantic value beyond the schema.

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

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

The description clearly states the tool provides live gas prices in gwei for three specific chains (Ethereum, Base, Polygon). It names the resource and source (Live-RPC) and notes no key required, which distinguishes it from potential siblings that might offer similar market data. The purpose is unambiguous.

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

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

The description does not explicitly mention when to use this tool versus alternatives, nor does it list exclusions. However, the highly specific purpose (gas prices) makes it obvious for an agent when to invoke it. There is no guidance on when not to use it or what other tools might be better for related needs, so it relies on implication.

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

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

Annotations already declare readOnlyHint, openWorldHint, idempotentHint, and destructiveHint=false. The description adds valuable context beyond that: the call is 'Free', the result is exhaustive ('every' service), and the response contents are enumerated. It does not mention pagination or rate limits, but those are not strongly needed for a simple listing tool.

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 dense, front-loaded sentences with no filler. 'Free' and 'Call this first' are immediately useful, and every clause contributes either scope, output format, or 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?

For a zero-parameter, no-output-schema catalog tool, the description is complete: it states what is listed, what fields are returned, the cost, and when to call. There are no missing details that would prevent correct invocation or interpretation.

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

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

The tool has zero parameters, so the input schema fully covers parameter semantics. Per the rubric, a zero-parameter tool receives a baseline of 4, and the description correctly avoids inventing parameter details that do not exist.

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 ('List'), a precise resource ('every paid x402 service this gateway sells'), and the exact output fields (name, description, price in USD, HTTP method, live path). This clearly distinguishes it from the sibling tools, which focus on analytics, routing, or research rather than catalog discovery.

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

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

'Call this first to discover what can be bought here' gives explicit when-to-use guidance and positions the tool as the discovery entry point. It does not list alternatives or when-not-to-use cases, but for a zero-parameter catalog tool the primary usage context is clear.

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

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

Annotations already declare readOnlyHint=true and destructiveHint=false, so the safety profile is known. The description adds the $0.02 cost and the verdict types (BLOCK/REVIEW/SAFE) which are valuable behavioral details. Does not mention DataHub access specifics or response structure, but annotations carry the safety burden.

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?

Fully front-loaded with cost and action. Two sentences with precise terms. No filler. Every phrase earns its place, including the verdict classification which is essential for an agent to interpret results.

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?

Tool is a single-input read-only guard, so description is sufficient. The complexity is low. It covers cost, classification, and verdict. No output schema, so not explaining return format is acceptable, but could mention that return includes list of affected assets and classifications, which is partially stated.

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 both parameters are documented. The description adds the example URN format and clarifies that the return are the assets that break, reinforcing the schema's description. However, no extra semantics beyond what schema provides, so 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?

Description clearly states the tool's purpose: a lineage blast-radius guard that classifies downstream assets and issues a verdict. It uses specific verb (blast-radius guard) and resource (DataHub lineage), distinguishing it from general-purpose data tools like 'providers' or 'score'.

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

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

Provides clear context on when to use: when evaluating impact of dropping or changing a table. Does not explicitly list alternatives but the sibling tools are all in different domains (defi, gas, nft), so the use case is unique. Slight gap: no explicit when-not-to-use 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?

The annotations already establish read-only, idempotent, non-destructive behavior; the description adds useful cost context ('$0.005 USD per call') and freshness ('Real-time'). This goes beyond the annotations without contradicting them.

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

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

The description is a single front-loaded sentence that opens with the headline cost and states the tool's function with zero filler. Every word earns its place given that the schema handles parameter details.

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 simple (one required parameter, strong annotations, no output schema), and the description conveys that the result is real-time market price data. It does not describe the exact output shape, but the low complexity and detailed schema/annotations make this adequate for 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%, and both 'symbol' and 'payment' are documented with meaningful detail including the EIP-3009 payment proof flow. The description itself adds no parameter-level semantics, so it meets the baseline rather than exceeding it.

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

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

The description identifies a concrete resource ('crypto market price data') and the 'real-time' qualifier narrows its scope. It does not use an explicit verb like 'get' or 'return', but the noun phrase is sufficient to distinguish it from siblings such as gas_oracle, nft_search, and token_security.

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 statement about when to use this tool versus the sibling tools. An agent might infer use for current prices, but the description never says when not to use it (e.g., analytics, security, deal tracking) and names no 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 cover read-only, idempotent, non-destructive behavior, so the description adds the per-call cost and the Magic Eden source. It doesn't describe the payment flow in detail (that lives in the schema), but the cost is a useful extra behavioral detail beyond the annotations.

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

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

The description is a single sentence, leading with the cost, then the purpose. Every word earns its place, with no fluff or repetition. It is highly efficient and 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?

The tool is a search operation but does not explain what search terms or criteria are used (since only a payment parameter exists), nor what the output looks like (no output schema). This leaves the agent unclear on how to actually perform a search, making the description incomplete for practical use.

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

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

The schema provides 100% coverage for the single 'payment' parameter, including the invocation pattern (call once without it, then retry with proof). The description adds no parameter-specific meaning beyond what the schema already documents, so a baseline score of 3 is appropriate.

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

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

The description clearly states the action ('search'), the resource ('NFT collection'), and the scope ('across Solana via Magic Eden'). It is specific enough to distinguish from sibling tools like market_intelligence or token_security, which cover different domains.

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, nor any exclusions or prerequisites beyond the payment mechanism. The description only states what the tool does, not when it should be chosen.

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

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

The description adds the cost per call ($0.005 USD) and implicitly references the payment proof requirement via the parameter. This goes beyond the readOnlyHint, idempotentHint, and openWorldHint annotations. The two-step payment flow is disclosed in the schema, and the description's cost note is a valuable behavioral disclosure.

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

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

The description is a single, concise sentence with the cost noted in brackets, front-loading key information. It contains no filler and every word serves a purpose, making it efficient for an agent to parse quickly.

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

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

For a simple read-only list tool with one optional parameter, the description is mostly complete. It states the purpose and cost, and the schema covers the payment parameter. However, it does not describe the output structure (e.g., what fields are returned for each provider), and since there is no output schema, this information is absent. Nevertheless, given the tool's simplicity, the gap is minor.

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

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

The schema description for the 'payment' parameter is 100% complete, providing the full semantics of the optional x402 payment proof. The tool description itself does not add any additional parameter context beyond what the schema already states. With high schema coverage, a baseline of 3 is appropriate.

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

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

The description clearly states the verb 'List' and the resource 'registered model providers in the Sovereign Router pool', making its purpose unambiguous. It is distinct from sibling tools like 'route' or 'score', which imply different operations. The title reinforces the purpose with 'Sovereign Router Model Provider List'.

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

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

No explicit guidance is given on when to use this tool versus alternatives. While the purpose is clear, there is no mention of when not to use it or what distinguishes it from similar listing tools (e.g., gentech_list_services). The agent must infer usage context from the name and description.

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 mentions x402 settlement and a $0.05 per-call cost, and the parameter description instructs the caller to retry with a payment proof. This implies a financial side effect, which contradicts the readOnlyHint=true annotation. This is an annotation contradiction.

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

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

The description is one compact sentence with the cost and core routing behavior front-loaded. The parenthetical 'MSS v2 Sovereign Router' adds some product specificity but is not fully explained, so it is not perfectly 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?

The description and parameter note explain the payment flow but do not clarify what request is being routed, what a successful call returns, or how the tool selects among registered providers. Without an output schema, these gaps make the actual invocation semantics underspecified.

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 payment parameter already has a rich description explaining EIP-3009 and the two-step payment flow. The main description adds little beyond the schema's own parameter 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?

The description states a concrete action, 'Route across registered model providers,' and references the x402 settlement protocol, which gives a clear sense of what the tool does. It does not explicitly differentiate route from sibling tools like providers, and the 'MSS v2 Sovereign Router' phrase is unexplained jargon, so it falls short of a 5.

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

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

There is no guidance about when to use this tool versus its alternatives, such as providers or score. The payment-parameter description explains a retry flow, but that is procedural rather than a when-to-use-vs-sibling comparison.

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 readOnly, openWorld, idempotent, and non-destructive behavior. The description adds useful context beyond that: the $0.02 per-call cost and the 0-850 output scale. It does not contradict the annotations, and the payment handshake is covered in the schema's payment parameter description.

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 entire description is one compact, front-loaded sentence with no wasted words. The cost, purpose, scope, and output range are all included efficiently.

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

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

The description plus annotations and schema cover cost, safety, payment flow, and score range. However, it is ambiguous how the tool knows which model profile to score given there are no required parameters; the phrase 'any model profile' needs more context for an agent to invoke it correctly.

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

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

Schema description coverage is 100%, so the baseline is 3. The description's mention of cost hints at payment relevance, but it does not add meaningful semantics for the optional payment parameter beyond what the schema already explains.

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

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

The description uses a specific verb ('score'), names the resource ('MSS v2 model strength + sovereignty score'), and gives a concrete output range (0-850) and scope ('any model profile'). It is clear on its own, but it does not explicitly differentiate itself from sibling tools like agent_research or market_intelligence, so it stops short of a 5.

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

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

No guidance is provided about when to call this tool versus the many sibling tools, nor are any exclusions or prerequisites stated. 'Score any model profile' implies a use case, but the agent is left to infer when this tool 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 establish read-only, idempotent, non-destructive behavior, and the description adds helpful context: per-call cost, supported network, factor categories, and a concrete failure mode. It stops short of describing the returned score or any pagination, but that is not a major gap given the annotation coverage.

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

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

The description is compact and front-loaded with purpose and cost, followed by network restriction and alternative guidance. It is dense but every clause serves a distinct purpose, with only slight redundancy between 'SOLANA ONLY' and the repeat of the EVM rejection.

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?

Together with the schema and annotations, the description covers cost, payment flow, network constraints, error behavior, and sibling routing, which is enough to invoke the tool correctly. The lack of an output schema is mitigated by the fact that return-value parsing is not needed for selection, though an example result would make the definition marginally more 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% and the property descriptions already explain the address formats and the x402 payment flow, so the description carries little parameter burden. The 'SOLANA ONLY' note does narrow the address domain, but the schema's own wording still mentions EVM addresses, creating a minor inconsistency that the description does not fully reconcile.

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

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

The description identifies a precise action and resource: Solana token risk scoring and rugcheck analysis, with 11 concrete factors. It also differentiates from treasury_defender by network, so an agent can tell exactly what the tool is for.

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

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

It explicitly says when to use the tool (Solana tokens) and when not to (EVM), naming treasury_defender as the alternative. The concrete rejection behavior (400 invalid_mint for EVM addresses) removes any ambiguity.

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 says it will 'quarantine flagged tokens,' which is a state-mutating action, while annotations declare readOnlyHint=true and destructiveHint=false. This is a direct contradiction and is not resolved elsewhere in the definition.

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

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

The description is a single front-loaded sentence that packs price, purpose, classification labels, and expected outputs with no filler. Every clause contributes useful 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?

It discloses the $0.01/call cost, the KNOWN/SUSPICIOUS output categories, and safe burn calldata as a deliverable; the schema handles payment retry. It is mostly complete for invocation, though the real meaning of 'quarantine' is left ambiguous given the read-only annotations.

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

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

The schema already provides 100% coverage for all three parameters, including required chainId, token, and optional payment proof retry flow. The description adds no additional parameter semantics, 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?

The description names a specific resource (airdropped/dust tokens) and concrete actions: classify as KNOWN/SUSPICIOUS, detect homoglyph/no-liquidity scams, and return safe burn calldata. This clearly differentiates it from siblings like token_security or wallet_analysis by framing it as scam-airdrop defense.

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

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

It gives clear context: use this when defending against scam airdrops and dust tokens. It doesn't explicitly state when not to use it or name alternative tools, but the intended use case is obvious enough for an agent to route correctly.

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 read-only, idempotent, non-destructive behavior. The description adds useful context with the per-call cost and the expected output content, but it does not explain how the analysis is sourced, how unsupported wallets are handled, or the payment-flow behavior beyond what the schema already states.

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

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

The description is a single, information-dense sentence with the cost front-loaded. It contains no filler or redundant phrasing and 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 two-parameter tool with read-only annotations and a fully documented schema, the description provides the key missing piece: what the tool returns. It lacks sibling-routing guidance and payment-flow details, but those are either inferable or covered by the schema, so basic invocation is adequately supported.

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 both the address and payment parameters. The description adds no parameter-specific detail beyond referencing wallet portfolio analysis, which meets the baseline without needing to compensate.

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

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

The description clearly states the operation ('analysis') and resource ('wallet portfolio'), and specifies the output content ('token balances and USD valuation'). It is specific enough to identify the tool's function, though it does not explicitly differentiate itself from siblings like defi_lp_analytics or token_security.

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 use case is implied by the phrase 'wallet portfolio analysis,' so an agent can infer when it might be relevant. However, there is no explicit statement of when to use this tool over alternatives, nor any exclusions or prerequisites.

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