aeX402 — Cross-Chain DeFi MCP: LINQ, AMM, Bridge, AI

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

With no annotations, the description carries full burden. It discloses that the tool fetches live pool state, computes output with slippage protection, and returns instruction parameters for client signing (not executing). This is transparent, though missing details on failure modes or side effects.

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

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

Two sentences efficiently convey purpose, process, and output. Front-loaded with 'Build an AeX402 AMM swap action' and no redundant words.

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 5 parameters, an output schema exists, and description covers the core function (fetch, compute, return). It lacks error handling or prerequisite info, but is sufficient for a builder tool within a known protocol.

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

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

All 5 parameters have descriptions in the input schema (100% coverage), so baseline is 3. The description adds context about live state and slippage protection but does not elaborate on individual parameters beyond 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 builds an AeX402 AMM swap action, with specific verb 'build' and resource 'swap action'. It distinguishes from sibling tools like aex402_getPool, aex402_listPools, and aex402_quote by focusing on constructing the swap instruction with live state and parameters for signing.

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 building a swap after obtaining pool and quote info, but does not explicitly state when to use versus alternatives like quoting first. No exclusions or prerequisites are mentioned.

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

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

No annotations are provided, so the description carries full burden for behavioral disclosure. It does not state if the tool is read-only, any side effects, authorization requirements, or rate limits—only what data is returned. This is minimal transparency beyond the obvious.

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, well-structured sentence that efficiently conveys the tool's purpose and the included data. No wasted words.

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, the description need not explain return values. It sufficiently lists the categories of data returned (token mints, balances, etc.), which is adequate for a simple getter 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 baseline is 3. The description confirms the tool returns detailed info for the given address but adds no parameter-specific context beyond the schema's own description ('Pool account address (base58)').

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 'Get detailed AeX402 pool info' and enumerates specific data fields (token mints, balances, fee, amplification, LP supply, analytics, circuit breaker status), making it distinct from the sibling aex402_listPools which likely lists pools without detail.

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 retrieving detailed pool information but provides no explicit guidance on when to use this tool versus alternatives like aex402_listPools, and no when-not or precondition statements.

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

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

No annotations provided, but the description adds behavioral context: pools are 1024-byte accounts owned by a specific program, and returns basic info. It implies a read-only operation, which is appropriate.

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 wasted words, front-loaded with the main purpose. Every sentence adds value.

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

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

Given the tool's simplicity and the presence of an output schema, the description adequately covers the return fields (mints, balances, fee, amp) and account details. Could mention pagination but not necessary.

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 one parameter (minTvl) with 100% schema coverage. The description does not add any additional meaning beyond the schema, meeting the baseline of 3.

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

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

The description clearly states the tool lists all AeX402 AMM pools on Solana, which distinguishes it from siblings like aex402_getPool (single pool) and aex402_buildSwap (swap). The verb 'list all' is specific and actionable.

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

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

The description implies use for listing all pools, contrasting with sibling tools for specific operations. However, it does not explicitly state when not to use it or suggest alternatives, but the 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?

With no annotations provided, the description effectively discloses the tool's behavior: it calculates expected output, price impact, and fees without executing, and is read-only in nature.

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

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

The description is two sentences long, conveying essential information without extraneous words, and is front-loaded with the main purpose.

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 presence of an output schema, the description is sufficient for a quote tool. It might benefit from mentioning prerequisites like pool existence, but overall it is adequate for the complexity.

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

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

Schema coverage is 100%, so baseline is 3. The description adds no additional parameter meaning beyond what the input schema already provides, e.g., 'atomic units' is already in the schema description.

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

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

The description explicitly states the verb 'Get', the resource 'swap quote', and the context 'from an AeX402 pool', clearly distinguishing it from siblings like aex402_buildSwap which likely executes trades.

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?

While it mentions 'without executing' implying use before execution, it does not provide explicit guidance on when to use this tool versus alternatives like aex402_buildSwap or any conditions for 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?

With no annotations provided, the description carries the full burden of behavioral disclosure. It explains the scanning mechanism (VPoolGraduated events + reserves), returns status field, and mentions the legacy-drained pool. While it does not discuss side effects or rate limits, it sufficiently discloses its read-only, live-tracking behavior.

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

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

The description is dense but efficient, with each sentence adding value: purpose, mechanism, returned fields, differentiation, and input clarification. It is front-loaded with the primary action and avoids unnecessary repetition.

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

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

