Robyn — Gasless Cross-Chain for AI Agents

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

No annotations are provided, so the description must disclose behavior. It states 'Free, read-only, moves nothing,' which confirms no side effects. However, it does not mention error handling, rate limits, or auth requirements, leaving some gaps.

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, directly stating purpose and read-only nature. Every word is necessary and no extraneous information exists. It is optimally concise.

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 (2 params, nested object), no output schema, and no annotations, the description covers verification behavior and read-only safety. It lacks details about return values or failure modes, but is largely complete for an agent to understand its function.

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

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

Schema description coverage is 100%, so the schema already documents all parameters. The description adds minimal extra meaning (e.g., 'recovers the expected account' hints at output), but does not significantly enhance understanding beyond what the schema provides.

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

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

The description clearly states the tool's purpose: verifying a signed EIP-7702 authorization tuple by recovering the expected account and checking nonce. This is specific to a well-defined task and distinguishes it from sibling tools like robyn_7702_delegate or robyn_sponsor_7702.

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 verifying authorizations and notes it is free and read-only, but does not explicitly state when not to use it or mention alternatives. Without exclusions, guidance is adequate but not thorough.

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 only declares 'Read-only,' missing other behavioral traits like idempotency, response format, or data freshness. Minimal extra value beyond the read-only hint.

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

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

Two sentences with zero waste. Information is front-loaded and directly addresses the tool's purpose without extraneous 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?

For a zero-parameter info tool with no output schema, the description fully explains the return values (address per chain, ABI, EIP-712 scheme) and notes the read-only nature. Complete given the tool's simplicity.

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?

No parameters, so baseline is 4. The description adds context about what the tool returns (address, ABI, schema), compensating for absence of output schema. No param-related confusion.

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

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

The description clearly states the tool provides the canonical delegate address, ABI, and EIP-712 scheme for EIP-7702. It specifies the scope (22 EVM chains) and distinguishes from siblings by focusing on static delegate 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?

The description implies usage for delegation and sponsored transactions ('Delegate to this and the relayer can sponsor your transactions'), but lacks explicit when-to-use or alternatives compared to siblings like robyn_sponsor_7702.

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, so the description carries the burden. It discloses key behaviors: returns a signed attestation, includes a timestamp, covers all components, and verifies privacy invariants. It also explains how to verify the signature (recover signer over digest). This covers the core behavioral contract, though it doesn't detail failure modes or edge cases like what happens if invariants don't hold.

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?

Description is well-structured and reasonably concise. It front-loads the main purpose (returns signed attestation), then adds details on what it covers and how to verify. Every sentence adds value, though it could be tightened slightly. Overall 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?

No output schema exists, so the description must explain return value. It does this thoroughly: describes the attestation content (liveness + privacy invariants), mentions signature, and instructs verification. Also gives the intended use case. This is sufficient for an agent to understand what to expect and how to use 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?

Zero parameters, so no parameter documentation needed. The description doesn't need to add parameter info. Baseline 4 is appropriate since there's nothing to document beyond what the schema shows (empty object).

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 returns a relayer-signed attestation proving liveness and privacy invariants. It specifies the exact components covered and the cryptographic verification methodable. While it distinguishes from many siblings by being an attestation, it doesn't explicitly contrast with similar status/check tools like robyn_route_status, but the description 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?

Explicitly states when to use: 'Use this to programmatically decide whether to trust this router before routing value through it.' This is clear use-case guidance)Skip, though it doesn't explicitly say when not to use it or mention alternatives. The context is sufficient for an agent to decide.

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

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

With no annotations, the description fully discloses behavioral traits: the output is a 'RECORD, not a guarantee', may be stale ('does not promise the same capability a minute later'), and the signature does not imply an SLA. It also clarifies the meaning of `notServiceable`. This is substantial transparency beyond any possible annotation.

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

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

The description is front-loaded with the core purpose, then layered with usage instructions, field clarification, and limitation caveats. Each sentence earns its place: the field emphasis, the fallback explanation, and the non-SLA disclaimer are all necessary for correct use. No fluff.

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

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

Despite having no output schema and no annotations, the description provides a comprehensive picture: what the tool returns (capability categories), how to use the key field (`serviceableNow`), what `notServiceable` contains, and critical caveats (not a guarantee, may change). This is sufficient for an agent to decide when to call it and how to interpret results.

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 schema offers no parameter details. The description compensates by explaining output fields like `serviceableNow`, `policyEligible`, and `notServiceable`, adding semantic meaning even though these are not parameters. A 4 is appropriate given the baseline for zero parameters.

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

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

The description clearly states the tool produces 'a signed, timestamped record of current capability' and enumerates exactly what it covers (chains payable now, policy-eligible chains, execute-ready rails, delivery estimation). This goes beyond a simple verb+resource and clearly distinguishes it from sibling tools like robyn_quote or robyn_preflight by focusing on current operational capability.

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 is given: 'USE serviceableNow, NOT policyEligible, when deciding where to send funds' with a concrete explanation of why (policy eligibility may not reflect inventory). It also instructs to 'Fetch this BEFORE committing to a multi-step plan' and explains the evidence value. This is direct, actionable usage context.

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 explains the behavioral traits: it explicitly discloses that `breaking:true` is a compatibility claim, not importance; `mustAct` should be checked first and may indicate the integration is already failing; and `entries[].action` should be read. This is excellent transparency for a read-only changelog 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?

The description is three sentences, each earning its place: it opens with the tool's purpose, then explains usage, and ends with critical interpretation guidance. It is appropriately sized and front-loaded, though it could be slightly condensed without losing 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 only one parameter and no output schema, the description adequately covers the return fields (`breaking`, `mustAct`, `entries[].action`) and the interpretation workflow. It doesn't address error handling or invalid versions, but for a simple changelog tool it is sufficiently complete.

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

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

The schema already provides 100% coverage for `since` with 'the API version you built against.' The description adds a similar phrase and clarifies the filter behavior, but it doesn't introduce new information beyond the schema, so the baseline of 3 is appropriate.

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

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

The description clearly states the tool provides 'Machine-readable API history' and returns what has changed since a given version, with a specific verb and resource. It distinguishes itself from siblings by focusing on versioned changes and compatibility impact, which no other sibling tool name suggests.

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

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

The description gives clear usage context by instructing to pass the build version as `since` and explains the workflow of checking `mustAct` first and reading `entries[].action`. It doesn't explicitly name alternatives or exclusions, but the context is unambiguous, so no further guidance is needed.

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?

Even though no annotations are provided, the description carries the full transparency burden and does so thoroughly. It discloses that the tool is NOT a reputation score, says nothing about honesty, warns about compromised keys, and explicitly flags that float-lane payouts are excluded, so 'first time' may be incorrect.

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

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

The description is long but every sentence earns its place, delivering critical safety warnings and usage context. It is front-loaded with the core purpose and then expands into necessary caveats without any filler.

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

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

For a counterparty-check tool with no output schema, the description is remarkably complete: it outlines the kind of result ('first-time-recipient'), mentions the `coverage` field, and explains the practical action to take. The caveats around false confidence are essential context for safe use.

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

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

Schema description coverage is 0%, so the description must compensate. It adds meaning to `toAddress` as the recipient address being checked and to `amount` as the value compared for typicality. It does not specify formats, but the core semantics are clear enough for correct invocation.

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 shows 'Your OWN payment history with a recipient address: how many times, how recently, and whether this amount is typical.' This goes well beyond the title and distinguishes it from reputation scoring, fulfilling a specific verb+resource purpose.

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

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

It explicitly says 'Call it before paying an address you have not confirmed' and explains when not to use it, such as never treating it as a trust/safety signal. It also gives actionable guidance on first-time recipients and warns against telling users an address is 'trusted' or 'safe'.

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 bears full responsibility. It explains the behavior: returns a payload to sign, the server does not hold the key, and the relayer broadcasts on submission. It lacks details on error handling or rate limits but is transparent about the core workflow and security.

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 deliver essential information efficiently. The most critical action ('Plan a gasless cross-chain move') is front-loaded, and every sentence adds value 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 has 6 parameters, no output schema, and no annotations, the description covers the overall purpose and workflow adequately. It lacks detail on the returned payload structure and error scenarios, but the presence of sibling tools like 'robyn_route_status' may cover status tracking.

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 50% with only three parameters described in the schema. The description adds no additional meaning or context for any parameters, missing an opportunity to clarify formats (e.g., chain IDs as numbers or strings) or the optional 'toAddress' field.

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 plans a gasless cross-chain move and returns a payload to sign. It distinguishes itself from siblings by referencing 'robyn_submit' for submission, 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 a sequential workflow: call this, sign the returned payload, then call 'robyn_submit'. It also notes the server never holds the key, which is a key usage caveat. However, it does not explicitly exclude other sibling tools or 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 provided, the description carries the full burden. It discloses a key behavioral caveat: below a sample threshold, the figure is a static estimate marked 'insufficient-data', not a measurement. It also instructs users to say which one they are quoting. This is strong, but it does not fully describe the return format or other edge cases, so a 4 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?

The description is two sentences, each well-chosen. The first states the primary function, and the second delivers a critical caveat and user guidance. There is no fluff or redundancy, and all content earns its place.

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

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

Given no output schema or annotations, the description covers the core purpose and the crucial reliability caveat (insufficient-data vs. estimate). It could be slightly more explicit about the successful output shape (e.g., fields and units), but for a simple read-only stats tool, it is reasonably complete. A 4 reflects this minor gap.

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

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

The tool has zero parameters, so the description has no parameter semantics to add. The mention of 'basis' and 'status' likely refers to fields in the output rather than inputs. With 0 parameters, a baseline score of 4 applies, and the description does not need to explain parameter details.

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

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

The description clearly states what the tool does: it provides actual measured settlement delivery times per rail and per corridor, contrasting with a single advertised constant. This distinguishes it from sibling tools and specifies the resource and scope. The implicit verb (e.g., 'returns'/'provides') is clear from context.

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

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

The description gives clear context: use this when you need real measured times rather than advertised constants. It also tells users to check basis/status and to distinguish between measurements and estimates. However, it does not explicitly name alternative tools or provide exclusion criteria, so it stops short of a 5.

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

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