Given no output schema and no annotations, the description provides a thorough overview: it explains the data source, returned fields, and status. However, it could complete the context by noting that sibling tools (e.g., aex402_listPools) may offer similar but distinct functionality.

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 baseline is 4 per rubric. The description states 'No inputs,' which is consistent and adds no extra meaning beyond the empty schema. Since coverage is 100% (vacuously), no correction is needed.

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 that the tool gets the live state of the aeX402 AMM and enumerates graduated pools. However, it does not explicitly differentiate itself from sibling tools like aex402_getPool or aex402_listPools, which could cause confusion about which tool to use for specific pool queries.

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

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

The description implies that the tool is used to get all graduated pools live, but it does not provide explicit guidance on when to use this tool versus its siblings (e.g., aex402_getPool for a single pool). There are no when/not-to-use conditions or alternative suggestions, only a mention that it is distinct from the chain's Uniswap-fork DEX.

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

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

No annotations are provided, so the description carries the burden. It discloses that the delegate runs with full tool access and returns its response, and states a max depth of 3. However, it omits details on error handling, side effects, or cost implications, which are relevant for a delegation 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?

Three short sentences, each adding value. The tool's action is front-loaded ('Delegate'), and there is no redundant or unnecessary text.

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

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

The description covers the core purpose, usage hint, and a key limitation (max depth). An output schema exists to describe results. It could mention failure behavior or rate limits, but overall it is sufficient for a delegated agent 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 already explains each parameter. The description adds no extra meaning beyond the schema, e.g., it doesn't elaborate on the 'session' parameter's role in depth tracking.

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

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

The description clearly states it delegates tasks to a specialist AI agent and is useful for breaking complex tasks into subtasks. However, it does not explicitly distinguish from the sibling 'ai_chat' tool, which could cause confusion.

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 complex tasks and mentions a recursion depth limit (Max depth: 3), but does not provide explicit when-to-use or when-not-to-use guidance, nor does it mention 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?

With no annotations provided, the description partially carries the burden. It discloses pricing behavior (free tier caps, credit deduction) but lacks details on rate limits, concurrency, error handling, or how the reasoning_effort parameter's chain-of-thought appears in the result. The transparency is adequate but not comprehensive.

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

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

The description is two sentences, efficiently stating the core purpose and then adding pricing context. No irrelevant details. It could be slightly more front-loaded with the cost information, but overall it is concise and well-structured.

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 presence of an output schema, the description does not need to explain return values, but it omits guidance on streaming, context length, error scenarios, and how to interpret the reasoning meta. Although the tool has only 5 parameters and no nested objects, the description leaves gaps in completeness for a chat completion 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 input schema already documents all parameters. The tool description adds no additional meaning beyond what the schema provides. Baseline for high coverage is 3, and no extra value is contributed.

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 ('Send a chat completion request') and the target resource ('aeX402 AI Router'). The verb 'send' and noun 'chat completion request' are specific and distinguish this tool from siblings, none of which appear to offer chat functionality.

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 mentions free tier limits and paid credit deduction, providing some context on when cost is a factor. However, it does not explicitly state when to use this tool versus alternatives (e.g., other AI tools) or provide exclusion criteria. Usage guidance is implied but not fully elaborated.

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

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

With no annotations provided, the description carries the burden of behavioral disclosure. It states the operation is a public read GET, implying safety, and enumerates endpoints. However, it does not disclose potential errors, rate limits, or response variability, which would be valuable for a generic endpoint fetcher.

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 front-loads the main purpose, then provides a comprehensive list of endpoints. While long, every endpoint listed is a useful example, and there is no redundant wording.

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 simple generic GET fetcher, and the description covers the host, scope, and a broad list of valid paths. There is no output schema, so some return format context could be helpful, but given the variety of endpoints, endpoint-specific responses make that impractical.

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 for the single parameter 'path' is 100%, so the baseline is 3. The description adds concrete examples of valid paths including placeholders like <pool> and <sig>, which enriches the parameter semantics beyond the schema's generic 'Endpoint path including query string.'

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

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

The description clearly states the tool performs GET requests to public read endpoints on rpc.aex402.com, with a specific verb and resource. It distinguishes itself from specialized siblings like aex402_getPool by covering all other endpoints, though it doesn't explicitly contrast with them.

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

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

The description implies usage for any public read endpoint on the host, listing many examples. It doesn't explicitly state when to use this instead of specialized aex402_* tools, but the broad scope and endpoint list make the intended context reasonably 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?

The description discloses that the tool returns an unsigned transactionRequest for the caller to sign and submit, and that no keys are held. It also explains what the return includes (estimated output, fees, bridge used, duration). This is transparent about not executing transactions, which is critical for an agent.

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

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

The description is a single dense paragraph but is well-structured: core purpose first, then example, then return details, then accepted inputs. Every sentence adds information without redundancy.

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

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

Given that an output schema exists and is not provided here, the description sufficiently covers the tool's purpose, input format, and behavioral output. It addresses the parameters indirectly and explains the transaction workflow, making it complete for an agent to select and invoke the tool.

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

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

The description supplements the already-complete schema with helpful examples: amount in smallest unit (e.g., 1000000 = 1 USDC at 6 decimals), chain ids/keys, and token symbols/addresses. This adds significant 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's function: it bridges/swaps any asset across any chain via LI.FI, returns the best route plus an unsigned transactionRequest. It distinguishes from sibling tools by specifying cross-chain functionality and the unsigned tx output.

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

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

The description provides context on when to use this tool (cross-chain swaps, bridging into ETH for gas) but does not explicitly mention alternatives or when-not-to-use. It implies the use case but lacks explicit 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?

Describes return values and optional optimization hint. No annotations provided, so description carries burden. Discloses statuses and receiving-chain tx, but no mention of auth, rate limits, or error conditions. Acceptable for a read-only status 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 sentences, no wasted words. Front-loaded with purpose, then provides parameter 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?

Given the presence of an output schema and high schema coverage, the description fully explains the tool's function, status values, and relationship to bridge_quote. No gaps.

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%. Description adds value by explaining that the 'bridge' parameter comes from bridge_quote and speeds up lookup. This goes beyond the schema's bare description of the parameter.

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

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

Clearly states it tracks a cross-chain bridge submitted via bridge_quote, returning DONE/PENDING/FAILED plus receiving-chain tx. Uses specific verb 'Track' and resource 'cross-chain bridge'. Distinguishes from sibling bridge_quote.

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 instructs to pass source-chain tx hash and optionally the bridge tool from the quote for faster lookup. Implies usage context after bridge_quote, but lacks explicit when-not-to-use 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?

With no annotations provided, the description carries the full burden. It discloses what is returned per chain type: for Solana/Slonana (executable, owner, data size, known program) and for EVM (RPC-verified facts including ERC-20 and EIP-1967 proxy, plus Blockscout enrichment). It does not explicitly state read-only, but 'Introspect' strongly implies a non-mutating operation.

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

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

The description is two sentences: the first immediately states the tool's core purpose, and the second efficiently details chain-specific return values. No unnecessary words or repetition; it is front-loaded and structured clearly.

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 multi-chain introspection tool, the description adequately covers key behavioral details and return values for both Solana and EVM, and notes the Blockscout enrichment. Given that an output schema exists (as indicated), the description does not need to enumerate every return field. It lacks explicit error behavior, but that is not critical for a read-only introspection 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 coverage is 100% for both parameters, and the schema already provides formats for chain and address. The description adds some mapping between chain names and address types (base58 vs 0x), but this is marginal beyond the schema. It does not significantly enhance 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 clearly states the tool's function: 'Introspect ANY specific program/contract address on a chain.' It specifies the resource (program/contract address), the verb (introspect), and distinguishes from sibling tools like solana_getAccountInfo or evm_rpc by offering a higher-level, cross-chain introspection with chain-specific outputs.

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 any specific address across multiple chains, and the chain-specific details indicate when each format applies. However, it does not explicitly name alternatives or exclusions (e.g., 'use discover_programs to list programs'), but the 'ANY specific' phrasing gives clear context that this is for a known, single address.

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

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

With no annotations, the description carries full behavioral burden. It discloses the auto-discovery mechanism, hourly refresh, activity count semantics, and that 'discovered' entries are not yet named. It doesn't cover all possible behaviors (e.g., pagination, rate limits), but the disclosed traits are significant and non-obvious.

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, front-loaded with the purpose, then details. Every sentence adds value: the first identifies the resource and scope, the second explains the merged seed/auto-discovery behavior and usage context. No redundancy or fluff.

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

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

Given the tool's complexity (multi-chain, merged seed, hourly refresh, activity counts), the description covers the core semantics well. The output schema handles return details, and the description provides the necessary context for an agent to understand what the tool offers, including the pointer to describe_program for next steps.

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 (chain) with 100% schema description coverage, so the schema already documents it. The description repeats the chain list but adds no additional parameter semantics beyond what the schema provides, 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 clearly states the tool discovers on-chain programs/contracts across all supported chains, with a specific verb ('Discover') and resource. It distinguishes itself from siblings by explicitly mentioning the merged curated/discovered nature and pointing to describe_program for introspection.

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 ('learn what is actually active on-chain right now') and names the alternative tool ('then describe_program to introspect any specific address'). However, it doesn't provide explicit when-not-to-use conditions 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?

No annotations are provided, so the description carries the burden of disclosing behavioral traits. The verb 'report' and the overall health-check framing imply a read-only, non-mutating operation. However, it does not explicitly state 'does not modify data' or mention any access/rate limitations, which would have made it fully explicit.

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

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