No annotations are provided, so the description carries the full burden. It discloses that the tool returns error codes, retryability, and recovery actions. There is no contradiction with annotations. It provides clear behavioral context for a read-only reference 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?

The description is extremely concise: two sentences that convey all necessary information without any wasted words. It is front-loaded with the key purpose and includes actionable advice.

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 no parameters, no output schema, and no annotations, the description fully covers its purpose and behavior. It tells the agent exactly what data to expect and how to use it (branch on errorCode). This is complete for a reference tool.

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

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

The tool has zero parameters (schema coverage 100%). The description adds meaning by explaining what the tool returns (error taxonomy), which is valuable beyond the empty schema. Baseline for 0 parameters is 4, but the description is exceptionally clear about the output content.

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 provides 'the full error taxonomy: every errorCode, whether it is retryable, and the suggested recovery action.' This is a specific verb-resource pair and distinguishes it from sibling tools which perform actions like check, delegate, submit, etc.

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

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

The description includes explicit guidance: 'Read this once and branch on errorCode instead of parsing messages.' This tells the agent exactly when and how to use the tool. However, it does not explicitly state when not to use this tool or provide alternatives, but given it's a reference tool, the guidance is sufficient.

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

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

With no annotations provided, the description carries the full burden, and it excels: it discloses the signature integrity (swapping components invalidates), the verdict being the weakest of its parts, the meaning of 'undetermined' (not verified), and the presence of 'unavailable' components with reasons and the 'incomplete' check. These behaviors are critical for correct use and go far beyond what a schema could convey.

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

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

The description is information-dense but every sentence earns its place: the component list, the signing property, the verdict warning, and the unavailable/incomplete note. It is front-loaded with the most important content and flows logically from what the tool produces to how to interpret it, 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 no output schema, the description effectively explains the return semantics: what components the bundle contains, how to interpret the verdict (including the dangerous 'undetermined' case), and how missing components are signaled. It also covers the signature invalidation constraint, making the description complete enough for an agent to safely invoke and present the tool's output.

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% parameter coverage, so the baseline is 3. The description does not add parameter-specific meaning, but it doesn't need to because the schema already describes 'id', 'minAmount', and 'recipient' adequately. The description focuses on the tool's output and interpretation, not on parameter details.

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

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

The description opens with 'Assembles EVERYTHING about a settled transfer in one call' and explicitly enumerates the components (on-chain verification, fee breakdown, alternative route cost, delivery time), making the tool's purpose unmistakable. It also distinguishes itself as 'the artefact to hand to a principal who was not there', differentiating it from simple verification or query 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?

It clearly states when to use it: to present evidence to a principal who was not present. It adds a strong procedural instruction ('READ verdict BEFORE PRESENTING IT') and explains what to do if verdict is undetermined. However, it does not explicitly name alternative tools or state when not to use it, so it lacks the explicit exclusion/alternatives of a 5.

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

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

With no annotations provided, the description carries the burden of behavioral disclosure. It explicitly states that unattributable amounts are returned as `unattributed` rather than being folded into other lines, and instructs the user to report this field instead of treating the breakdown as complete. This is meaningful behavioral context beyond a generic description, though it does not detail auth requirements or error handling.

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 and front-loaded with the primary action ('Reconstruct a settled transfer unit by unit'). The second sentence provides valuable guidance about the `unattributed` field without unnecessary fluff. Every sentence earns its place.

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

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

For a single-parameter tool with no output schema, the description provides sufficient context: it explains the purpose, the types of breakdown lines, and the special handling of unattributeable amounts. It does not discuss error cases or return format details, but these are less critical for this simple forensic tool. The description is complete enough for an agent to know what to expect and how to handle 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?

The input schema covers the single parameter `id` with the description 'settled transfer id', and the tool description echoes 'settled transfer' but adds no new detail about the id's format, source, or validation. Given 100% schema coverage, the baseline is 3; the description adds no meaningful parameter-level semantic value beyond what the schema already provides.

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

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

The description clearly states the tool's purpose with a specific verb ('Reconstruct') and resource ('a settled transfer unit by unit'), and enumerates the output categories (destination payout gas, Robyn margin, subsidy). This makes it distinct from sibling tools like robyn_netting_statement, which focus on statements rather than forensic breakdowns.

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 but provides no explicit guidance on when to use it versus alternatives. It does not mention when not to use, what prerequisites exist, or how it compares to sibling tools. The only implicit cue is that it applies to settled transfers, but no clear decision framework is given.

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 transparency burden. It discloses the critical behavior that `changesOutcome: true` moves where money lands and requires user confirmation, and that the tool will honestly report no improvement rather than fabricating suggestions. This is meaningful 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 dense and well-structured, with a clear list of output categories and a highlighted CRITICAL warning. The opening sentence 'Turns a price into a decision' is somewhat vague, but every subsequent sentence earns its place.

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

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

Given no output schema and 0% parameter coverage, the description is incomplete. It provides rich behavioral context but fails to explain input parameters or the exact return structure, leaving the agent without enough detail to reliably construct a correct invocation or parse the results.

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 0% and the description provides no explanation of the six parameters (fromChain, toChain, amount, toToken, fromToken, toAddress). The agent is left without input semantics, which is a critical gap.

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: it turns a price into quantified improvement suggestions (cheaper destination chain, cost thresholds, float lane, rail availability). It distinguishes itself from sibling tools by focusing on cost-improvement decisions rather than quotes or route status, though it does not explicitly name alternatives.

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

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

The description implies usage when a transfer price already exists and cost improvements are desired, especially by noting 'if nothing can be improved it says so'. However, it does not explicitly state when to use this tool versus siblings like robyn_quote or robyn_fee_forensics, nor does it provide 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?

With no annotations provided, the description carries the full burden of behavioral disclosure. It thoroughly explains the tool's scope (lints the request only), potential consequences ('unsafe can lose money or make you report something untrue'), and its limitations (cannot see verification branch logic). This goes well beyond a simple statement and fully discloses what the tool does and does not do.

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 not verbose. It front-loads the core action ('Post the request...') and then adds valuable instructions and caveats in a structured way. Every sentence earns its place: purpose, when to use, safety warning, and limitation. No fluff or redundancy.

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

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

The tool has no output schema, so the description should explain return values. It partially does: 'get back what is missing or unsafe, with the concrete consequence' and mentions 'Findings marked unsafe.' This is sufficient for a 2-parameter lint tool, though a bit more detail on the exact output structure would make it fully 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 already provides 100% coverage for both parameters (endpoint and payload) with clear descriptions. The tool description does not add additional meaning beyond what the schema states, though it reinforces the intent of 'the request you INTEND to make.' Baseline 3 applies as the schema does the heavy lifting.

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

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

The description clearly states the tool's purpose: 'Post the request you INTEND to make and get back what is missing or unsafe, with the concrete consequence.' It uses a specific verb ('Post') and resource ('the request'), and distinguishes itself from sibling tools by emphasizing that 'it lints the REQUEST only' and cannot verify integration logic, which separates it from broader preflight/verification 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 provides explicit when-to-use guidance: 'Run this before your first live execute.' It also gives when-not-to-use context: 'A clean lint does NOT mean your integration is correct' and warns against proceeding with unsafe findings. However, it does not name alternative sibling tools (e.g., robyn_preflight_full) explicitly, so it lacks explicit 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?

Since no annotations are provided, the description carries the full burden and does so admirably. It discloses that every spend was verified on-chain, amounts reflect what the chain showed arrived (not agent-reported), and that Robyn can only account for money moved through Robyn. This is substantial and trustworthy 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 moderately sized but every sentence adds distinct value: core definition, usage timing, verification detail, scope limitation, and a presentation warning. It is well-structured and front-loaded with the primary purpose, 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?

For a tool with one parameter, no annotations, and no output schema, the description is exceptionally complete. It explains the certificate's contents (spends, budget, total, compliance), its signed nature, the on-chain verification process, and the scope limitation, leaving no major 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?

The only parameter, mandateId, is not mentioned in the description. The description references 'a mandate' but does not explicitly map this to the mandateId parameter or explain how to obtain it. With 0% schema coverage, the description fails to compensate, leaving the parameter semantics underspecified.

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 produces a signed certificate listing every spend counted against a mandate, the budget, the total spent, and compliance status. This specific verb+resource combination distinguishes it from other Robyn tools, especially by emphasizing it certifies adherence to a ROBYN budget, not total spending.

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 an explicit usage context ('Hand it to the principal at the end of a period') and a clear exclusion: it does not certify that the agent spent nothing elsewhere and should not be described as proof of total spending. This is strong when/when-not guidance, even though no alternative tool is named.

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 the return values (WITHIN_MANDATE, EXCEEDS_MANDATE, EXPIRED) and the remaining budget, plus an important behavioral warning about not splitting spends. It also clarifies the mandate's scope and non-custodial nature, which is critical context beyond the basic function.

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 well-structured and front-loaded. The first sentence states the purpose, followed by return values, then a critical warning, and finally a scope note. Every sentence earns its place and the length is appropriate for the tool's complexity.

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

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

Given no annotations and no output schema, the description fully covers what the tool does, how to interpret results, how to react to an exceedance, and the scope of the mandate. It equips an agent with all necessary context to select and invoke the tool correctly.

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

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

The input schema already provides full 100% coverage for both parameters: amount is 'proposed spend in base units' and mandateId is 'the mandate digest'. The description adds no new parameter-level semantics beyond what the schema states, so the baseline of 3 is appropriate.

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

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

The description clearly states the tool checks a proposed spend against a signed spending mandate before making it. It names the specific action (check), the resource (mandate), and the timing (before spending), distinguishing it from siblings like robyn_mandate_status that likely only query mandate 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?

The description explicitly says to use it BEFORE making a spend, provides a clear directive for the EXCEEDS_MANDATE case (do not split, ask to raise budget), and notes the scope limitation (mandate covers only spending through Robyn). This gives strong when-to-use and when-not-to-use guidance, even without naming 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, the description carries the burden. It discloses critical behavioral traits: the digest binds the mandate, transfer, and amount, and that approvals cannot be reused. However, it lacks explicit statement about whether the tool is read-only or has side effects, and does not describe error/refusal behavior beyond the digest-presentation advice.

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 three sentences, front-loaded with the core purpose and followed by two critical caveats. Every sentence adds value, and the structure is tight with no redundancy.

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

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