Two sentences, no filler. The first sentence front-loads the purpose and key details, and the second sentence provides usage guidance. Every word 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 no parameters and an output schema present, the description gives all necessary context: what the tool reports, why it matters, and when to use it. It also names the sibling tools that produce the data being checked, making it clear why this health check exists in the tool ecosystem.

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

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

The tool has zero parameters and an empty schema, so there is nothing to explain. The baseline for zero parameters is 4, and the description correctly does not attempt to add parameter details that don't 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 starts with a specific verb ('Report') and clearly identifies the resource (freshness and health of the cross-chain program/token discovery pipeline). It lists concrete outputs (cron last ran, counts per chain, failed scans) and explicitly distinguishes itself from sibling tools by naming discover_programs and search_tokens as the data it helps validate.

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

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

The description gives explicit when-to-use guidance: 'Use this to check whether discover_programs / search_tokens data is current before relying on it.' This clearly indicates the tool is a prerequisite check for other discovery tools, providing both context and an alternative (the named sibling tools).

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

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

With no annotations, the description carries full burden. It does not disclose behavioral traits such as state mutations (e.g., eth_sendRawTransaction writes), error handling, rate limits, or authentication requirements. Only method names and chains are listed, lacking transparency on impacts.

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

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

The description is a single, front-loaded sentence that efficiently conveys the tool's purpose, examples, and supported chains without extraneous information.

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

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

Given the tool's complexity and lack of output schema, the description is incomplete. It does not explain the return format (likely raw JSON-RPC result) or error behavior. The list of methods and chains is helpful but leaves gaps for an agent to understand full usage.

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

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

All three parameters are fully described in the schema (100% coverage). The description adds value by providing concrete examples of methods and chain slugs, aiding the agent in selecting appropriate values beyond the schema definitions.

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 calls ANY EVM JSON-RPC method on supported chains, listing example methods and chains. It distinguishes itself from sibling tools like solana_rpc by focusing on EVM chains.

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 EVM chain interactions but does not explicitly state when to use this tool versus alternatives like Solana RPC tools. No when-not or exclusion criteria are provided.

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

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

Despite no annotations, the description provides clear behavioral context: it is a read operation that returns entity details for a given id, with specific return types for each entity. No side effects are mentioned, which is appropriate for a fetch. The description adequately compensates for lack of 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 concise, consisting of two sentences with no unnecessary words. The first sentence states the primary purpose, and the second provides details on accepted formats and return types. Every sentence adds value.

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

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

Given the presence of an output schema, the description does not need to elaborate on return values in detail. It succinctly covers the entity-specific return information. The single parameter is fully documented in both schema and description. The tool is simple and the description 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?

The input schema has 100% description coverage for the one parameter 'id'. The description adds further context on valid formats and how they map to different entities, but the schema already describes the id format. Thus the baseline of 3 is appropriate, with slight additional value.

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

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

The description clearly states the tool fetches the full document for a search result id, and specifies the format of IDs and the return types for each entity (tokens, programs, pools). This distinguishes it from sibling tools like 'search' which returns a list of results.

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

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

The description explicitly says the id comes 'from the search tool', guiding the agent to use search first. It also details the accepted id formats (token:<chain>:<address>, program:<chain>:<address>, pool:<address>), which helps in correct usage. However, it does not explicitly state when not to use this tool.

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

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

With no annotations, the description carries full burden. It discloses read-only and no-auth behavior, and provides detailed transparency about the metaAndAssetCctxs response being two parallel arrays correlated by position, warning against direct scanning and recommending rankBy. This is substantial behavioral disclosure 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?

The description is a dense paragraph but front-loaded with the core purpose. The long section on metaAndAssetCctxs is necessary and well-structured, explaining the gotcha and solution. No wasted words, though it could be split into shorter sentences for readability.

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

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

The description covers key aspects: read-only, type selection, and especially the complex metaAndAssetCctxs behavior. It does not specify output formats for other types (e.g., allMids, l2Book), but given the absence of output schema, it could be more complete. Overall, it is adequate for a multi-query 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 covers 100% of parameters with descriptions. The description adds extra semantics for rankBy (explains funding vs fundingAbs, joining, sorting, and response structure) and for type (names examples). This adds value beyond the schema, though schema alone would be sufficient for basic use.

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 queries the Hyperliquid Info API for perps/spot order-book data, explicitly read-only with no auth. It lists the 'type' field and examples (meta, l2Book, allMids, etc.), distinguishing it from generic fetch/api tools and other siblings.

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

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

The description explains what the tool does and when to use it (for Hyperliquid data) but does not explicitly compare with sibling tools or state when not to use it. It does provide strong guidance for metaAndAssetCctxs usage, directing to rankBy for sorted queries, which is a clear usage 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?

With no annotations, the description fully discloses behaviors: custodial vs non-custodial, gas-free when gated, return object shape, and constraints on name/ticker bytes. The bonding curve and USDG quoting are detailed.

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 single paragraph is dense but well-organized, front-loading the key purpose and default behavior. Every sentence contributes necessary detail, though breaking into sections could improve scannability.

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 (custodial/non-custodial, gating, bonding curve), the description covers all essential behavioral aspects, input constraints, and return values. Output schema existence further reduces need for return format details.

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 3. The description adds value by explaining the relationship between creator and build, and clarifies that image/links/description are off-chain metadata, exceeding mere schema repetition.

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

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

The description clearly states it launches a memecoin on the aeX402 launchpad with specific bonding curve parameters (fixed supply, starting price, graduation threshold). It distinguishes from sibling tools like aex402_buildSwap by focusing on token creation.

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 describes custodial (default) and non-custodial (build:true) modes, and notes the gating status pending upgrade. However, it does not explicitly contrast with alternative tools for similar tasks.

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

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

With no annotations provided, the description carries the burden of explaining behavior. It discloses that calling with only a server lists tools, and that a tool call invokes the remote tool. It does not mention error handling, return format, or side effects, but for a generic proxy, the described behavior is sufficiently transparent for typical use.

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

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

The description is concise and well-organized. It begins with the core action, then explains the condition, provides an example, and ends with usage guidance. No redundant or irrelevant information is included, making it efficient and easy to parse.

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 proxy tool, the description covers the essential usage scenarios: calling a tool and listing available tools. It does not address potential errors or the exact return structure, but given the absence of an output schema, this is acceptable. Overall, it provides enough context for an agent to understand how to interact with the tool.

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

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

The schema already provides clear descriptions for each parameter, including the optional nature of tool and arguments and the listing behavior. The description augments this by giving a concrete server example (slonana) and clarifying the context (tools without equivalents). While the schema covers most semantics, the description adds useful contextual meaning.

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

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