Given the lack of output schema and annotations, the description provides sufficient context for a check tool: when to use, what it returns (digest), and how to handle a common refusal. It does not elaborate on error conditions or edge cases, but it is adequate 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 coverage is 0%, so the description must compensate. It indirectly explains all three parameters by stating the digest binds the mandate (mandateId), the transfer (transferId), and the amount (amount). This adds semantic meaning beyond bare parameter names, though it does not detail formats or units.

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 checks whether a specific spend requires principal approval and retrieves the exact digest to sign. It distinguishes itself from siblings by specifying the co-sign threshold context and the binding nature of the digest to mandate, transfer, and amount.

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 states the tool applies to mandates with a co-sign threshold and provides guidance for the refused-large-spend scenario: present the digest rather than splitting the spend. It does not name alternative tools but gives clear contextual when-to-use guidance.

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

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

With no annotations, the description must disclose behavioral traits. It explains the cursor mechanism ('Pass the returned cursor back as since') and the set of events covered, which gives insight into how the tool behaves incrementally. It does not mention rate limits or error behavior, but for a read-only polling tool, 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 three sentences, front-loaded with the core verb and resource. The cursor usage and intended use case are explained without redundant details. Every sentence contributes value, making it 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 no output schema and simple optional parameters, the description adequately covers the tool's purpose, event types, pagination, and a representative use case. It lacks an explicit statement about the return format (beyond the cursor), but this is reasonably inferable from a polling tool with these event types.

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 no descriptions, and the description compensates by explaining the 'since' parameter as a cursor from a previous call. However, 'limit' and 'principal' are not explicitly clarified; their meanings are only implicit from the context (e.g., 'a principal's mandates'). With 0% schema coverage, more explicit parameter guidance would be expected.

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

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

The description uses a specific verb 'Poll' and clearly enumerates the exact event types (spend, nearly-exhausted, exhausted, approval-required, revoked) on a principal's mandates. It also differentiates from siblings by emphasizing polling for events rather than static checks, making its purpose unmistakable.

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 states when to use this tool ('tell a principal their budget is running low or that a large payment is waiting on their approval') and provides context that this replaces manual checking. However, it does not explicitly name alternative tools or state when not to use it, so it falls short of a 5.

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

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

With no annotations, the description carries the burden. It discloses a critical behavioral trait: live mandates can be drawn against without further approval, emphasizing the urgency of revocation. Though it does not explicitly state that listing is read-only or non-mutating, the 'List' verb and warning provide useful context.

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

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

The description is three sentences: the first states the purpose, the second provides critical usage guidance, and the third advises on revocation. Every sentence contributes value; there is no fluff or repetition. It is front-loaded with the core function.

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 list tool with one parameter and no output schema, the description is complete: it explains what is listed, the key fields returned, the recommended usage context, and the safety implications. It also gives actionable advice, making it sufficient for an agent to decide when and how to use it.

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

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

The schema includes one parameter, 'principal', with a description already covering it (the principal address). The tool description also mentions 'principal address' but does not add extra meaning, such as format, examples, or constraints. Schema coverage is 100%, so the baseline 3 is appropriate.

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

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

The description clearly identifies the tool as listing all mandates for a principal address, specifying the returned fields (remaining budget, co-sign threshold, expiry, revocation state). This verb-resource pairing and scope distinguishes it from sibling tools like robyn_mandate_check or robyn_mandate_status, which likely target individual mandates.

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 usage context: 'Use this before telling a user they are safe' and explains why (live mandates can be drawn on without further approval). It does not mention when not to use it or name alternative tools, but the directive is clear and practical.

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 of behavioral disclosure. It does reveal a key behavioral trait: consumption counts only verified on-chain transfers, preventing inflation. However, it does not disclose whether the operation is read-only, potential error conditions, auth requirements, or the return format. This is a partial disclosure.

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

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

The description is a single sentence, front-loaded with the core purpose and followed by an important caveat. Every word earns its place; there is no redundancy or fluff. It is efficiently structured and appropriately sized for the tool's complexity.

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

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

Given the simple schema (one param, no output schema) and no annotations, the description is fairly complete for a status query. It describes the main function and a crucial behavioral nuance. However, it lacks clarity on the output format (e.g., units, currency) and does not contrast with sibling tools, leaving the agent without enough context to differentiate when this tool is preferred 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?

The schema has one parameter (mandateId) with 0% description coverage, so the description must compensate. It adds context by referring to 'a signed mandate,' indicating the ID refers to a signed mandate. However, it does not explain what a mandate ID looks like, how to obtain it, or any constraints. For a single simple parameter, this is adequate but not comprehensive.

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

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

The description clearly identifies the tool's purpose: 'Remaining and consumed budget for a signed mandate.' It uses a specific resource (mandate budget) and distinguishes from siblings like robyn_mandate_check or robyn_spend_statement by focusing on budget status. The caveat about on-chain verification adds precision and clarifies the tool's scope.

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 when to use this tool (when you need accurate, verified budget consumption) via the on-chain verification statement, but it does not explicitly state when not to use it or mention alternative tools. With many siblings, explicit guidance would be beneficial, but the context is enough to infer the primary use case.

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

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

Without annotations, the description carries the full burden. It clearly states what the tool lists and that it requires no credentials, implying a safe, read-only operation. It does not disclose rate limits or output format, but for a simple list tool this is adequate.

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

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

Two short sentences convey the full purpose and a key usage detail. No filler or repetition. The critical information is front-loaded.

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

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

Given the tool has no parameters and no output schema, the description sufficiently covers its function. It would benefit from briefly noting the return format (e.g., JSON array), but this is a minor gap.

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

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

The tool has zero parameters, so the description cannot add parameter-level detail. The lack of parameters is correctly reflected in the schema, and the description confirms no credentials are 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 explicitly states the tool lists specific resources: Robyn gasless chains, cross-chain route graph (22 EVM nodes + Stellar), and relayer/Permit2 addresses. This clearly differentiates it from sibling tools like robyn_cross_chain or robyn_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?

The description includes the important usage note that no credentials are needed. However, it does not specify when to use this tool versus alternatives like robyn_cross_chain, nor does it mention any prerequisites or limitations.

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 and does so impressively. It explicitly states 'Read-only', lists the expected proof fields, and discloses the conditional 'when enabled' for the on-chain transaction. It could mention error behavior but covers the essential operational traits well.

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 yet information-dense, pack intent, content, verifiability, and safety into a few lines. No filler or redundancy.

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

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

For a single-parameter tool with no output schema, the description covers the proof contents, the verification method, the conditional transaction field, and the read-only nature. This fully compensates for missing structured metadata.

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 fully describes the single parameter as a '16-hex feed row id' (100% coverage), and the description's 'anchored row id' adds no new semantics. A baseline of 3 is correct since the schema handles the parameter documentation without needing additional 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 clearly identifies the tool as providing a Merkle inclusion proof for an anchored row id and specifies the proof components. It doesn't explicitly contrast with sibling proof/verification tools, so it's clear but lacks direct sibling differentiation.

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

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

It gives practical guidance to 'Verify locally with plus-sdk verifyAnchorProof()', which implies how to use the output, but it doesn't position this tool against alternatives or state when not to use it. Usage context is conveyed only through the proof purpose, so it's barely adequate.

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 burden. It discloses that the tool is read-only, that the result is identical for all readers, and that fetching leaks no information about the intended recipient. It also mentions privacy-preserving selection, which is valuable behavioral context.

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

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

The description is two sentences effectively, but the first is long and packed with detail. It is front-loaded with the core purpose, then adds privacy context and SDK usage. Slightly dense, but efficient with 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?

Given the zero-parameter tool and absence of output schema, the description provides sufficient context: it explains the data returned, the privacy model, and the SDK sealing usage. It could mention that the output is a list, but since no output schema exists, the description covers the essentials adequately.

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

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

The tool has zero parameters, and the description covers 100% of schema (which is empty). The description adds value beyond the schema by explaining the data structure and the sealing SDK call, but doesn't need to explain any parameters as none 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 clearly states the tool's purpose: it lists all published v2 mailboxes, including address, stealth meta-address, and KEM public key. It is differentiated from siblings like robyn_message_feed and robyn_message_mailbox_of by specifying it covers ALL mailboxes, not a single one.

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

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

The description implies the use case: fetching the directory to select a recipient locally without privacy leak. It does not explicitly distinguish from alternatives like robyn_message_mailbox_of, but the context is clear for a directory-lookup tool. No exclusions 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?

The description explicitly states "Read-only," indicating no side effects, which is a behavioral trait. However, it does not disclose other behavioral aspects such as potential errors, rate limits, or permissions. Given that no annotations are present, the description carries the burden, and it only partially fulfills it.

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 packs the essential information without superfluous words. It is well-structured and directly states the subject, making it exemplary in conciseness.

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

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

The description gives some detail about the returned data (expired count, cumulative, root of purged ids, signed) but omits the exact action (e.g., "retrieve") and broader usage context. Since there is no output schema, the description must explain the return, but it does so only partially, leaving ambiguity about what the tool actually performs.

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 is empty (no parameters), and the description does not need to explain any. Since schema coverage is trivially high (no parameters to describe), the baseline score of 3 is appropriate. The description adds no parameter-specific meaning because there are none.

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 deals with the last purge statement signed by the operator, which conveys the purpose of retrieving or providing a signed proof of erasure. However, it lacks an explicit action verb like "get" or "retrieve," making it slightly less direct than ideal.

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 versus alternatives. The description only defines what the tool returns without contextualizing it against sibling tools or offering scenarios for its use.

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 and excels: it discloses the feed is public and identical for all readers, that data is encrypted (ct) requiring local decryption with viewPriv/KEM, and explicitly states "Read-only" at the end. This is exactly the behavioral nuance an agent needs to understand why responses are opaque without local crypto.

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 cover return columns, the local scanning workflow, paging, and safety semantics — roughly 40 words, zero fluff, no repetition of trivia. Every clause earns its place and the safety note is deliberately reserved for the end as a closing tag.

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 2-parameter, no-annotation, no-output-schema read tool, this description is essentially complete: it explains what is returned, how to interpret and decrypt results, how to page, and the safety profile. There is no missing critical information an agent would need to invoke this correctly.

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

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

Schema coverage is 100% (limit 1–200 default 100; since as releaseAt cursor in ms), so the baseline is a 3. The description adds genuine value by prescribing the paging recipe ("Use since=<last releaseAt> to page"), converting the parameter schema into an actionable invocation pattern, which elevates it slightly above baseline.

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

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

Uses a specific verb ("Returns") with a precise resource (released rows from a public feed) and enumerates the exact columns, while the title adds the "public feed to scan with your viewing key" framing that distinguishes it from sibling message_* tools like send/mailbox_of/directory. The "identical for every reader" qualifier further differentiates this broadcast-feed tool from per-user mailbox 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?

Provides clear operational context for when to invoke: scan locally, checkStealthAddress with viewPriv, open with KEM secret, and page via since=<last releaseAt>. It does not explicitly name alternatives or give when-not-to-use guidance, but the usage pattern is concrete and unambiguous, meriting a 4 rather than 5.

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

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

The description explicitly states 'Read-only', clarifying no side effects. It also details server storage and privacy properties, making the tool's behavior fully transparent. No annotations are present, so the description carries the full burden, which it meets well.

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 somewhat verbose, with marketing-like phrases such as 'PRIVATE · SEALED · POST-QUANTUM MESSENGER' and repeated concepts. While it includes useful details, it could be more concise. The structure is logical but not tightly packed.

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

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

With no output schema, the description is the only source of return information. It lists the key returned items (mode, ciphertext sizes, release grid, cover-row rate, anonymity accounting) and explains the system, but does not specify data types or formats. It is fairly complete for a tool of this nature.

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 no parameters, and the schema coverage is 100% (empty). The description does not need to elaborate on parameters, and the baseline for high coverage is 3. No additional parameter semantics are required or provided.

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

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

The description clearly states the tool's purpose: to return status, suite, and parameters of the Sonar private messenger, including mode, ciphertext sizes, release grid, and anonymity accounting. It distinguishes itself from sibling message-related tools (publish, receive) by focusing on informational retrieval.

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 querying messenger configuration or status, but it does not explicitly state when to use it versus alternatives, nor provide concrete use cases. The 'info' suffix in the name helps, but the description lacks explicit guidance on when this tool is the appropriate choice.

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

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

The description discloses a privacy-relevant behavior: resolving a name reveals the intended recipient to the server. It also declares 'Read-only', which is transparent. No annotations are provided, so the description carries the burden, but it doesn't mention any side effects like caching or network implications. This is adequate but not rich.

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

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

The description is concise, two sentences, front-loaded with the main purpose. It includes an example and a key privacy note without redundancy. Every sentence earns its place.

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

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

For a simple read-only lookup with a single parameter, this is complete. It covers the privacy implication, explicitly says read-only, and mentions return fields ({address, metaAddress, kemPub}) which act as an implicit output schema. The description is sufficient for an agent to invoke correctly.

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

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

The single parameter addressOrName has 100% schema coverage, meaning the schema already explains that it accepts a 0x address or a label with domain variants. The description adds an example name and notes that the server must resolve it, but it doesn't add much beyond the schema. Baseline 3 is appropriate.

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

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

The description clearly states the tool resolves a Robyn name (e.g., sphynx.robynchain.eth) to its mailbox address. It uses specific verbs ('resolve', 'reveals') and mentions the return fields, distinguishing it from sibling tools like robyn_message_directory which takes an address.

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 notes when to use this tool (when you have a name) and explicitly prefers robyn_message_directory when you have an address, which gives clear usage guidance. It doesn't mention any when-not-to-use cases beyond that, 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 carries the full burden of disclosure. It warns that private keys must never be exposed ('this server must never see them'), states that the record is forwarded unchanged, and explains the monotonic ts semantics for rotation. It could have mentioned response/error behavior, but the key secrecy and forwarding behavior are disclosed.

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

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

Three sentences front-loaded with purpose: first sentence explains the binding action, second gives critical security/signing steps, third explains rotation. Every sentence earns its place; no filler or repetition. Ideal length for the complexity.

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

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

The tool involves cryptographic signing, 5 required parameters, and a publish action. The description covers the purpose, local key generation, signing prerequisite, and rotation behavior. It doesn't detail the return value (no output schema), but for a publish/record tool this is not a major gap. It is complete enough for an agent to use it correctly.

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

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

Schema coverage is 80% (4 of 5 params described), which is already strong. The description adds meaning by specifying that address, metaAddress, kemPub, and ts are all part of the signed message, and by explaining the metaAddress format. It also clarifies the role of address (the user's wallet) which the schema leaves blank, adding 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 opens with a specific verb+resource: 'Binds your address to a stealth meta-address + KEM public key so others can seal to you.' This clearly distinguishes it from sibling tools like robyn_message_send (sending messages) and robyn_message_mailbox_of (querying mailboxes), while matching the title's 'publish a PRE-SIGNED mailbox' concept.

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 on when to use the tool: to bind a stealth mailbox for receiving sealed messages. It also gives actionable steps (generate keys locally, sign mailboxMessage, publish) and discusses rotation via 're-publish with fresh keys to rotate.' However, it does not explicitly exclude alternatives or mention when not to use it, so it stops short of a 5.

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

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

With no annotations provided, the description fully discloses key behaviors: it cannot encrypt, it only accepts sealed triples, it is replay-idempotent (returns duplicate:true on resend), and messages appear in the public feed at releaseAt. It also warns about plaintext exposure, giving the agent crucial safety context.

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

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

The description is concise (three sentences), front-loaded with the primary purpose, and each sentence adds actionable value: what it does, what it cannot do, and behavioral notes. 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?

Given the small parameter count and simple operation, the description covers the workflow (seal then send), the alternative, the idempotency, and the public feed caveat. No output schema exists, but the tool's side effects are clearly described, making it complete for an agent to use correctly.

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

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

Schema coverage is 100% (all three parameters have descriptions referencing seal() output), so the baseline is 3. The description adds extra context by explicitly tying the parameters to the seal() function and explaining the 'sealed triple' concept, reinforcing the meaning 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 relays an already-sealed message (contains the sealed triple: ephemeralPubKey, viewTag, ct) and explicitly distinguishes it from v1 (plaintext). It also names the SDK and its seal() function, making the purpose specific and distinguishing from siblings like message_publish_mailbox.

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 states when to use this tool: for sealed messages from the SDK, and provides an alternative (v1) when the SDK cannot be run, along with the caveat that v1 is plaintext. It also clarifies when not to use it (sending plaintext here) and notes replay-idempotent behavior.

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 burden. It discloses that the tool is read-only and explains the edge case for addresses that never enrolled (reported as not custodied). It does not detail error behavior or output format, but for a simple query this is reasonably 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 two sentences, front-loads key information, and includes the critical MUST-use note about nextNonce. Every sentence earns its place with 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?

Given the tool has one parameter and no output schema, the description adequately covers the main output concepts (enrolment, balance, history, nextNonce) and an important edge case. It could be more explicit about the return format, but it is sufficient for selecting and invoking the tool correctly.

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

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

The input schema has full coverage (100%) for the single 'address' parameter, with a description 'EVM address (0x…)'. The tool description does not add extra parameter-level semantics beyond reusing the term 'address', so the baseline of 3 applies.

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

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

The description clearly states that the tool reports enrolment state, internal balance, recent history, and nextNonce for an address. It is specific about the resource (netting account) and the operation (query/report), though it lacks an explicit verb and does not directly distinguish itself from sibling tools like robyn_netting_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?

The description gives clear context: the tool is for checking whether an address is enrolled and for obtaining the nextNonce that MUST be used when signing transfers or withdrawals. It does not explicitly state when not to use it or name alternatives, but the usage context is strong.

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 responsibility for behavioral disclosure. It reveals that the tool does not actually enroll anyone, does not hold keys, and that the resulting balance is custodial, uninsured, and 'could be lost.' This goes far beyond the name/schema and is essential context for the 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 compact yet information-dense, starting with the primary purpose and then adding essential workflow and risk warnings without redundancy. Every sentence earns its place, and the structure front-loads the most important 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?

For a one-parameter tool with no output schema, the description is self-sufficient: it explains what the tool returns, how to use it, and the critical custodial risks. It also provides the follow-up endpoint, making the entire flow clear.

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

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

The schema description already fully documents the single parameter 'address' as 'the address that will own the netting account.' The description adds no additional parameter-specific semantics beyond what the schema provides, so baseline 3 applies.

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

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

The description clearly states the tool 'Returns the EXACT message the account must sign with its OWN key to open a custodial balance.' It distinguishes itself from sibling tools by explicitly noting it 'holds no key and enrols nobody,' making it unambiguous that this is a payload-generation tool rather than an enrollment action.

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 a complete usage workflow: get the text, user signs it, then POST {address, signature} to /api/netting/enroll. It also gives critical guidance on when to use this tool (before enrolling) and contrasts it with other tools by highlighting that 'every other tool here moves funds without Robyn ever holding them.'

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

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

With no annotations, the description fully discloses behavioral traits: read-only, custodial (holds balance), and specific return values. The custodial warning is critical and clearly stated, providing complete transparency for a zero-annotation 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?

Four sentences packed with essential information: first explains the netting mechanism, then custodial risk, then read-only behavior and outputs. Every sentence earns its place with no redundancy.

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

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

The description thoroughly covers the concept, security implications, and return values, making it self-sufficient for an informational tool. It gives enough context for an agent to know when to call and what to expect.

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?

Input schema has zero parameters, so the description adds no parameter-specific meaning. Baseline for 0-param tools is 4, and the description does not need to elaborate on parameters.

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

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

Description clearly states the tool's purpose with verbs 'Explains' and 'Returns,' identifying it as an informational resource about the netting ledger. It distinguishes itself from sibling action tools by focusing on explanation of caps, limits, and fee model.

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

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

Provides clear usage context by instructing to 'Tell the user that plainly before they enrol,' indicating use before enrollment. It contrasts with other tools that move funds, implying this is for education rather than execution, though it lacks explicit alternative names.

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 that the tool is free and read-only, explains the significant cost differences (over 1000x), and clarifies that internal transfers are unaffected. This goes beyond basic safety and gives useful behavioral context, though it does not describe the exact output format or error handling.

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 (~80 words), front-loaded with 'Free and read-only,' and every sentence serves a purpose: explaining the ranking, cost disparity, single-chain option, and internal transfer exception. It is well-structured and avoids 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?

For a simple two-parameter preview tool, the description adequately covers purpose, behavior, and edge cases (internal transfers). It mentions that toChain can indicate success, and the ranking implies a return list. It does not specify the exact response structure, but no output schema exists and the tool is straightforward, so this is acceptable.

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

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

Schema description coverage is 100%, so the schema already documents both parameters. The description adds some contextual framing (e.g., amount is for the withdrawal, toChain limits to a single chain) but does not provide substantive new meaning beyond what the schema already states. Hence the baseline score of 3 is appropriate.

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

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

The description clearly states the tool's function: given an amount, it ranks every exit chain by what actually arrives after destination payout costs. This is a specific verb+resource+scope combination that distinguishes it from sibling tools like robyn_netting_transfer_payload or robyn_cross_chain, which handle actual movements rather than previews.

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

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

It provides clear context: use to preview netting withdrawals, and pass toChain to price a single chain. It also gives an explicit when-not-to-use: internal transfers between netting accounts are free and not subject to these costs. However, it does not explicitly name alternative tools for those cases, so it falls short of a 5.

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

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

No annotations are provided, so the description carries the full burden. It explicitly states 'Read-only' and describes the safety mechanism of refusing deposits that would push liabilities above a safe share. It also notes that solvency is checkable, adding behavioral insight beyond the bare function.

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 three sentences, each with a distinct value: what it publishes, the solvency guarantee, and the read-only usage scenario. Every sentence earns its place with 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?

For a zero-parameter tool, it covers the key aspects: purpose, scope, read-only safety, and a concrete user scenario. It does not detail the exact return format, but the description gives enough context for expected data (liabilities vs float per chain), making it reasonably complete.

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

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

With zero parameters, schema coverage is trivially 100%. The description adds scope context ('all netting accounts', 'per chain') that enriches the empty schema. The baseline of 4 for no parameters is appropriate and the added context justifies it.

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

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

The description uses the specific verb 'publishes' and clearly identifies the resource: what Robyn owes against the real relayer float per chain. It distinguishes itself from sibling netting tools by focusing on solvency/proof rather than account info or transfers.

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 a clear usage context: 'a user considering a custodial balance should be shown this.' It also emphasizes read-only nature, implying it's for verification rather than action. No explicit alternatives are named, but the context gives sufficient guidance.

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

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

With no annotations provided, the description carries the full burden and does so excellently. It discloses that internal transfers have no transaction hash, that the journal is append-only and never truncated, and that paging uses a `before` sequence number. These are critical behavioral traits beyond what the schema reveals.

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 three dense sentences, front-loaded with the most important fact (no transaction hash), and every sentence earns its place. It efficiently covers purpose, behavioral traits, and usage context without 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 simplicity (a history list), lack of output schema, and absence of annotations, the description provides all necessary context for an agent to select and invoke it correctly. It covers the 'why' (verify/dispute internal payments), the 'what' (full untruncated history), and the 'how' (paging with `before`).

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

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

Schema coverage is 100%, so baseline is 3. The description adds meaningful semantics for the `before` parameter by explaining it is a seq number for paging and emphasizing that the tool never truncates results, which enriches the schema's bare 'return entries with seq below this'.

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 tool provides the full, untruncated netting history for an address, and explains that it records internal transfers with no transaction hash. This clearly distinguishes it from sibling netting tools by emphasizing it is the only record for such transfers.

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

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

The description gives a clear when-to-use directive: 'Use this when a user asks to verify or dispute an internal payment, since there is no chain to check.' It also provides paging guidance with `before`, making the invocation context explicit.

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

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

With no annotations, the description bears full responsibility for disclosing behavior. It notably states 'Signs nothing and moves nothing' and emphasizes that Robyn will not hold a balance for a recipient who never consented, which are critical behavioral traits. It does not mention possible errors when nonce retrieval fails or when accounts are not enrolled, but the explicit safety and consent constraints are well covered, justifying a strong score.

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 yet information-dense: three sentences cover the exact return value, the workflow (sign and POST), the enrollment prerequisite, and an alternative for unenrolled recipients. There is zero fluff, and the most critical detail (what it returns) is front-loaded. Every sentence earns its place.

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

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

Given the tool's complexity (simple payload builder with 3 parameters, no output schema) and the rich sibling context, the description is remarkably complete. It explains the return value, the subsequent action required, the enrollment condition, and the alternative route. It effectively differentiates from robyn_netting_enroll_payload and other robyn_* tools without needing to enumerate all siblings.

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

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

Schema description coverage is 100%, so the schema already documents the parameters. The tool description adds meaningful context beyond this: it clarifies that the 'to' and 'from' must be enrolled accounts, and reveals that the nonce is automatically handled ('with the correct next nonce') and that the final POST includes a 'signature' field, none of which are in the input schema. This enriches the agent's understanding of how the parameters relate in the workflow.

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 with a specific verb and resource: 'Returns the exact string to sign, with the correct next nonce, for a free instant transfer between two ENROLLED accounts.' It distinguishes itself from siblings by explicitly noting it 'Signs nothing and moves nothing' and by referencing the exact endpoint and POST payload. This makes it unambiguous which action the tool performs.

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

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

The description provides explicit usage context and alternatives: it explains that the sender must sign the returned message and POST it to /api/netting/transfer, and it clearly states the prerequisite that both parties must already be enrolled. It also gives a direct alternative: 'to pay an unenrolled address use the ordinary non-custodial route instead.' This goes beyond merely implying when to use the 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 provided, the description carries the burden of disclosing behavior. It clearly states that Robyn does not sign, holds no payee keys, and returns a digest for the payee to sign, which is a critical counterintuitive behavior. It also explains the rationale. However, it does not mention whether the request is stored, expiration handling, or error scenarios, so it's not fully exhaustive.

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

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

The description is two sentences, front-loaded with the action ('Build a canonical payment request') and immediately states the key output and signing requirement. It includes a useful rationale without any fluff. Every sentence earns its place.

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

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

Given no output schema and no annotations, the description does well to explain the process, the signer, and the return value (digest). It also situates the tool within the payment request workflow. However, it could be more complete by mentioning what happens after signing or how the digest is used, though that is likely covered by sibling tools.

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 50%, meaning memo, token, and expiresInSec lack schema descriptions. The tool description lists all parameters (payee, chain, token, amount, memo, expiry) but adds little beyond their names. It doesn't clarify formats, defaults, or relationships (e.g., what 'expiry' maps to, token representation). This is adequate but not compensatory for the undocumented fields.

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

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

The description clearly states the tool builds a canonical payment request and returns a digest for the payee to sign. It distinguishes itself from siblings like robyn_payment_request_settlement and robyn_payment_request_verify by focusing on the prepare step, and explicitly clarifies that Robyn does not sign these requests.

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

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

The description provides explicit when-to-use guidance: 'Use this when an agent needs to ASK another agent for money in a way the payer can actually check.' It also implicitly explains when not to use it (when Robyn should sign) by stating Robyn doesn't sign and holds no payee keys, effectively differentiating from signing/verification 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 provided, the description fully carries the behavioral burden. It discloses the verification logic, the meaning of paid=true (verified on-chain result) and paid=null (undetermined, not evidence), which is crucial for correct interpretation.

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

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

The description is two sentences, front-loaded with 'After paying, prove it', and every sentence adds necessary behavioral insight. No redundant or filler content.

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

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

The description adequately covers the core purpose and primary return semantics (paid=true/null), but with no output schema it does not fully explain the complete response shape or the role of request/signature parameters. It is usable but has gaps for a 3-parameter tool with nested objects.

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 only 33% (only transferId has a description). The description adds no explicit meaning for the 'request' object or 'signature' string, and only indirectly relates to the transfer via the transferId. It does not compensate for the schema gaps.

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

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

The description clearly states a specific verb and resource: 'prove it' by re-checking the transfer against the DESTINATION CHAIN and confirming the payee was paid. It differentiates from siblings by emphasizing on-chain verification and the payee amount requirement.

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

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

Provides clear context: 'After paying, prove it' indicates when the tool should be used. However, it does not explicitly mention alternatives or when not to use it, which would fully distinguish it from sibling tools like robyn_payment_request_verify.

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 the tool's security checks, the meaning of a valid signature, and the critical risk of altered payee addresses. It also clarifies what a signature does NOT prove, which is valuable behavioral context.

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

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

The description is compact yet information-dense, front-loaded with the imperative 'ALWAYS run this before paying'. Every sentence adds value, covering purpose, use, and critical warnings 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?

The description thoroughly explains the tool's role and the key decision outcome (signedByPayee false → do not pay). However, since there is no output schema, it does not explicitly describe the return format or error behavior. While not fully complete in this respect, the essential behavioral outcomes are covered.

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 meaning by explaining that the signature parameter proves authenticity and that the request is checked for specific fields (payee, chain, token, amount, expiration). This enriches the reader's understanding of how the parameters are used.

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 'verify' and the resource 'payment request', and specifies exactly what it confirms (payee address, chain, token, amount, signature, expiration). It differentiates from siblings by mandating this step before paying and explicitly distinguishing between authenticity and whether payment is owed.

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 ('ALWAYS run this before paying a request you received') and a strong when-not-to-pay condition ('If signedByPayee is false, DO NOT PAY'). It also warns about address substitution, providing actionable safety guidance.

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

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

With no annotations provided, the description fully discloses important behavioral traits: it is READ-ONLY, stops at the first unroutable step, reports cumulative fees/durations, and returns binding-constraint feedback. This goes well beyond a minimal safety annotation.

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

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

The description is front-loaded with the primary purpose, then covers termination behavior, output feedback, read-only safety, and usage guidance—all in five targeted sentences. No sentence is redundant or filler.

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

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

Given the tool's complexity, nested parameters, and lack of an output schema, the description covers the essential behavior, safety, and response structure. It does not enumerate all constraint fields or explicitly compare with sibling tools, but it is still strongly 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 provides basic descriptions for 'steps' but not 'constraints'. The description adds meaning by explaining that fees and durations accumulate across steps and that error responses include 'bindingConstraint' and 'whatWouldMakeThisWork', which helps the agent understand constraint evaluation and output 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 validates an entire multi-step workflow up front, using a specific verb ('Validate') and resource ('a WHOLE multi-step workflow'). This directly distinguishes it from per-hop validation tools like robyn_preflight or robyn_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?

The description explicitly says to 'Use this before spending on step one' and positions it as an alternative to validating 'one hop at a time.' It provides clear contextual guidance, though it does not explicitly name sibling tools 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?

With zero annotations, the description carries full burden and discloses meaningful behavior: the tool never sees an unblinded pass (privacy guarantee), payment verification steps, each blinded token is signed blind, and unblinding happens locally via the SDK. This is strong disclosure for an unannotated 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?

The description is compact — two sentences plus a short privacy note — and front-loads the core action and inputs. Minor redundancy exists ('plus-sdk claim() does all of this' restates the local unblinding point), but no wasted sentences overall.

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?

Despite no output schema and no annotations, the description covers inputs, prerequisites (payment verified, one tx per invoice), flow (blind signing, local unblinding), and a key privacy property. Missing detail like the exact return format is understandable given the blind-signing protocol, making this reasonably complete.

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

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

Schema coverage is only 33% (txHash described). The description compensates partially by explaining the blinded array's source and format ('base64, from plus-sdk blindTokens()') and implying txHash is the EVM payment tx. However, invoiceId is never semantically explained beyond its required status, leaving a notable gap.

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

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

The description states a specific action ('Submit BLINDED tokens... with the payment txHash') targeting a clear resource (blind signature claim after payment). It distinguishes from sibling tools like robyn_plus_info, robyn_plus_invoice, and robyn_plus_invoice_status by scoping precisely to the claim phase (after payment, signed blind).

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

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

Provides clear usage context: tokens come from plus-sdk blindTokens(), payment is verified on-chain (recipient, amount, confirmation; one tx per invoice), and txHash is omitted for BTC (from schema). It does not explicitly name alternatives to exclude, but the phase-specific context ('after paying') gives adequate position among siblings.

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 states 'Read-only,' describes the privacy property that 'the server cannot link to any payment,' and promises 'honest what-we-learn / what-we-do-not.' This is solid coverage for a zero-parameter info tool, though it omits details like authentication requirements or data freshness.

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 four sentences and information-dense, front-loading the core definition of Plus before covering payment, redemption, and return values. It is efficient overall, though the phrase 'honest what-we-learn / what-we-do-not' is slightly vague and could be tightened.

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, so the description must explain return values. It lists products, assets, and the mint public key, but the title promises 'prices' and the description only mentions payment methods, not an explicit price return. The 'honest what-we-learn / what-we-do-not' clause is also underspecified, leaving some ambiguity about the actual response shape.

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

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

The tool has zero parameters and an empty schema, so there is no parameter burden for the description to carry. The description instead adds value by explaining what the tool returns, which is the appropriate focus for a no-input info endpoint.

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 defines the tool as an info endpoint for Plus: it 'Returns products, assets, the mint public key (JWK)' and explicitly states 'Read-only.' It also distinguishes itself from sibling tools by clarifying what Plus is not ('never a "more private lane"') and by listing the specific product categories.

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

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

The description gives clear context for when to use this tool: to learn about Plus offerings, payment methods, and redemption mechanics. It does not explicitly name alternatives or exclusion criteria, but the context strongly implies this is the informational precursor to tools like robyn_plus_claim or robyn_plus_invoice.

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 burden. It discloses that the tool is a creation operation (mutation), returns specific fields, and has a payment flow requiring follow-up actions. It could be more explicit about side effects (e.g., does it create an on-chain invoice? any cost?), but it gives enough behavioral context for an agent to proceed.

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, two sentences, with the first sentence front-loading the core purpose and return format. The second sentence adds essential usage detail. 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?

Given the tool's moderate complexity (2 params, no output schema, no annotations), the description is fairly complete: it states the output shape, the acceptance of any wallet, the follow-up claim call, and the special BTC requirement. It lacks details like timeout, payment confirmation expectations, or error scenarios, but these are not critical for basic invocation.

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

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

Schema coverage is 50%, meaning only 'refundAddress' has a description ('btc only'), while 'asset' only has an enum. The description clarifies that 'asset' selects the asset for the invoice and that 'refundAddress' is for BTC, adding meaning beyond the enum. However, it does not explain the format of refundAddress (e.g., bech32 vs legacy) or the precise meaning of each supported asset (e.g., chain specifics), but it compensates for the gap.

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 creates an invoice for a specific bundle (500 passes, $3 quoted) in the chosen asset, and it is distinct from siblings like robyn_plus_claim and robyn_plus_invoice_status. The verb 'creates' with the resource 'invoice' and scope 'for one bundle' makes the purpose explicit.

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

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

The description explicitly says to use this tool to create an invoice, then pay from any wallet, blind tokens locally, and call robyn_plus_claim, which provides a clear workflow. It also includes critical guidance for btc refundAddress, telling the agent to provide a BTC address and mentioning the Chainflip deposit address, which is essential for correct 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?

The description does disclose the read-only nature, which is a useful behavioral trait. However, with no annotations provided, the description carries the full burden. It does not mention error handling, authentication requirements, rate limits, or what happens if the invoice ID is invalid. For a simple getter, this is minimal 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 extremely concise and front-loaded. It communicates the primary function and the read-only guarantee in two short sentences without any extraneous words. This is appropriate for a simple status retrieval tool.

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

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

The tool has a single parameter and no output schema, so the description must provide enough context about the return and edge cases. While it mentions the kinds of data returned (status, passes, payment details), it does not describe the response format, error conditions, or any prerequisites. This is insufficient for an agent to know what to expect.

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 coverage is 0%, meaning the description does not explain the invoiceId parameter at all. The description omits any mention of the parameter or its purpose. Since there is only one parameter and the description provides zero explanation, it fails to compensate for the lack of schema documentation.

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 retrieves 'status, remaining passes and payment details for an invoice' and explicitly labels it 'Read-only'. This is specific about the resource and the type of data returned. However, it lacks an explicit verb (e.g., 'get', 'retrieve') and does not directly distinguish it from sibling tools like robyn_plus_invoice or robyn_plus_claim, which might also relate to invoices.

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 instead of alternatives. There is no mention of context, exclusions, or related tools. For example, it doesn't explain how this differs from robyn_plus_invoice or robyn_plus_claim. The description is purely declarative without any usage direction.

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 of behavioral disclosure. It explicitly states that the tool never sees an unblinded pass, highlighting a privacy guarantee. It also describes the token blinding requirement and the output (blind signatures). While it does not mention error handling or side effects beyond the daily limit, it provides essential behavioral context (e.g., process steps, privacy) that an agent needs.

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 three sentences long, each serving a purpose: stating the action and outcome, specifying the daily limit, and explaining the unblinding process and privacy feature. It is front-loaded with the core function and contains no redundant or filler text, making it highly concise.

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

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

The tool is simple (one parameter, no output schema) and the description covers input format, constraints (daily limit), process (blinding, signing, unblinding), and a privacy guarantee. However, it omits potential error scenarios (e.g., exceeding daily limit, invalid token format) and the exact return structure (though signatures are implied). Given the low complexity and helpful detail, it is 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 provides no description for the single 'blinded' parameter (0% coverage), so the description must compensate. It does so effectively by specifying the parameter is an array of up to 20 base64-encoded blinded tokens from the plus-sdk 'blindTokens()' function. This gives the agent precise format and source information beyond the schema's basic type and 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 tool's function: submit up to 20 blinded tokens to receive blind signatures for trial passes. It specifies the exact resource (blinded tokens) and action (submit/receive signatures), and distinguishes itself from siblings like robyn_plus_claim by emphasizing the trial nature and the blinding process. The phrasing 'identical unlinkable passes to paid ones' further clarifies its purpose.

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

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

The description provides clear context for when to use this tool: for trying Plus before paying, with a constraint of 'one trial per day per caller.' It also mentions the SDK method for unblinding, which implies the workflow. However, it does not explicitly state when not to use this tool or compare it to alternatives like robyn_plus_claim, lacking 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?

With no annotations provided, the description carries full responsibility for behavioral disclosure. It explicitly states 'Read-only — signs nothing, moves nothing,' clearly setting safety expectations. It also lists the exact failure modes it detects (fee consumption, address family, settle capability, lane capacity), providing a detailed behavioral model beyond what annotations would offer.

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 three sentences, starts with actionable direction, then explains the return type and key failure modes, and ends with a critical safety trait. Every sentence earns its place with no redundancy or filler.

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

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

Despite lacking an output schema and annotations, the description is complete: it covers purpose, workflow position, output shape (GO/NO_GO with blockers and warnings), specific failure modes, and safety behavior. This is sufficient for an agent to invoke the tool correctly across its seven parameters.

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 86%, so the schema already documents most parameter meanings. The description adds a usage note about fromAddress for 'free micro-transfers,' but this overlaps with the schema's existing 'membership and fee tier' description. Overall, the description adds only marginal parameter-level 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 identifies the tool as a preflight check that returns GO/NO_GO with blockers and warnings, and explicitly names robyn_prepare/robyn_submit to distinguish its role in the workflow. It enumerates specific failure modes it catches, making the purpose unambiguous and well-differentiated from siblings.

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

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

The opening sentence 'Run this before robyn_prepare/robyn_submit' gives explicit sequencing guidance. The description further explains the value (catches costly failures for free) and offers a parameter-specific tip about fromAddress for membership recognition, which helps the agent decide when and how to use it.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It thoroughly explains the semantics of blockers, warnings, unavailable, and proceed, including that proceed is not a guarantee. This goes far beyond what annotations typically provide and gives the agent critical context for decision-making.

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

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

The description is front-loaded with the core purpose in the first sentence, followed by usage guidance, then detailed output semantics. Each sentence earns its place, and the structure logically progresses from what → when → how to interpret. It is appropriately sized for the tool's complexity, not overly 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?

With no output schema and no annotations, the description must fully explain the tool's behavior and return semantics. It does so thoroughly, covering all important output markers and caveats. It also justifies when to use this tool over siblings, making it complete for the agent to safely invoke it.

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

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

The schema has 7 parameters with only 14% description coverage, and the tool description does not explain most of them. It only indirectly references mandateId via 'mandate budget'. There is no explanation of fromChain, toChain, amount, toToken, fromToken, or toAddress. The description fails to compensate for the low schema coverage, leaving the agent to infer meaning from types and tool name.

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: a single combined check covering serviceability, routing competitiveness, cheaper alternatives, delivery basis, and mandate budget. It explicitly positions it as a go/no-go pre-execution check, distinguishing it from the multiple separate checks it replaces. The phrase 'ONE call' and the list of integrated concerns leave no ambiguity about what the tool does.

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

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

It explicitly says to call this before executing rather than making five separate checks, providing clear when-to-use guidance. It also explains how to interpret the output (blockers vs warnings, unavailable, proceed), and implies that other tools may be used for individual checks. This is strong usage guidance with actionable direction.

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 the tool is non-destructive and does not require keys, but lacks details on rate limits, auth requirements, or error handling. The return statuses are partially explained.

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, no wasted words. The core purpose is front-loaded, followed by behavioral note and return info. Efficient and clear.

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 7 parameters, no required, and no output schema, the description gives a high-level view but lacks detail on parameter interactions or full return structure. It is moderately complete for a first glance but insufficient for complex 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?

Schema coverage is 57% (4 of 7 params described). The description adds context that input can be plain language or structured, aligning with the 'intent' param, but does not elaborate on other params like toChain or fromChain. Baseline 3 is appropriate given moderate coverage.

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

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

The description clearly states the tool converts an intent into a concrete plan and the exact payload to sign. It mentions return statuses ('sign' or 'quoted'), distinguishing it from sibling tools like robyn_quote or robyn_submit.

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 safe usage with 'Costs nothing, moves nothing, needs no key' but does not explicitly state when to use this tool versus siblings like robyn_quote for quotes or robyn_submit for submission. No direct alternatives or exclusions 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?

Without annotations, the description carries the burden. It clearly identifies this as a read operation ('ONE read'), clarifies it reads live flags rather than static docs, and lists exactly what information it returns. It does not cover auth requirements or rate limits, but this is sufficient for a read-only posture check.

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?

Dense but efficient, every clause adds specific value (privacy items, feature modes, quota path). It's a single sentence but well-structured and front-loaded.

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

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

For a tool with no output schema, the description thoroughly enumerates the return contents: private items, public items, live modes, and quota guidance. Combined with usage guidance, this 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 schema already documents chainId with 100% coverage, so the description adds little beyond noting the chain context. 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 this is a read tool that reports privacy posture for a chain and lane, with specific details about private vs public data, live feature modes, and quota improvement. It distinguishes itself from siblings by its specific focus on privacy.

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 'Call it first when planning,' giving clear timing guidance. It also contrasts with a 'brochure' by noting it reads live flags, but does not name alternative tools for comparison.

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

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

No annotations are provided, so the description carries the full burden. It discloses the read-only nature ('moves nothing') and reveals a critical behavioral nuance: the quoteOnly field indicates whether the route is executable, with detailed instructions on how to interpret and present it. This is exemplary transparency beyond typical tool descriptions.

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 five sentences, front-loaded with the primary purpose, then the essential behavioral caveat. It uses bold and uppercase for the critical part, making it scannable. No unnecessary words or repetition.

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

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

For a quote tool with no output schema, the description covers everything needed: return fields, read-only behavior, the quoteOnly exception, its reason, and the default executable status. This fully equips the agent to correctly interpret and present the tool's response in all 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?

The input schema already provides complete descriptions for all 7 parameters (100% coverage), so the baseline is 3. The description adds no additional parameter-level meaning beyond the schema, which is acceptable given the schema's thoroughness.

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: 'Best gasless route to move a token from one Robyn chain to another' and lists the returned fields (estimated output, bridge, duration, Robyn fee). It explicitly says 'Read-only — moves nothing,' distinguishing it from execution tools like robyn_cross_chain or robyn_submit.

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 strong contextual guidance: it says to use the tool for quoting and explicitly warns about quoteOnly=true cases, instructing the agent to present such quotes as price comparison only and not as sendable. It references that 'execute will refuse it' but does not name the specific alternative tools (e.g., robyn_cross_chain) explicitly, so it falls just short of a 5.

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

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

With no annotations, the description carries the behavioral burden and does well: it discloses content-hash idempotency, relayer-signature validation, and that the counterparty never contacts Robyn. It could add more about failure modes or return behavior, but it provides substantial behavior 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 concise and front-loaded with the core action. Each sentence adds useful information about provenance, idempotency, and signature constraints, though the first sentence is somewhat dense with the parenthetical proof explanation.

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 3-parameter tool with no output schema or annotations, the description provides enough context about purpose, prerequisites, validation, and retry behavior. It does not explicitly state the return value, but the surrounding context and idempotency note make the tool sufficiently complete for correct invocation.

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

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

The schema already documents all parameters with 100% coverage, establishing a baseline of 3. The description adds meaningful semantics by clarifying that the 'receipt' comes from robyn_settle or a completed route, is relayer-signed, and must be accepted by this relayer, elevating the score.

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

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

The description clearly states a specific action: delivering a relayer-signed settlement receipt to the counterparty's sealed messaging-v2 mailbox. It distinguishes this from related tools like robyn_settle and robyn_receipt_verify by emphasizing delivery to the counterparty and the acceptance of only relayer-signed receipts.

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

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

The description gives clear contextual guidance by tying usage to 'robyn_settle / a completed route' and notes that the receipt provides proof without contacting Robyn. It stops short of explicitly naming alternative tools or stating when not to use this tool, so it slightly misses the top bar for usage guidance.

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

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

The description declares the tool is read-only, which is valuable behavioral disclosure given no annotations. However, it does not describe the outcome of verification (success/failure returns, errors, or response structure), leaving a significant gap for a verification 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, front-loaded with the action and key checks, ending with 'Read-only'. Every word earns its place with no filler.

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

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

Despite the tool's complexity (one opaque parameter, no output schema, no annotations), the description provides only a minimal summary. It omits return behavior, failure modes, prerequisites, and parameter structure, leaving the agent underinformed for correct invocation.

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

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

The single 'receipt' parameter has an empty schema with 0% description coverage, so the description must compensate. It only mentions the receipt is 'received (e.g. opened from your v2 mailbox)', providing a source hint but no structural details, format, or required fields, which is insufficient for safe usage.

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 verifies a settlement receipt by checking digest, relayer signature, and signed terms, and explicitly notes it is read-only. This distinguishes it from sibling verification tools like robyn_payment_request_verify or robyn_refusal_verify, which target different objects.

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

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

It gives a concrete use case ('opened from your v2 mailbox') that implies when to use it, but does not explicitly name alternatives or state when not to use. This is useful context, though a note distinguishing it from other verification tools would strengthen it.

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

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

With no annotations, the description carries the full transparency burden. It does describe the content and structure of steps ('what it answers, what to do with the answer, whether it is optional, what skipping it costs'), which is helpful. But it does not disclose whether the tool is read-only, what it returns overall, or any failure/edge-case behavior, leaving notable gaps.

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

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

The description is compact and front-loaded with the list of playbooks, then the key usage instruction, then output structure details. Every sentence adds value, though the all-caps 'CALL THIS BEFORE...' is slightly noisy and the sentence about step details could be trimmed without losing meaning.

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

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

Given the tool's simple interface (one optional parameter, no output schema), the description provides sufficient context: what the playbooks are, when to invoke, and what each step tells the user. It doesn't over-explain return values, and the mention of 'skippingCosts' hints at output richness. A concrete example or a note about the return container would make it fully complete, but it's strong for the complexity level.

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 documents the single 'name' parameter well ('a specific recipe, or omit for all'), giving 100% coverage. The description does not add any additional parameter-level meaning, so the baseline 3 is appropriate.

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

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

The description clearly identifies the tool as providing ordered playbooks for specific real-world goals (pay-someone-safely, prove-what-i-spent, etc.), which goes well beyond the vague title. It distinguishes itself from sibling execution tools by framing itself as a sequencing guide ('CALL THIS BEFORE IMPROVISING A SEQUENCE'), though it doesn't explicitly contrast with any named alternative.

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

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

The description gives explicit guidance on when to use it: before improvising a sequence. It also scopes the tool to particular goal areas, implying it should not be used for arbitrary ordering tasks. However, it lacks explicit exclusions or named alternatives, so it stops short of a full 5.

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

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

With no annotations, the description carries the full transparency burden. It discloses a required header ('x-anygas-receipt: 1'), the conditional trigger (IF Robyn refuses), and a critical limitation: 'It proves the refusal HAPPENED; it does not claim the refusal was correct.' This is meaningful behavioral context, though it omits return format and authentication requirements.

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

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

The description is front-loaded with the core action and remains focused. The extended rationale about blame and proving external blockage is helpful but slightly verbose; still, each sentence contributes to understanding the tool's value and proper use.

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

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

The tool has a single parameter, no output schema, and no annotations, so the description must cover the full context. It explains the setup, when it applies, and a key semantic limit, but it does not describe the verification result format, failure behavior, or how to interpret the outcome, leaving notable gaps for a no-output-schema 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 covers 100% of the single required parameter 'receipt,' described as 'the full refusalReceipt object as returned.' The description adds context about the receipt's contents (what was asked, when, and why) and its purpose, but the schema already provides the essential semantics, so the value added is marginal.

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 'Check a signed refusal receipt,' which clearly identifies the tool's primary action and target resource. It distinguishes this tool from siblings by focusing specifically on refusal receipts and explaining their evidentiary role, making its purpose unmistakable.

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 when this tool is relevant: when Robyn refuses a request and the provider denies, and it emphasizes that the receipt proves external blockage versus agent failure. It provides clear context for use, though it does not explicitly name alternative tools or state 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.

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

With no annotations, the description provides transparency about state transition (BRIDGING → DONE) and output (destination tx when delivered). It does not mention error conditions or rate limits, but for a status check this is reasonable.

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. It front-loads the purpose and provides key details efficiently.

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

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

Given the low complexity (1 param, no output schema), the description covers input, behavior, and output hint. It lacks explicit return structure but is sufficient for the tool's simplicity.

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

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

The single 'id' parameter has 0% schema coverage. The description adds meaning by stating 'by id' and implying it identifies a route, but does not specify format or example. This partially compensates for the schema gap.

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 returns status of an in-flight route by ID, with state transition (BRIDGING → DONE) and delivery of destination tx. It distinguishes from sibling tools like robyn_cross_chain (initiation) and robyn_quote (quoting).

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

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

The description explicitly says to use for status of an in-flight route by ID. While it doesn't mention when not to use or alternatives, the context of sibling tools implies this is for checking after route creation.

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, so description carries full burden. It discloses key behavioral traits: no key required, no funds moved, no broadcast (simulated). This adequately informs an agent that the tool is safe and non-destructive, though it could mention absence of 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 concise sentences with no unnecessary words. Front-loaded with the action, then the constraints. Each sentence adds value and the structure is clean.

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 7 parameters, no annotations, and no output schema, the description is minimal. It provides the tool's purpose but lacks parameter details, usage examples, or output explanation, making it incomplete for an agent to use effectively.

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 0% across 7 parameters. Description adds no meaning beyond property names (e.g., 'amountHuman' is not explained). An agent cannot infer parameter details from the description alone, which fails to compensate for the missing schema documentation.

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 it runs a dry-run of the whole flow in sandbox mode ('no key, no funds, no broadcast'). While it distinguishes from siblings by indicating sandbox usage, it does not explicitly name alternative tools for comparison.

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 'Use this to prove an integration works before touching real money,' providing clear guidance on when to use. Does not include explicit exclusions or when not to use, but the intent 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, the description carries full burden and delivers: it never broadcasts, returns route/method/privacy/receipt, and offers private-mempool request. It discloses the privacy posture (API-relay + private mempool + uniform shape) without contradicting any structured data.

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

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

Four sentences, front-loaded with 'The one-verb primitive.' Some slight redundancy between 'in a SINGLE call' and 'It collapses quote + preflight + prepare', but no fluff. Structured with em-dashes and semicolons 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?

For a complex planning tool with 8 parameters and no output schema, the description covers core functionality, planning-only behavior, and the submit path. It doesn't specify exact return values, but states what the receipt will prove, which is sufficient for initial understanding.

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 high at 88%, so baseline is 3. The description adds value by explaining the private:true parameter meaning and how to use it, plus the conceptual 'one call' context. It doesn't deeply elaborate on all 8 parameters, but that's not necessary given schema richness.

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 this is the 'one-verb primitive' that returns the best route, gasless method, privacy posture, and settlement receipt proof in a single call. It explicitly distinguishes itself from siblings by collapsing quote + preflight + prepare, making it a compound planning tool.

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

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

Provides explicit guidance: 'Planning only: it never broadcasts — sign + submit via robyn_submit.' This tells when to use (planning) and when not to (broadcasting), naming the alternative. It also advises on the private:true parameter for requesting private-mempool execution.

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 must disclose behavior. It does so by explaining the statement is signed via EIP-191, verifiable against a published address, and explicitly states the coverage limitations: only the Robyn float lane, excluding other rails and netting book. This is strong behavioral context beyond a simple read-only hint, though it does not mention auth or rate limits.

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 but rich with information. It front-loads the core function, then gives usage context and limitations. It's not overly long, though the 'Read limitations and repeat them' phrasing adds a minor imperative tone.

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 covers purpose, signed nature, and limitations. It doesn't describe the exact return payload or verification steps, but the EIP-191 mention and 'verifiable against a published address' provide enough for an agent to infer usage. It's fairly complete for this 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?

Both parameters are fully described in the input schema (100% coverage), so the description adds no extra parameter-level detail beyond what the schema already covers. The description mentions 'window' and 'record names this sender' but these mirror the schema descriptions.

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

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

The description clearly states the tool produces a signed statement of every transfer in a window with fee breakdowns, and explicitly distinguishes it from an 'own summary' claim. This is specific and differentiates from sibling statement tools by highlighting the signed/provable nature.

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 when-to-use guidance: 'Use this when you must PROVE to a principal what you spent', and contrasts with the less trustworthy own summary. It also warns about limitations, though it doesn't name alternative sibling tools directly, the contrast with own summary implies the alternative.

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 burden. It discloses that the endpoint performs a dry price-check (returns estGas, priceUsd, envelope) and that broadcasting requires a separate call with an X-PAYMENT header. It mentions that Robyn pays gas, so no native token is needed. It does not cover failure modes, rate limits, or authentication details beyond the header, which is a gap.

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

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

The description consists of two well-structured sentences. The first sentence clearly states the primary purpose, and the second sentence explains the dual-mode operation. No extraneous information. It is front-loaded with key details about who pays gas and the two call paths.

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 (EIP-7702, nested authorization, two modes) and no output schema, the description covers the essential flow but lacks details on error handling, prerequisites (signed authorization), and the exact structure of the return values (estGas, priceUsd, envelope). It provides a good overview but falls short of being fully actionable without additional context.

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

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

Schema coverage is 50%, meaning half of the parameters lack schema descriptions. The description does not elaborate on parameter semantics; it only mentions the overall function. For example, the 'authorization' object and 'chainId' are not explained beyond the schema. The description adds marginal value to parameter understanding.

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: 'Price or request an EIP-7702 sponsored transaction'. It specifies the resource (EIP-7702 transaction) and the action (sponsor, relayer pays gas). It distinguishes between a dry price-check and actual broadcast, and the context signals show siblings like robyn_7702_check and robyn_7702_delegate, which are clearly different.

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 the tool: for sponsored transactions where the relayer pays gas. It explains the two modes (dry price-check vs. broadcast with X-PAYMENT header). However, it does not explicitly state when not to use this tool or compare it to sibling tools, though the unique function is evident.

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 that the relayer fronts gas, the signed spender must match the relayer, and the critical caveat that omitting a live flag may still broadcast on the EVM-to-EVM path. It also explains dryRun return values and idempotencyKey semantics, providing rich behavioral context.

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

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

The description is dense but well-organized, with the main action up front, then permit2 construction, safety warnings, and a critical corridor-specific caveat. Every sentence serves a purpose, though the all-caps warnings and repeated emphasis make it slightly longer than strictly necessary. It earns a 4 for effectiveness despite minor verbosity.

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 tool's core workflow, permit2 construction, gas sponsorship, dryRun behavior, and idempotency. Given the complexity (nested permit2 object, dryRun variations) and absent output schema, this is quite complete. However, the normal (non-dryRun) return value is never described, which is a notable gap for a submission 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 only 33%, so the description must compensate. It adds crucial meaning for permit2 (explicitly stating it is an object, not a bare signature, and how to build it) and idempotencyKey (prevents double-spend on retry). However, basic params like fromChain/toChain and amount receive no additional explanation beyond their names, leaving some ambiguity.

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

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

The description opens with a specific verb and resource: 'Relay an intent you already signed.' It clearly distinguishes this as the submission step after robyn_prepare, distinct from related tools like robyn_quote or robyn_preflight. The scope (broadcast signed intent, relayer pays gas) is explicit.

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

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

The description provides clear usage context: build permit2 from robyn_prepare, sign the eip712 payload, and pass the object. It also warns about dryRun behavior and idempotency. However, it does not explicitly mention when not to use this tool vs. alternatives, so it stops short of a 5.

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

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

No annotations are provided, so the description fully discloses behavior: it decodes ERC-20 Transfer logs, cross-checks Robyn's receipt, and defines a three-valued verdict including the meaning of 'undetermined'. It also warns about non-re-derivable rails, offering deep insight 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?

While detailed, every sentence provides necessary information: purpose, optional parameters, decoding behavior, verdict semantics, and usage warnings. Information is front-loaded with clear formatting and the verdict is highlighted, making it easy to scan. 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?

Despite no output schema or annotations, the description covers core functionality, parameter usage, and result interpretation thoroughly. It explicitly addresses edge cases like unreachable chains and non-re-derivable rails, making the description complete for an agent to select and invoke correctly.

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

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

The schema covers all parameters with descriptions, but the description adds functional meaning: explains that 'recipient' asserts who should be paid and 'minAmount' asserts the minimum arrival, and that 'id' can be a transfer id or tx hash. This enriches the schema's raw definitions and clarifies how parameters are used in verification.

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 uses a specific verb ('Check what ACTUALLY happened') and clearly identifies the resource ('a settled transfer against the destination chain'). It distinguishes this tool from Robyn's own database and covers the optional assertions of recipient and minAmount, making the purpose unambiguous and differentiating it from siblings like robyn_route_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?

The description explicitly explains when to use this tool: to verify settled transfers against the chain rather than Robyn's database. It also provides a clear exclusion rule: 'undetermined' must never be treated as success, with specific examples of when undetermined occurs. This gives strong guidance on interpretation and limits.

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 explicitly states 'Read-only' and outlines the membership benefits, giving the agent a clear understanding of what the tool does without side effects. It could mention edge cases like invalid address handling, but the core behavior is 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 two sentences long and front-loaded with the action. The second sentence provides dense, useful context about benefits and usage, without redundant fluff. It's slightly long but each clause earns its place, so 4 is appropriate.

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

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

For a simple read-only check with one parameter, the description covers purpose, usage, and behavior. No output schema exists, so the description reasonably indicates the output involves membership status and benefits, though it doesn't specify exact return format or error handling. This is a minor gap, so 4.

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% coverage for the single 'address' parameter with a clear EVM address description. The tool description adds no extra semantics beyond the schema, so the baseline of 3 applies.

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

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

The description clearly states the tool checks whether an address holds a recognised member NFT and what benefits it gets. It uses a specific verb ('Check whether') and resource ('an address'), and the mention of membership benefits distinguishes it from routing/quoting siblings like robyn_quote and robyn_cross_chain.

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 instructs to call this before quoting a user, providing a clear context for use. It implies the tool informs accurate cost quotes and savings for non-members, but it does not explicitly name alternative tools or specify when not to use it, so it falls short of a 5.

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