The description clearly states that this tool calls a tool on another MCP server, and explicitly distinguishes it from tools with direct equivalents in solana_rpc/evm_rpc. It provides an example (slonana's aea_list_services) and clarifies that it is for tools without a native JSON-RPC method, making the purpose specific and 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 provides clear guidance on when to use this tool: when a tool has no equivalent in the built-in RPC methods. It also instructs to call the server's tools/list first if the tool name is unknown, and explains that omitting both tool and arguments lists available tools. This effectively differentiates usage from sibling tools.

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

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

With no annotations, the description carries the burden and does disclose safety (READ-ONLY), boundedness (up to 32 calls), and aggregation semantics. But it leaves important traits — subcall failure collection, ordering guarantees, and result envelope behavior — to the schema (e.g., the ignoreFailures param description) rather than the tool description itself.

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?

Exactly three sentences, front-loaded: identity ("Primary LINQ-style MCP workflow tool"), mechanism (fan-out + compose), and usage guidance. Every sentence earns its place with zero filler, appropriately deferring technical detail to 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?

For a complex 6-param tool with nested objects, an output schema, and exhaustive 100% schema coverage, the lean description provides the correct mental model and is sufficient for orientation. Minor gap: it offers no guidance on when to prefer linq string vs pipeline vs reduce, though the schema examples largely compensate.

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 parameter is richly documented (linq syntax with examples, pipeline ops with a worked example, reduce ops, concurrency limits, ignoreFailures rationale). Per rubric, the baseline 3 applies since the schema carries the load; the description only loosely hints at the three composition modes without adding param-level meaning.

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

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

The description names a specific workflow with verb+resource+scope: "Run one bounded MCP call: fan out up to 32 READ-ONLY tool calls... then compose the combined result." It clearly distinguishes from siblings with "Use mcp_linq when you want one aggregate answer instead of N tool calls," positioning it against the single-call tools (evm_rpc, solana_rpc, mcp_call, fetch).

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 mcp_linq when you want one aggregate answer instead of N tool calls" is an explicit when-to-use trigger, and the "READ-ONLY" constraint implies it is not for mutation tools. However, it names no explicit alternatives or when-not cases beyond the read-only exclusion and the aggregate-use trigger.

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

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

With no annotations, the description carries the full burden. It discloses that the tool is free and never rate-limited, provides concrete pricing ($0.01 minimum buys 100 calls), lists all accepted assets/chains, and outlines the topup → session-token → API-key flow. This gives the agent clear expectations about cost, rate limits, and process.

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

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

The description is a single dense paragraph, front-loaded with the main purpose, and each clause adds specific, non-redundant detail. It could be slightly better structured with bullet points, but there is no filler or wasted words.

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 informational tool, the description fully covers the tool's scope: what the guide contains, when to use it, cost details, and credential attachment. The presence of an output schema covers return-format expectations, so the description 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?

The tool has zero parameters, so the baseline is 4. There are no parameter semantics for the description to add, and the schema already has empty properties.

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 is a 'complete self-serve guide' for paying for API access via x402 micropayments, and enumerates its contents (prices, assets/chains, merchant addresses, step-by-step flow). It also gives a specific trigger ('call it when you hit a 402 / rate limit'), which distinguishes it from sibling payment-execution tools.

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

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

The description explicitly says when to use the tool: 'call it when you hit a 402 / rate limit' and notes it is free and never rate-limited. However, it does not name specific alternatives or state when not to use it, relying on implicit distinction from sibling tools.

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

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

No annotations are provided, so the description fully discloses behavior: it is partial, depends on public signature DBs, leaves unknown selectors unresolved, and treats bytecode as ground truth. It also clarifies proxy handling in the schema. The description is honest about limitations.

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

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

The description is concise, front-loaded with the core purpose, and each sentence adds value—scope, method, limitations, and usage context are all covered without redundancy.

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

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

Given the tool's specialized nature and presence of an output schema, the description sufficiently covers purpose, limitations, and alternatives. It doesn't need to describe return values because the output schema handles that, and it gives actionable guidance for edge cases.

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

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

Schema coverage is 100% with meaningful descriptions for both chain and address, including proxy guidance. The description adds no parameter-specific details but isn't required to since the schema already provides thorough 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?

Clearly states the tool reconstructs a partial function/event interface from bytecode for EVM contracts, with specific outputs (PUSH4 selectors and topic0 hashes) and no source/verification requirement. Distinguishes itself from a full ABI and mentions decompilation as an alternative for unresolved selectors.

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 ('to understand what an unknown contract does before trusting behavior-based guesses') and when not to rely on it (not a full ABI; use decompile for novel/proprietary selectors). This provides clear context and 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?

Though annotations are absent, description discloses that output is a result list to be passed to a fetch tool, implying read-only behavior. No side effects or destructive actions hinted. Could be more explicit about non-destructiveness but sufficient for a search 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?

Three sentences, front-loaded with verb and scope, then output usage, then alternative guidance. No filler, each sentence serves a distinct purpose.

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 single parameter with full schema coverage and existence of output schema, description covers search scope, output usage, and sibling differentiation comprehensively. No gaps identified.

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?

Parameter 'query' is fully described in schema with examples. Description reinforces by listing types but adds no new semantic details beyond schema. Baseline score for 100% 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?

Description clearly states verb 'search' and specifies resources (tokens, programs, pools) across multiple chains. Explicitly distinguishes from sibling tools by directing to specialist tools when entity type is known.

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

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

Provides explicit guidance: use this tool for broad keyword search, and use specialist tools (search_tokens, discover_programs, aex402_listPools) when entity type is known, fulfilling when-to-use and when-not-to.

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

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

No annotations exist, so description carries full burden. It discloses hourly refresh, spam-filtering, and that HyperEVM canonical tokens include live spot price and 24h volume. Also lists return fields (address, standard, decimals, etc.).

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 well-structured sentences. No fluff: first sentence states purpose and returns, second adds frequency and 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?

Given the tool's complexity (multi-chain search, multiple token standards, market data), the description covers essential aspects. Output schema exists, so return values don't need further elaboration.

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

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

Schema coverage is 100% with descriptions for all three parameters. The description adds value by explaining the chains, giving usage examples, and detailing what the output contains, 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 it searches a live token/NFT census for two specific chains (Robinhood Chain, HyperEVM) by symbol or name. It distinguishes from sibling 'discover_programs' by specifying when to use each.

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?

Explicit guidance to use this instead of discover_programs for specific assets, with examples like 'USDC on hyperevm'. Lacks explicit when-not cases, but the alternative 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?

With no annotations provided, the description carries the burden of behavioral disclosure. It clearly indicates the tool only constructs and returns instruction JSON rather than executing a transaction, which is a key side-effect-free behavior. The mention of 'client-side TX construction and signing' further signals that no broadcast occurs. It could additionally note that no network call is made, but the current wording is sufficiently transparent.

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, efficient sentence that conveys the tool's core function, supported asset types, and return value. There is no redundancy or filler; every word contributes to understanding the tool's behavior and output.

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

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

The description is sufficiently complete for a tool of this simplicity. It covers the operation (building a transfer instruction), the asset types (SOL and SPL), and the output format (JSON with programId, keys, data), which aligns with the existence of an output schema. An agent can confidently select and invoke the tool based on this description and 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 already provides complete descriptions for all four parameters (100% coverage), including the distinction between native SOL and SPL token transfers and atomic units. The description adds no additional parameter-level details beyond the schema, so it appropriately meets the baseline without further compensation.

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

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

The description uses the specific verb 'Build' and identifies the resource as 'a SOL or SPL token transfer instruction', making its function unambiguous. It also distinguishes itself from related siblings like solana_sendTransaction by clarifying it returns instruction JSON for client-side construction and signing, not broadcasting the transaction.

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 its use case: building an instruction as a precursor to sending, explicitly stating it is for 'client-side TX construction and signing'. It does not explicitly name alternatives or when not to use it, but the sibling context (e.g., solana_sendTransaction for sending) makes the intended workflow clear enough for an agent.

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

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

The description implies a read-only operation ('Get raw account info'), but does not explicitly state side effects, safety, or permissions. With no annotations provided, the description carries full burden; it is minimally adequate but lacks depth.

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 no wasted words. It is front-loaded with the essential verb and resource, making it easy to scan.

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

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

Given the simplicity of the tool (a basic getter) and the presence of an output schema (not shown but noted), the description covers the necessary context. It identifies the key returned fields and the supported encoding options.

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

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

Schema coverage is 100%, so the baseline is 3. The description does not add meaning beyond the schema: it mentions 'raw account info' but does not clarify parameter formats or constraints beyond what 'base58' and 'base64/jsonParsed' already convey.

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

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

The description clearly states the verb 'Get', the resource 'raw account info', and specifies the fields returned (owner, lamports, data). It distinguishes the tool from siblings like solana_getBalance (which only returns balance) and solana_getSignaturesForAddress.

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

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

No explicit guidance on when to use this tool versus alternatives. While the purpose is clear, there is no mention of prerequisites, when not to use it, or how it compares to other Solana query tools.

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

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

No annotations are provided, so the description carries full burden. It discloses that the balance is returned in lamports and provides conversion to SOL. It does not mention any behavioral traits like rate limits or auth needs, but for a simple read operation, this is sufficient.

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 two sentences, no redundant information, and front-loads the purpose. Every word serves a purpose.

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

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

Given that an output schema exists (as indicated by context signals), the description need not explain return values. It covers the essential information for using the tool correctly: what it does, units, and conversion. Complete for its complexity.

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

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

Schema description coverage is 100% with one parameter 'address' already described as a base58 wallet address. The description does not add new semantic information about the parameter beyond the schema, so baseline score 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 clearly states the tool's purpose: 'Get SOL balance for a wallet address (in lamports).' It specifies the verb (Get), resource (SOL balance), and provides conversion context. Among sibling Solana tools, it uniquely identifies its function.

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

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

The description implies usage for retrieving SOL balance but does not explicitly state when to use vs alternatives or provide exclusions. Given the straightforward nature of the tool, the guidance is adequate but lacks explicit comparisons.

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

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

With no annotations provided, the description only states the return fields but fails to disclose behavioral traits such as idempotency, side effects, or rate limits. A read operation is implied but not confirmed.

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 two front-loaded sentences, no wasted words, and directly conveys the tool's purpose and return 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?

Given the tool's simplicity (zero parameters, clear return fields), the description is complete. The output schema is stated in the description, so no further detail is necessary.

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

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

There are no parameters, so the description adds no parameter-level information beyond the schema. Baseline score of 4 applies as per guidelines for zero-parameter tools.

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 'Get', resource 'latest blockhash', and purpose 'for transaction building', making it distinct from sibling tools like solana_getSlot or solana_getBalance.

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

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

The description provides clear context that this tool is used for transaction building, implying it should be called before building a transaction. However, it lacks explicit when-not or alternative tool references.

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?

Description claims 'up to 20 most recent' but schema allows limit up to 1000, creating a direct contradiction. No mention of read-only behavior or other traits. With no annotations, description carries full burden but is misleading.

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, front-loaded, but second sentence is inaccurate regarding limit. Conciseness undermined by inaccuracy.

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?

Has output schema, so return values are covered, but description fails to accurately describe limit behavior (contradicts schema). No explanation of pagination or how to get more than 20 signatures. Incomplete for safe usage.

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

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

Both parameters have schema descriptions with 100% coverage. Description adds no new detail about parameters beyond schema, achieving baseline for high 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?

Clearly states verb 'Get', resource 'transaction signatures for an address', and scope 'recent, up to 20 most recent'. Distinct from sibling tools like solana_getTransaction which retrieves a single transaction.

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?

Implied usage to retrieve signatures for an address, but no explicit guidance on when to use versus solana_getTransaction or other siblings. No when-not-to-use or alternative hints.

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

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

With no annotations, the description carries the full burden. It correctly indicates a read-only, non-destructive operation, but could mention that it's a lightweight RPC 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?

The description is a single, focused sentence with no wasted words, perfectly matching the tool's simplicity.

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 no parameters and an output schema present, the description is largely complete. A slight improvement could be mentioning the return type, but the output schema covers it.

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

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

There are no parameters, so the description adds no extra meaning beyond the schema. Baseline score of 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 'Get the current slot number' uses a clear verb-resource pattern and distinctly identifies the tool's function among siblings like solana_getBalance or solana_getTransaction.

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

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

No explicit guidance on when to use this tool vs alternatives is provided. However, for a simple query with no parameters, the context is clear enough to infer basic 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?

No annotations provided. The description only states return fields (mint, balance, decimals) but does not disclose behavioral traits like read-only nature, pagination, rate limits, or prerequisites such as wallet existence.

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

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

Two sentences, no fluff. Clear and 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?

For a simple query tool with one parameter and an output schema, the description is sufficient. However, it lacks any notes about error handling or edge cases, but given the low complexity, it's nearly complete.

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

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

The schema has 100% description coverage for the single parameter 'owner' (base58). The description adds minimal extra meaning beyond 'Wallet address (base58)'. 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 clearly states the verb 'Get' and resource 'SPL token accounts' scope 'owned by a wallet'. It distinguishes from siblings like solana_getBalance (SOL balance) and solana_getAccountInfo (general account info).

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. It does not mention when not to use it or provide context about token vs SOL balance queries.

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

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

No annotations are present, so the description must cover behavioral traits. It conveys that the tool is read-only and returns full details, but does not mention potential failure modes, costs, or response size.

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

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

The description is a single, concise sentence that immediately conveys the core purpose. No extraneous information is present.

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

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

Given the tool has an output schema and one clearly described parameter, the description is mostly complete. However, it lacks usage context and behavioral details that would help an agent choose this tool over similar ones.

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 description repeats 'by signature' without adding meaning beyond the schema's 'base58' note. The description does not elaborate on the parameter's format or constraints.

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 'Get' and resource 'full transaction details' with a specific input 'signature'. It distinguishes from sibling tools like solana_getAccountInfo and solana_getBalance by emphasizing instructions, logs, and status.

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 provided on when to use this tool versus alternatives such as solana_getAccountInfo or simpler queries. The usage is implied but not clarified with conditions 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?

No annotations are provided, so the description carries the full transparency burden. It does outstanding work by detailing inert stubs, warning about their deceptive behavior, and confirming source-level verification. It does not disclose auth/error/rate/rate-limit behavior, but for a generic RPC proxy this still creates solid behavioral transparency.

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

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

The description is dense and slightly run-on, but every part adds value: main purpose, network alternatives, unusual methods, latent stubs, and sibling-tool routing are all covered. It is appropriately front-loaded with the core action and stays compact enough given the scope.

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?

There is no output schema and no annotations, but the description still covers the necessary use-case context: when to use this tool, which alternatives exist, special network behavior, and even deceptive stubs. For the complexity of a generic RPC helper, this is unusually complete.

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

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

The schema already has full descriptions for all three parameters. The description adds more semantic value, especially for 'network': it explains that the Slonana network exposes extra RPC methods and identifies which methods are special. This goes beyond the baseline but is not exhaustive for every parameter.

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

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

The description states 'Call ANY Solana-compatible JSON-RPC method by name' with examples, which is a specific verb + resource. It also explicitly distinguishes this tool from the typed solana_* tools, making its scope 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?

It provides explicit guidance on when to use the generic RPC surface, when to select 'network=slonanza' for network-specific methods, and directs Slonan-specific MCP-only tools to mcp_call. This goes well beyond what a typical description provides.

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

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

No annotations were provided, so the description must carry the full burden of behavioral disclosure. It does not mention that submission modifies state (destructive), potential fees, error cases, or confirmation behavior. Only the basic action and return type are given.

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

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

The description is a single sentence with no wasted words. It is efficient but could include more context without being verbose.

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

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

The tool has only one parameter, which is well-documented in the schema, and an output schema is indicated. However, for a mutation tool, the description lacks crucial details about side effects, success/failure conditions, and network interaction, making it only partially 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 description adds no additional meaning beyond what the schema already provides for the 'transaction' parameter. 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 clearly states the verb 'Submit' and the resource 'a signed transaction to the network', with the output 'Returns transaction signature'. This distinguishes it from siblings like solana_buildTransfer (build transaction) and solana_getTransaction (query).

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 on when to use this tool vs alternatives, such as prerequisites (e.g., transaction must be built and signed first) or when not to use it.

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