FlexYield — blockchain RPC gateway

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

Beyond annotations, the description adds the return payload fields, the requirement for an API key, and the nuance that idempotency applies 'for the same wallet.' This complements the idempotentHint annotation rather than merely repeating 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?

Every sentence earns its place: core purpose, sequencing, exclusions, return fields, idempotency, and auth requirement. The most important information is front-loaded in the first sentence.

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 compensates by enumerating the JSON return fields. It also covers all invocation requirements: signature source, sequencing, same key, and API key necessity. Nothing essential for calling the tool correctly is missing.

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

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

Schema coverage is 100%, so the schema already documents both parameters. The description adds valuable invocation context by tying the signature to the message from bind_key_start and requiring the same key, which goes slightly beyond the schema text.

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

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

States a specific verb and resource: completing the second step of binding an API key to a wallet by passing the wallet's signature. It explicitly differentiates itself from bind_key_start and claim_agent_complete, so an agent can identify it precisely among 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?

Gives explicit when-to-use guidance: 'Use it right after bind_key_start, with the same key.' It also names exclusions: not for the first step (use bind_key_start) and not for agent claims (use claim_agent_complete).

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

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

Annotations provide idempotentHint=true, and the description aligns by framing this as a message-returning step rather than a side-effectful binding action. It adds useful context beyond the annotations: the exact JSON return fields, expiration behavior, the need to follow with bind_key_complete, and the API-key requirement. A minor gap is not spelling out the consequence of using an already-bound key, though it does say not to.

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?

Every sentence carries weight: purpose, use case, exclusions, return shape, next step, and auth requirement are all packed into a compact paragraph. The core outcome is front-loaded, and there is no filler or repetition.

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

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

For a single-parameter start-step tool with no output schema, the description supplies the return fields, expiration, the mandatory follow-up step, the auth requirement, and the conditions under which it should not be used. Nothing essential for correct invocation is missing.

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

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

Schema coverage is 100%: the single parameter address is documented as 'The wallet's 0x address (your identity)'. The description does not add further parameter details, but none are needed since the schema fully explains the one required input. 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 opens with a precise action—'Step 1 of binding the API key you are calling with to a wallet'—and says the tool returns a SIWE message to sign. It also explicitly distinguishes itself from claim_agent_start, so an agent can immediately tell which workflow this belongs to.

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 exactly when to use the tool: when the key came from get_key and the user wants persistence across sessions. It also lists exclusions, including claiming an agent on another key and already-bound keys, naming the alternative claim_agent_start. This is exemplary routing guidance.

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

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

The description discloses the full purchase lifecycle: checkout creation, no money moves until a human pays, units become available upon payment, are consumed after quota, and remain valid for 12 months. It also notes the +5% bonus and API key requirement, adding considerable context beyond the annotations.

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

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

Despite being multi-sentence, every clause provides necessary details: pricing, trigger conditions, exclusions, return format, payment/availability behavior, and API key requirement. Nothing is redundant, and the key actions are 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 single-parameter mutation tool with no output schema, the description is complete: it covers when to use, when not to use, parameter values, side effects, return JSON structure, and auth. An agent does not need to open schemas or inspect 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?

The schema only says size can be 's', 'm', or 'l'. The description expands each value with specific unit counts and prices, and adds the bonus-units behavior, so an agent knows exactly what each size means in practice.

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: 'Start the purchase of a prepaid unit pack' and immediately enumerates exact sizes and prices. It explicitly excludes changing the plan and reading balances, and routes the reading task to get_billing_status, making it unmistakable 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?

It gives an explicit trigger: 'Use it when what_can_i_do or a refusal says the monthly budget is running out.' It also names clear exclusions: not for changing the plan via web console and not for reading balances, providing 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?

The annotations are all false or non-illuminating, so the description itself must carry behavioral weight. It does: it discloses that the operation creates a key, returns a plaintext token shown only once, and requires the agent's API key. This goes beyond the schema and gives the agent essential side-effect and security 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 and front-loaded, leading with the tool's exact role in the workflow, then usage constraints, then return format and caveats. Every sentence carries actionable information; there is no filler or repetition of schema fields.

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

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

For a tool with no output schema and uninformative annotations, the description is complete: it covers flow position, return fields, the once-only token warning, the created key, the default budget, and authentication needs. An agent has enough to invoke it correctly and know what to do with the response.

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%, which sets a baseline of 3. The description adds meaningful detail beyond the schema by clarifying that signature is over the message from claim_agent_start, that address is the same as in that first step, and that the default monthly cap is 50000 requests—information the schema leaves implicit. This lifts it above the baseline.

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

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

The description names a specific verb and resource: verify a wallet signature and equip an agent with a budgeted API key. It explicitly frames itself as 'Step 2 of claiming an agent,' making its position in the workflow unambiguous. It also names claim_agent_start and configure_key as related but distinct tools, so an agent can pick it out from siblings.

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

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

The description gives direct when-to-use guidance: 'Use it right after claim_agent_start.' It also states what it is not for, excluding the first step and budget changes, and names the alternative (configure_key) for the latter case. This is explicit routing with no reliance on inference.

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

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

Annotations already cover idempotency and destructiveness. The description goes beyond them by explaining the multi-step process ('Step 1'), the exact return fields ('address, message_to_sign, expires_in_seconds, note'), the authentication requirement ('Needs your API key'), and that it is scoped to 'the account you are calling with.' This adds practical behavioral context, though it doesn't cover error/failure modes or session state, which is acceptable for a step in a larger workflow.

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?

Every sentence earn its place: purpose, use case, exclusions, return format, next step, auth requirement. No fluff or repetition. The information is front-loaded and structured so the critical facts (purpose and alternatives) come first, and the operational details follow. It's dense but readable.

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

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

For a two-parameter tool in a multi-step, overloaded nested environment, the description covers all necessary entry points: purpose, when to use, alternatives, output shape, next step, and authentication. It doesn't explain edge cases or expiration thresholds, but those are not needed for correct selection and invoicing. Given the absence of an output schema, the inline return-field list provides sufficient transparency.

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

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

Schema description coverage is 100% for both parameters, so the base is 3. The description slightly augments the schema by describing the address as 'the agent's 0x wallet address' and the name as a label, but it doesn't explain validation rules or relational meaning. It adds no info beyond the schema for these parameters, so the baseline score 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 is 'Step 1 of claiming an agent by its EVM address' and that it returns a SIWE message to sign. It explicitly distinguishes itself from computational siblings: 'Not for binding your own key (use bind_key_start) and not for plain key creation without a wallet (use create_api_key).' This makes the tool's purpose unambiguous and separates it from the two most likely 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?

Provides explicit when-to-use guidance: 'Use it when an account owner wants a budgeted key for an agent that proves control of a wallet.' Also gives clear when-not-to-use instructions naming the exact alternatives, and even provides the next step ('Follow with claim_agent_complete'). The agent can decide correctly without extra inference.

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

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

Annotations already provide readOnlyHint=false, idempotentHint=true, and destructiveHint=false; the description adds context on top: omitted month cap means unchanged, 0 removes the cap, return JSON differs depending on whether budget or services changed, and authentication is required ('Needs your API key'). Minor gaps remain—behavior when both budget and services change is ambiguous—but the description carries substantial behavioral weight beyond the annotations.

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

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

The description is dense and logically ordered: what it does, what fields mean, when to use it, what it is not, and what it returns. Every sentence carries information, though a little redundancy with the schema's window values and the trailing auth note 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?

With no output schema, the description is responsible for explaining the return shape, and it does so conditionally for budget vs services changes. It also covers auth, parameter semantics, and exclusions. It doesn't detail error behavior or simultaneous-field-change returns, but for a 5-param config tool with 100% schema coverage and annotations, 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?

Schema coverage is 100%, so the baseline is 3. The description adds meaningful semantics: it explains the omitted/0 behavior of monthly_request_cap, enumerates the actual service keys accepted by enabled, and examples for caps and window behavior. That is more than the schema alone 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 leads with a specific verb and resource ('Configure one API key of your account by id'), names exactly what can be changed (monthly_request_cap, enabled, caps), and explicitly distinguishes itself from configure_services and revoke_api_key. An agent can tell this tool apart from its siblings without reading the schema.

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

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

It states when to use the tool ('Use it to budget or restrict one key'), where ids come from ('key ids come from list_api_keys'), and explicitly says when NOT to use it ('Not for account-wide service settings (use configure_services) and not for revoking (use revoke_api_key)'). This is exactly the guidance needed for correct selection.

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

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

Annotations already declare readOnlyHint=false, idempotentHint=true, and destructiveHint=false. The description adds useful behavioral context beyond those flags: the exact error codes when a service is capped or disabled, the response shape, and the fact that an API key is required. It does not add rate limits or detailed side-effect warnings, but the annotation coverage lowers the burden.

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

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

Every sentence earns its place: purpose, read-vs-change usage, sibling distinction, output shape, error conditions, and authentication. The information is dense but not padded, and the core operation is stated first.

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

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

The description is complete enough for a 3-parameter tool with no output schema: it explains the return JSON, error semantics for capped/disabled states, authentication needs, and the read/change distinction. Nothing required to decide whether or how to call the tool is missing.

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

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

Schema description coverage is 100%, so the baseline is 3, but the description adds real semantic value: it enumerates the valid service keys, connects 'no arguments' to read mode, connects enabled/caps to write mode, and clarifies the account-wide scope. Since the schema has no enums, this extra detail is meaningful.

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

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

The description names a specific verb and resource, 'Read or change the account-wide service settings,' and lists the exact gateway services involved (rpc, data, gas, tx_status, ens, prices, contracts, utils). It also explicitly distinguishes itself from the per-key sibling by saying 'Not for one key's budget or services (use configure_key).'

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

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

It gives explicit when-to-use guidance: 'Use it with no arguments to read; pass enabled and/or caps to change.' It also names the alternative tool for a different scope, configure_key, and provides functional consequences such as error -32014 for capped services and -32012 for disabled ones.

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

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

Beyond the annotations (readOnlyHint, idempotentHint, destructiveHint), the description adds substantive behavioral context: 'no chain call' (offline behavior not captured by readOnlyHint), 'Read-only, deterministic' (determinism goes beyond idempotency), and 'Needs your API key' (an auth requirement absent from annotations). None of this contradicts the annotations — it complements them. This is exactly the extra context the rubric rewards.

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 every sentence earns its place: operations, usage context, exclusions, return shapes, and behavioral notes. The 'no chain call' scope is front-loaded. It is somewhat long, but given four distinct sub-operations and no output schema, the length is justified. A list format could improve scannability, which prevents a 5.

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

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

For a multi-mode tool with 4 parameters and no output schema, the description is thorough: it documents all four operations, their input requirements, and their return shapes (essential since no output schema exists), plus workflow context, exclusions, and behavioral guarantees. Minor gaps remain — the full unit list for convert is vague and error/edge-case behavior (e.g., invalid address handling) is not addressed.

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

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

Schema coverage is 100%, so the baseline is 3. The description raises it by adding per-operation parameter semantics the schema lacks: it explains what `op` values do, that `from`/`to` apply 'convert only', that `input` means address/value/signature/text depending on op, and it maps each op to its return fields (checksum → valid_address, checksummed; convert → value, from, to, result). The only minor gap is that valid units are hinted as 'wei…gwei…eth' without full enumeration.

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 'Offline EVM utilities, no chain call' — a specific verb phrase naming the resource and scope. It enumerates all four operations (checksum, convert, selector, keccak) with precise definitions for each, and distinguishes itself from siblings by naming what it is not: 'Not for verifying a signature (use verify_signature) or decoding calldata (use decode_calldata)'. An agent can tell exactly what this tool does and how it differs from rpc_call, verify_signature, and decode_calldata.

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

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

The description gives explicit when-to-use guidance: 'Use it for address hygiene and unit maths before an rpc_call' — a concrete workflow context. It also names alternatives with conditions: 'Not for verifying a signature (use verify_signature) or decoding calldata (use decode_calldata)'. This is the textbook case of explicit when/when-not/alternatives guidance.

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

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

Annotations already declare write (readOnlyHint=false), non-idempotent, non-destructive. The description adds important context beyond those flags: the created token is shown once and cannot be read again, the returned plaintext_token must be stored, and a get_key-issued key cannot mint further keys. It does not fully detail what happens with the monthly cap when omitted, but the schema already covers that.

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 effective: three well-organized sections (purpose, exclusions, return contract). It front-loads the purpose and immediately names alternatives. The only minor inefficiency is repeating 'Creates a key' at the end after already saying 'Create an additional API key', and the return-value list could be considered somewhat long, but each clause earns its place given there is no output schema.

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

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

For a 2-param tool with no output schema, the description covers the full call contract: what it returns (including that plaintext_token is shown once), when to use, when not to use, and the alias/constraint. The only minor gap is it doesn't state the exact auth mechanism beyond 'Needs your API key', but that matches the tool family and the given context signals; the description is complete enough for correct invocation.

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

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

Schema description coverage is 100%, so the schema documents both parameters. The description adds context for monthly_request_cap ('own budget', 'fleet spend control') which reinforces the schema's wording, but doesn't add new meaning beyond it. The 'not: type: null' schema oddity for monthly_request_cap is a schema detail, not something the description needs to compensate for. Baseline 3 is appropriate.

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

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

States a specific verb+resource ('Create an additional API key'), and explicitly distinguishes itself from siblings: 'Not for your first key (use get_key, no signup) and not for a wallet-proven agent key (use claim_agent_start)'. An agent can tell it apart from get_key, list_api_keys, revoke_api_key, and configure_key without opening schemas.

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

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

Explicitly says when to use (give a service or teammate its own key/budget) and when not to (first key → get_key, wallet-proven agent key → claim_agent_start). States a prerequisite ('Needs your API key') and a hard constraint ('a key obtained from get_key cannot mint further keys'). No exclusions are left to inference.

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

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

Annotations already declare readOnlyHint, openWorldHint, idempotentHint, and destructiveHint=false, so the description doesn't need to repeat safety. It adds useful behavioral context beyond annotations: the decoding behavior (static types decoded, dynamic types shown raw and labelled), the reliance on Sourcify verification, the explicit output JSON structure, and the API key requirement. No contradictions with annotations.

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

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

The description is compact yet information-dense, front-loading the core action and output, then covering usage, exclusions, output format, and constraints in a logical order. Every sentence earns its place—no fluff, no repetition.

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

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

Given the tool's complexity and the absence of an output schema, the description adequately conveys the return shape (chain, address, function, selector, args, source) and key limitations (static vs. dynamic types, Sourcify dependency, API key requirement). It could mention error cases or what happens if the ABI isn't verified, but for most agent scenarios this is sufficient.

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%: chain, address, and data are fully described in the input schema with types and examples. The description does not add any additional parameter-level semantics beyond what the schema already provides, so it meets the baseline 3 but doesn't exceed it.

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

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

The description clearly states the verb ('Decode'), the resource ('a transaction's calldata against the target contract's verified ABI'), and lists the specific outputs (function signature, selector, argument values). It also differentiates from siblings by naming get_abi, get_tx_status, and convert_evm, so an agent can immediately identify this tool's unique 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 states when to use the tool ('to explain what a pending or past transaction does') and when not to use it, naming exact alternatives for each exclusion ('Not for the whole ABI (use get_abi), a transaction's status (use get_tx_status), or computing a selector from a signature (use convert_evm)'). This provides unambiguous routing guidance.

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

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

Annotations already declare readOnlyHint, idempotentHint, and destructiveHint, but the description adds meaningful behavioral context beyond them: it is read-only, requires no key, returns a JSON object with specific fields, and handles unknown codes by returning known=false with a hint. This fully discloses the tool's behavior and edge case without contradicting the annotations.

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

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

The description is three sentences and every sentence earns its place: what it does, when to use it, what it returns, and what it is not for. The key information is front-loaded, and there is no filler or repetition of the tool name.

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, read-only tool with no output schema, the description is fully complete. It explains the return shape (code, http, title, meaning, steps, doorway, decoder), the unknown-code case, auth requirement (no key needed), and usage exclusions. Nothing an agent needs to invoke it correctly is missing.

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

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

Schema description coverage is 100%, so the schema already documents that the only parameter is an integer JSON-RPC error code such as -32007. The description reinforces this with an example and context, but does not add substantial meaning beyond the schema — so the baseline of 3 applies.

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

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

The description states a specific verb ('Explain'), a specific resource ('a FlexYield error code'), and precisely what the tool provides: meaning, steps, and doorway. It also names what it is not for (upstream chain errors, filing tickets) and explicitly routes ticket filing to manage_tickets, distinguishing it from siblings without opening schemas.

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

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

The description gives an explicit trigger: use it whenever a call returns an error code you do not know, before retrying or filing a ticket. It also provides clear exclusions and alternatives: not for upstream chain errors that are not ours, and not for filing the problem — for that use manage_tickets with the request_id.

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

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

Annotations already provide readOnlyHint=true, idempotentHint=true, and destructiveHint=false, so the safety profile is covered. The description adds valuable behavioral context beyond this: the exact JSON return fields, the unverified-contract case with verified=false, the API key requirement, and the open dataset origins. This combination gives an agent a solid mental model of the operation.

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

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

The description is organized into short, focused sentences: what it returns, when to use it, when not to use it with alternatives, return format, edge case, and auth requirement. It is slightly dense but every clause carries information and there is no meaningful 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?

With no output schema, the description takes on the burden of explaining return values, and it does so explicitly including edge-case behavior for unverified contracts. Combined with annotations covering safety/idempotence and the small parameter set, nothing an agent needs to select and call this tool correctly is missing.

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

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

Schema description coverage is 100%, so the schema already documents both parameters. The description adds a list of valid chains and reaffirms the address format, but does not add substantial new meaning beyond the schema. This matches the baseline 3 for full schema coverage.

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

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

The description clearly identifies the resource (verified ABI of a contract), the data source (Sourcify), and the supported chains, which makes the tool's purpose unmistakable. It also differentiates itself from siblings by explicitly contrasting with decode_calldata and convert_evm.

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

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

The description gives explicit when-to-use guidance ('Use it before calling or decoding a contract you do not have the ABI for') and explicit when-not-to-use guidance with named alternatives ('Not for decoding a specific calldata blob (use decode_calldata) ... not for a function selector (use convert_evm)'). No inference is required.

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

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

Annotations already include readOnlyHint, idempotentHint, and destructiveHint=false. The description adds important behavioral context beyond annotations: it is read-only (confirming the annotation), costs 10 weighted units (metered on the user's key), requires an API key, and notes that token availability depends on 'data-capable upstream' existence. This is rich, supplementary behavioral disclosure.

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

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

The description is information-dense but well-structured: first sentence defines the operation and scope, second gives use cases, third names exclusions and alternatives, fourth summarizes the return JSON, and fifth covers read-only/cost/auth. Every sentence earns its place, with critical details front-loaded. 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?

Given the tool's simplicity (2 required params, no output schema) and strong annotations, the description covers all needed aspects: what it does, when to use it, what it returns (JSON structure), its safety profile (read-only, idempotent), cost, and authentication requirements. An agent can invoke it correctly without additional information.

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

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

Schema description coverage is 100%, so both 'chain' and 'address' are well-documented in the schema. The description adds value by enumerating the allowed chain slugs and clarifying that the address format differs per chain (0x… for EVM, base58 for Solana), which slightly exceeds the schema's brief examples. This is a meaningful enhancement over the schema alone.

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 retrieves native and ERC-20 balances for an address on a specific chain, listing supported chains. It explicitly differentiates from get_history and rpc_call, making its purpose unambiguous relative to siblings.

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

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

The description gives concrete use cases ('portfolio or pre-flight funds check') and explicitly states what it is NOT for, naming the alternative tools (get_history for transfer history, rpc_call for raw eth_getBalance). This provides clear guidance on when to use this tool versus alternatives.

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

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

Annotations already mark it read-only, idempotent, and non-destructive. The description adds meaningful context: it returns a specific JSON shape, never exposes the full card number, requires the API key, and notes where plan changes do occur. It does not contradict the annotations.

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

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

The description is dense but well-organized: return payload first, usage conditions next, exclusions with named siblings, then output keys, safety, and auth. Every clause adds information an agent needs; nothing 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?

For a zero-parameter, read-only inspection tool with no output schema, the description is complete: it states what data is returned, when to call it, what not to use it for, how to distinguish it from related tools, and the auth requirement. An agent has everything needed to select and invoke it correctly.

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

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

The tool has zero parameters, so the description correctly avoids parameter-level detail. The 'Needs your API key' line is an authentication context note rather than an input parameter. Baseline 4 applies for zero-parameter tools with no missing semantic burden.

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

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

The description clearly identifies the resource ('billing state of your account') and enumerates the contained information. It explicitly contrasts itself with get_usage, get_statement, and list_plans, making sibling differentiation immediate 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?

It gives concrete when-to-use triggers: before buy_pack and when a call is refused for budget reasons. It also names the alternatives for usage numbers, invoices, and plan prices, and states that plan changes happen in the web console rather than through 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?

Annotations already mark readOnly/openWorld/idempotent/non-destructive, and the description adds value beyond them: it specifies the JSON return shape, the 10 weighted-unit cost, metering on the user's key, and the API-key requirement. No contradiction with annotations.

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

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

Three sentences pack definition, usage, exclusions, output, cost, and auth without padding. The core action is front-loaded and 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 low-complexity 2-parameter read-only tool with no output schema, the description covers what the tool returns, when to use it, constraints, cost, and key requirement. Nothing needed to invoke it correctly is missing.

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

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

Schema description coverage is 100%, so the schema already explains chain slug and address. The description adds context like 'one EVM chain' and 'data-capable upstream' but does not materially extend parameter-level meaning beyond the schema, matching the baseline.

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

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

The description uses a specific verb and resource: 'Recent asset transfers ... of an address' on one EVM chain. It also explicitly distinguishes itself from get_balances and get_tx_status, so an agent can tell it apart without opening schemas.

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

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

It gives a clear when-to-use framing ('what moved in or out of this address lately'), explicit exclusions ('Not for current balances', 'one transaction's state', 'Solana'), and names the alternatives (get_balances, get_tx_status). This routes an agent to the correct tool unambiguously.

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 the side effects (creates a key), the limits (at most 3 per IP per day, 10,000 weighted units per day, 5 requests/s), the return structure (key shown once, key_prefix, door, fences, doorways, terms, skill), and that no key is needed. Since annotations provide no hints (all false), the description carries the full burden and does so thoroughly.

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 efficient. It opens with the core purpose and the key limits, then flows into usage guidance, exclusions, return format, and creation limit. Every sentence adds unique value, with 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?

Given the absence of an output schema and empty annotations, the description must independently provide all necessary context for an agent to call the tool correctly. It covers the purpose, when to use it, what it returns, the limits, and the lack of required authentication. This is fully complete for a tool with no 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?

The tool has zero parameters, so the schema provides no parameter semantics (100% coverage vacuously). The baseline for 0 parameters is 4. The description does not need to explain parameters, and it doesn't; it appropriately focuses on behavior and output. No additional parameter information is necessary.

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

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

The description clearly states the verb 'Get' and the resource 'a FlexYield API key with no signup'. It explicitly distinguishes itself from siblings by stating it is for when you have no key yet, and points to what_can_i_do and list_plans as alternatives for other cases. This provides strong 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?

Explicit usage guidance is given: 'Use it once, when you have no key yet; then send the key as the bearer on every other call.' It also states what it is NOT for ('Not for a key you already hold' and 'not for a human's paid plan') and names the alternative tools to use instead, leaving no ambiguity.

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

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

Annotations already declare read-only, idempotent, open-world, and non-destructive. The description adds meaningful behavioral context beyond annotations: it requires an API key, uses a weighted unit, computes from 'our pool', and specifies exact response fields per mode. No contradiction.

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

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

Though multi-sentence, the description is dense and well-structured: mode definitions first, then use cases, then exclusions, then return shape and auth requirement. Every sentence adds operationally useful information 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?

For a read-only price tool with no output schema, the description fully equips an agent: required parameters per mode, examples, return fields, auth requirement, and sibling-tool exclusions. Nothing critical for a correct call is missing.

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

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

Schema coverage is 100%, so baseline is 3. The description adds value by explaining the kind-mode relationship, noting that gas requires a chain and token requires comma-separated symbols, and clarifying that token prices are in USD and gas recommendations are EIP-1559. This goes beyond the schema's terse parameter descriptions.

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

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

The description clearly defines two distinct modes ('gas' and 'token') with specific verbs and resources: EIP-1559 gas recommendations and current token prices in USD. It also explicitly names what this tool is not for, distinguishing it from get_quote and list_plans.

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: before sending a transaction for gas, or to value a balance for token. It also names alternatives (get_quote, list_plans) and explains 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?

Annotations already declare readOnlyHint=true, idempotentHint=true, and destructiveHint=false; the description reinforces this with 'Read-only' and adds 'No key needed.' It also discloses behavior beyond the schema: what the JSON response contains, and that unsupported methods return offered=false with a reason. This gives the agent a clear model of side effects and output shape without needing a sample.

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 every sentence earns its place: purpose, output format, when-to-use, exclusions with alternatives, and response details are all packed in without fluff. Key info is front-loaded, with the 'Read-only' and 'No key needed' notes at the end as low-priority confirmations.

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

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

For a read-only quoting tool with no output schema, the description is fully self-sufficient: it explains what the tool does, the exact response fields, the special case for unoffered methods, authentication expectations, and usage boundaries. There is no critical information an agent would need to correctly select or invoke this tool that is missing.

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

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

Schema coverage is 100%, so the baseline is 3codified. The description goes beyond the schema by defining the semantic relationship between 'lane' and the tier parameter ('a lane = a price tier: cheap, balanced, fast') and clarifying the meaning of 'units' (standard 1, heavy 2). While it doesn't detail each parameter, it adds meaningful conceptual context that helps set tier correctly.

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 ('Quote') and a clear resource (a JSON-RPC call's cost), and defines what it returns: weighted units and USD per 1M units per tier. It explicitly distinguishes itself from sibling tools by naming get_prices, list_plans, and get_billing_status as alternatives for other quote-like questions, so an agent can disambiguate immediately.

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

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

It gives explicit when-to-use guidance: when an owner asks what a workload would cost or before calling a heavy method. It also provides direct exclusions with named alternatives ('Not for gas or token prices (use get_prices), plan prices (use list_plans) or your own balances (use get_billing_status)'), leaving no ambiguity about routing.

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

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

Annotations already declare readOnlyHint/idempotentHint/destructiveHint, so the description adds value beyond them by stating 'Read-only', the default period, the 'list' mode, that an agent sees only its own usage, and that periods follow subscription cycle or calendar months. It does not mention rate limits or error behavior, but the provided content is strong.

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?

Every sentence carries high-signal information, and the core purpose is front-loaded. It is dense and long, but not redundant; the only slight inefficiency is the extensive return-format enumeration, yet with no output schema that also serves as needed context.

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 enumerates the JSON fields for both normal and list modes, explains default scope, period, authentication need, and read-only behavior. For a single-parameter read tool with clear result shapes, nothing essential is missing.

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

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

Schema coverage is 100%, giving the parameter baseline at 3, but the description adds what the schema does not: default period behavior, that 'list' is a special enumerator, and that periods follow the subscription cycle or calendar months. These are meaningful semantic enrichments beyond the schema's start-date example.

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

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

The description states a specific verb-resource pair ('get statement') and details exactly what it contains: 'invoice facts plus usage grouped by API key or agent, chain and method class'. It also differentiates from siblings explicitly by naming get_usage and get_billing_status, leaving no ambiguity about what this tool uniquely 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 gives explicit when-to-use ('Use it for month-end reconciliation or to show an owner what a period cost') and when-not-to-with alternatives ('Not for live usage (use get_usage) or the card and subscription (use get_billing_status)'). It also adds scoping rules (agent's key sees only that agent's usage) and cycle behavior, giving an agent complete decision guidance.

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

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

Annotations already declare readOnlyHint, idempotentHint, and destructiveHint, and the description adds 'Read-only; metered on your key. Needs your API key.' It also discloses the exact return fields and the per-chain variations. No contradiction with annotations. Slight deduction because the description repeats 'Read-only' that annotations already state, but the metering and auth details go beyond annotations.

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

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

Every sentence earns its place: purpose, status enum, chain-specific fields, usage instruction, exclusions, return format, and operational notes (metering, API key). It is front-loaded with the core purpose and structured clearly, with 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?

For a tool with no output schema, the description fully compensates by enumerating all return fields and their chain variants. It covers usage, exclusions, auth requirements, and metering, leaving no ambiguity for an agent to call it correctly. The complexity is moderate, but the description addresses all practical needs.

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

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

Schema description coverage is 100% – both parameters (hash and chain) are fully documented in the schema, including the format for hash (0x… for EVM, base58 for Solana) and an example chain slug. The description adds no additional parameter-specific information beyond what the schema already provides, so baseline 3 is appropriate.

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

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

States precisely what the tool does: reports the status of a single transaction hash across chains, enumerating the possible statuses and the chain-specific details returned. It explicitly names sibling tools it is not (get_history for address transfers, decode_calldata for decoding), making its purpose 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?

Gives direct, actionable guidance: 'Use it to poll a transaction you sent or were told about' and explicitly states what it is NOT for, naming the two alternative tools. This is a textbook example of when-to-use/when-not-to-use clarity.

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

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

Annotations already declare readOnlyHint=true, destructiveHint=false, and idempotentHint=true. The description reinforces read-only status and mentions authentication ('Needs your API key'). It also discloses the return structure per view, which is behavioral detail beyond annotations. Since no output schema exists, this is valuable context. However, it does not describe edge cases or error behavior, so a small gap remains.

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

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

The description is longer than typical but every sentence earns its place. It is front-loaded with the main purpose, then details each view, exclusions, return format, and safety note. It is well-structured with clear delineations, avoiding redundancy. It could be slightly more succinct, but the density of useful information justifies the length.

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?

Considering the tool's complexity (three views, five parameters) and the absence of an output schema, the description is exceptionally complete. It explains each view's purpose, parameter usage, return JSON fields, exclusions, and read-only nature. There is no significant missing information an agent would need to correctly invoke the tool.

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

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

Schema coverage is 100% with descriptions for each parameter, so the baseline is 3. The description adds value by mapping parameters to specific views (e.g., 'view=report uses hours', 'view=stats uses report and window', 'view=volume uses window'), which the schema does not do. This clarifies which parameters are relevant in each mode, going beyond the schema's individual 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 states a clear purpose: 'Your account's usage in one of three views' and further explains each view in detail. It explicitly distinguishes this tool from siblings by naming alternatives (get_statement, get_billing_status, list_api_keys) and what they are for, leaving no ambiguity about the tool's specific function.

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

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

The description provides explicit when-to-use guidance: 'Use it to answer how much did we use, where, and how fast' and clearly states exclusions: 'Not for invoices (use get_statement), balances (use get_billing_status) or one key's settings (use list_api_keys)'. It also breaks down usage by view, telling the agent which parameters apply to which mode, which is excellent routing guidance.

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

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

Annotations only carry default false hints, so the description carries the burden and largely delivers. It discloses that the tool 'Creates a record and a mail,' states the return JSON shape (sent, contact), and notes 'No key needed.' This goes beyond annotations with real side-effect and auth context. It stops short of mentioning idempotency or repeat-submission behavior, but that is a minor 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 is a single dense block, but every clause carries weight: purpose, content constraints, usage trigger, exclusions, return format, side effects, and auth. It is front-loaded with the core action. Slightly long, but efficient and well-ordered for an agent scanning it quickly.

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

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

For a simple 2-param tool with no output schema and generic annotations, the description is complete. It covers what it does, when to use it, when not to, return structure, side effects, and authentication. Nothing an agent needs to invoke it correctly is missing.

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

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

Schema coverage is 100% with both email and items described, so baseline is 3. The description adds meaningful context for items by enumerating example content (chains, SLAs, compliance, features, prices) and the max 1000 chars limit, which the schema's 'free text' does not convey. This extra guidance justifies a 4.

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

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

The description states a specific verb and resource: 'Send FlexYield an enterprise wishlist.' It clarifies the content (chains, SLAs, compliance, features, prices) and distinguishes itself from siblings by naming manage_tickets and manage_feedback as alternatives for different scenarios. An agent can determine what this tool does even without reading the schema.

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

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

Explicitly provides the trigger condition: 'Use it when the public plans do not fit and a human wants to talk.' It also gives clear exclusions with named alternatives for bugs/account questions (manage_tickets) and signed-in product ideas (manage_feedback), leaving no ambiguity about when this tool is appropriate.

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

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

Although annotations already declare idempotentHint=true and destructiveHint=false, the description adds meaningful beyond that: it creates a waitlist entry, requires no key, and returns a specific JSON shape. This enriches the behavioral profile without repeating annotation data or contradicting 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?

Three sentences: (1) purpose and core inputs, (2) when and when-not with alternatives, (3) return format and side effect. Every sentence earns its place, the purpose is front-loaded, and there is zero 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 write tool with only 4 parameters, an output schema absent, and high schema coverage, this is complete. It covers purpose, usage guidance, behavioral side effects, auth requirements, and return shape. There are no obvious gaps for an agent to call it correctly.

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

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

Schema coverage is 100%, so the baseline is 3. The description only paraphrases the qualifier values already in the schema and does not add meaning to optional parameters like source or product_updates. It works, but adds no real semantic value over the JSON 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 and resource: 'Join the FlexYield early-access waitlist with an email and a qualifier'. It clearly defines the qualifier values and immediately contrasts the tool with siblings like get_key, manage_tickets, and join_enterprise_wishlist, making the 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 explicitly states when to use the tool ('only when a human asked to be kept informed') and names the exact alternatives for other scenarios (get_key for agent access, manage_tickets for support, join_enterprise_wishlist for enterprise). This is textbook usage guidance with conditions and exclusions.

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

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

The annotations already declare readOnlyHint, idempotentHint, and non-destructive behavior, so the description does not need to repeat safety. It adds value by stating the auth requirement ('Needs your API key') and disclosing the exact return shape for both scopes, which is not in the annotations or output schema. It does not mention pagination or limits, but for a simple read operation this is not a significant 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 is dense but every sentence earns its place: operation, scopes, use cases, exclusions, output format, auth, and safety. The most important information is front-loaded, and the exclusion clauses are compact rather than 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?

There is no output schema, but the description fully specifies the JSON response for both scopes, including field names. It also covers purpose, when to use it, when not to use it, alternatives, auth, and read-only behavior; nothing needed to call it correctly is missing.

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

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

Schema coverage is 100%, so the baseline is 3. The description adds meaning beyond the schema by explaining what each scope means ('wallet claims and budgets' for agents) and confirming the default behavior. This helps an agent understand the single parameter's practical effect better than the schema alone.

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

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

The description names a specific verb ('List') and resource ('API keys of your account' or 'agent fleet'), and immediately distinguishes the two scopes. It also differentiates from sibling tools like configure_key, revoke_api_key, get_usage, and what_can_i_do, so an agent can select it without opening schemas.

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

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

It explicitly says when to use this tool: to find a key id before configure_key or revoke_api_key, or to see which keys are in use. It also gives clear exclusions: not for usage numbers (get_usage) and not for the caller's key standing (what_can_i_do), leaving no ambiguity about alternatives.

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

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

Annotations already declare readOnlyHint, idempotentHint, and destructiveHint, so the safety profile is covered. The description adds valuable behavioral context beyond annotations: 'No key needed' indicates authentication requirement, and it outlines the return shape (JSON with plans array, enterprise, signup_url). This adds useful operational detail without contradicting annotations.

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

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

The description is efficient, with zero filler. It front-loads the core purpose, then immediately lists return fields and routes to alternatives. Every sentence earns its place, and the structure makes it easy to scan. It strikes a balance between completeness and brevity.

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 parameterless, read-only list tool, the description covers all necessary information: what data is returned (field names), the use case, and exclusions. Annotations cover safety, and the description provides the output structure despite lacking an output schema. Nothing an agent needs to call this correctly is missing.

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

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

There are zero parameters, so the empty schema needs no explanation. Per rubric, baseline for 0 params is 4. The description appropriately focuses on output and use cases rather than parameters, which is correct for a parameterless tool.

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 lists public plans with specific fields (price in cents, billing interval, included units, burst rate limits, enterprise line, signup URL). It uses a specific verb 'List' and resource 'FlexYield's public plans', and explicitly differentiates from siblings by naming what it is not for (get_quote, get_billing_status, what_can_i_do). This leaves no ambiguity about 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?

It provides explicit when-to-use: 'Use it to compare plans or before telling an owner what an upgrade costs.' It also gives explicit when-not-to-use with named alternatives for three distinct cases, covering all common misuse. This is exemplary guidance.

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

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

The annotations provide no positive hints (all flags false), so the description carries the transparency burden. It discloses that submitting 'files' feedback and that replies arrive 'on the feedback page', that list returns filed feedback plus replies, and that an API key is required. It does not elaborate on side effects or reply timing, but it covers the essential behavior.

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

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

The description is dense and each clause earns its place: action modes, parameter hints, intended use, exclusions, return shape, and auth requirement. It is a long run-on sentence, but it is compact relative to the information it conveys and front-loaded with the primary purpose.

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

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

Even with no output schema, the description provides the return shape for both actions ('submit → id, kind, title, chain, status, reply, created_at; list → feedback'), the required API key, and clear sibling boundaries. For a two-action tool with no nested objects, nothing critical is missing for an agent to select and invoke it correctly.

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

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

Schema description coverage is only 17% (only action is documented), so the description must compensate. It enumerates kind values ('feature' | 'chain' | 'praise' | 'complaint' | 'other'), marks title as expected with body and chain optional, and makes status conditional on list. It still leaves body, chain, and status semantics somewhat implicit, but it adds substantial meaning beyond the bare 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 states the exact function ('Product feedback to FlexYield') and enumerates the two action modes, submit and list. It also names the sibling tools it is not (manage_tickets, join_enterprise_wishlist), so an agent can clearly distinguish it.

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

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

It explicitly says when to use the tool: 'ideas, a chain you want added, or praise and complaints that need no fix on your account.' It also gives concrete exclusions with named alternatives: failing calls/refusals → manage_tickets, enterprise terms → join_enterprise_wishlist.

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

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

Annotations only provide negative hints (readOnlyHint false, destructiveHint false), so the description carries the burden of behavioral disclosure. It adds auth requirements ('Needs your API key'), describes the side effect of creating a ticket with evidence attached, and details reply actions including resolve/reopen. It also specifies return shapes per action. It does not explicitly state non-idempotency of create, but given the richness of the description, this is a minor 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 is dense but well-structured: it front-loads the purpose ('Your support tickets'), then enumerates actions with parameters, follows with usage triggers and exclusions, and ends with return summaries and auth note. While it is a long sentence, every segment earns its place, and there is no redundancy. It could be slightly more concise, but the structure is logical and scannable.

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 9 parameters, no output schema, and only minimal annotations, the description covers all essential aspects: action semantics, per-action parameter usage, return structures (create/reply vs list vs get), auth requirement, and explicit exclusions. It even includes the contextual trigger 'doorway said to file it', making it nearly 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?

Schema coverage is only 44%, and several parameters (subject, message, category, reopen, resolve) lack descriptions. The description fully compensates by mapping each parameter to its action context: 'create (subject, message, optional request_id of the failing call, optional category)', 'list (optional status)', and 'reply (reference, message, optional resolve/reopen)'. It also clarifies the meaning of request_id and reference explicitly, adding critical semantic value beyond the schema.

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

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

The description specifies the resource ('support tickets') and lists four concrete actions with parameter mappings, making the function's purpose unambiguous. It also explicitly distinguishes itself from sibling tools: 'Not for reading what an error code means (use explain_error first) and not for product ideas (use manage_feedback).' This level of specificity ensures an agent can select this tool correctly.

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 precise triggers for use: 'when a call was refused or failed and the doorway said to file it, or to follow up.' It also names alternatives and exclusions, e.g., 'Not for reading what an error code means (use explain_error first).' This gives the agent a solid decision rule and eliminates ambiguity.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true, and destructiveHint=false味的说明 adds meaningful behavioral context: keys are masked, nothing is stored, no key is needed, and the operation is read-only. This goes beyond the annotation field values and helps the agent set expectations about side effects and privacy.

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?

Although lengthy, every sentence earns its place: purpose, scope, usage timing, exclusions, privacy, input format, and output shape. The structure front-loads the core purpose and then layers supporting details, so an agent can quickly extract the key facts.

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 complex enough that the description carries the full responsibility for explaining the return value, but it does so by enumerating the JSON fields. Combined with rich annotationscam和clear sibling routing, nothing essential for an agent to select or invoke this tool correctly is missing.

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

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

Schema description coverage is 100%, so the schema already fully documents the single `config` parameter, including type, meaning, and max length. The description mostly restates the schema content (pasting endpoint URLs, env lines, code, up to 20,000 characters) rather than adding new semantic insight.

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 purpose: a compatibility report for switching RPC providers, and details exactly what it produces (mapped endpoints, method weights/limits, changes list). It also explicitly distinguishes itself from get_quote / what_can_i_do / rpc_call, so an agent can tell it apart 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?

It says when to use it ('Use it before you swap URLs') and when not to, naming the alternative tools for pricing and calls. This gives explicit, actionable routing guidance with no ambiguity.

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

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

Annotations already declare readOnlyHint=true and idempotentHint=true, and the description adds complementary context: 'Read-only. No key needed.' It also discloses the exact return shape for both modes, which is valuable beyond the annotations. No contradiction exists.

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

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

The description is dense but tightly organized: purpose, mode breakdown, when-to-use, exclusions, return shapes, and auth note. Every sentence adds useful information and the key differentiator 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 no output schema and low schema coverage, the description does a strong job covering inputs, outputs, exclusions, and authentication. Minor gaps remain around the precise semantics of family/prefer/candidates, but the overall context is sufficient for an agent to select and call 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?

Schema description coverage is only 14%, so the description must compensate. It explains what='chain' vs what='route' and maps optional parameters to each mode (family, candidates, prefer for chain; chain, method, need for route). However, the meaning of 'family', 'prefer', and 'candidates' is left vague, and the schema itself provides no further help.

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 establishes what the tool does: it returns a recommendation from live measurements, with two explicitly distinguished modes ('chain' and 'route'). It names the resource and the ranked output, and it differentiates itself from siblings by saying what it is not for (price, gas, making calls).

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

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

The description gives explicit when-to-use guidance: 'Use it when you can choose the chain or the lane and want the measured answer.' It also provides direct exclusions and alternatives: not for price (get_quote), not for gas (get_prices), not for making the call (rpc_call).

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

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

Annotations already declare readOnlyHint, openWorldHint, idempotentHint, and destructiveHint=false. The description adds valuable context: reverse records are self-declared and must be forward-resolved before trusting, plus it mentions the API key requirement. This goes beyond the annotations by warning about a security consideration, which is critical for safe usage.

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 paragraph that front-loads the core purpose, then covers usage, exclusions, output format, and a caveat. Each sentence adds value, with no redundant fluff. It is slightly long but well-organized and efficient for the information conveyed.

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

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

With no output schema, the description fully explains the return JSON fields for both forward and reverse resolutions, addresses the trust caveat for reverse records, and mentions the API key requirement. For a single-parameter tool, it covers everything an agent needs to call it correctly and interpret results safely.

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 describes the 'query' parameter with 100% coverage ('ENS name or 0x-address'). The description reiterates the same information without adding new syntax or format details. It does explain the dual-direction behavior (forward vs reverse), but that is more about output than parameter semantics, so it doesn't elevate beyond the baseline 3.

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

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

States a specific verb ('resolve') and resource (ENS names on Ethereum mainnet), clarifies both forward and reverse directions, and explicitly distinguishes itself from other name systems and balances. This differentiates it from siblings like get_balances and other ENS-related tools, making its purpose 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?

Provides explicit when-to-use guidance ('Use it whenever a user gives you a .eth name instead of an address') and names the alternative for balances ('use get_balances with the resolved address'). It also excludes other name systems, leaving no ambiguity about scope.

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

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

Annotations already mark destructiveHint and idempotentHint, and the description adds valuable context: immediate revocation, irreversibility, auth requirement, and the JSON response shape. No contradiction with annotations; the extra detail goes well beyond the structured hints.

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

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

Four tight sentences, front-loaded with the core behavior and effect, followed by usage guidance, exclusions, and return format. Every sentence carries necessary information 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?

For a single-parameter tool with no output schema, the description covers return fields, id source, destructive consequences, idempotency, and authentication needs. An agent has everything required to invoke it correctly.

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

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

Schema coverage is 100% and the api_key_id parameter is described. The description adds meaningful guidance by stating ids come from list_api_keys and that the key is identified by id, which helps an agent know how to supply the parameter correctly.

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

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

States a specific verb and resource: revoke one API key by id, with an immediate effect. The description clearly distinguishes this from related tools like create_api_key, list_api_keys, and configure_key.

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 conditions for use: when a key leaked or a service is retired. It also names alternative behavior with configure_key for pausing, and warns against revoking the calling key without a backup, leaving no ambiguity.

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

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

Annotations provide only generic hints (not read-only, not idempotent, not destructive, open-world), so the description carries the behavioral burden. It discloses routing/failover/cache/metering behavior, return shapes for success and refusal (including request_id and doorway in error.data), unit metering rates, and API-key requirement. This goes well beyond annotation coverage.

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

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

The description is dense and front-loaded with the core action, then moves into usage guidance, exclusions, return format, and metering. Every sentence contributes; the only mild overhead is the reference to 'the same routing, failover, cache and meter as POST /rpc/{chain}', which assumes endpoint familiarity but still adds context.

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 low-level RPC passthrough with no output schema, the description covers inputs, return values, error behavior, billing impact, authentication need, and routing decisions among sibling tools. An agent can select and invoke this tool correctly without external documentation.

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%, but schema descriptions are terse ('Chain slug', 'JSON-RPC method'). The description adds the actual allowed chain values for `chain`, examples like 'eth_blockNumber' and 'eth_getBalance', and clarifies that `params` follows the method's expectations. This materially improves a caller's ability to supply valid arguments.

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

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

The description states a specific verb ('Send one JSON-RPC call') and a precise resource (the FlexYield gateway), then gives chain values, method examples, and the exact role of params. It also differentiates itself from shaped sibling tools by covering reads that they do not.

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

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

Use conditions are explicit: 'for any read the shaped tools do not cover' and 'for sending signed transactions.' Exclusions name specific siblings — get_balances, get_history, get_tx_status, get_quote — and the reason (shaped tools offer one call, decoded). This leaves little to inference.

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

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

Beyond the annotations (readOnly=false, idempotent=true, destructive=false), the description discloses the partial-update behavior, the conditional return payload (notification fields vs insights), and the API key requirement. These are meaningful behavioral details not present in the structured fields.

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: scope first, then usage condition, exclusions, return behavior, and auth. The long field enumeration is justified for an 11-parameter tool, and there is minimal filler.

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

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

With no output schema and 11 parameters, the description still covers when to use it, what changes, what does not change, excluded alternatives, conditional return values, and authentication. An agent has enough 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?

Schema description coverage is only 18%, so the description must compensate. It names all 11 parameters and groups them into notifications vs insights, which helps call selection. However, it does not explain acceptable values or deeper meaning for most fields beyond their self-evident names.

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: 'Update your account's preferences', then enumerates exactly which notification and insight fields are affected. It also names what the tool is not for, distinguishing it from configure_key and configure_services.

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 the trigger condition explicitly: 'Use it when the owner's preferences change', and clarifies partial-update semantics with 'only the fields you pass change'. Exclusions with alternative tools are spelled out for keys, services, and billing.

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

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

Annotations already declare readOnlyHint, idempotentHint, and destructiveHint. The description adds behavioral depth beyond these: explains mode-specific processing (parses fields, checks signature and expiry), states 'Recovery only — FlexYield never holds keys' for security reassurance, and notes 'Read-only' and API key requirement. This adds context without contradicting annotations.

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

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

The description is long but each sentence earns its place: it leads with the core purpose, then explains modes, gives usage and exclusions, details return values, and ends with security and requirements. It is dense but not verbose; no filler. Structure is logical 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 two distinct modes and no output schema, the description is thorough: it covers input semantics per mode, expected return fields, authentication needs, and explicitly scopes what the tool does NOT handle (binding, hashing, domain/nonce policy). All essential information for correct invocation is present.

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?

Despite 100% schema description coverage, the description enriches parameter meaning: it explains that mode 'personal' verifies an EIP-191 personal_sign signature, while 'siwe' verifies SIWE/EIP-4361, and clarifies the signature is 0x-hex 65-byte (r‖s‖v). It also specifies the address is optional in personal mode. This goes beyond the bare schema properties.

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

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

The description specifies the verb 'verify' and the resource 'signature' with two distinct modes (personal/SIWE), and explicitly contrasts with sibling tools: 'Not for binding or claiming keys... use bind_key_complete / claim_agent_complete' and 'not for hashing (use convert_evm)'. This unequivocally clarifies what the tool does and how it differs from related 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 gives direct usage guidance: 'Use it to authenticate a wallet-holder or validate a login message' and then lists exclusions with alternatives. It also notes 'domain and nonce policy stay with you,' indicating when the tool does not handle those aspects. This is explicit when-to-use and when-not-to-use guidance.

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

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

Annotations already declare read-only, idempotent, and non-destructive behavior, and the description reinforces this with 'Read-only; no parameters.' It adds substantial behavioral context by listing the returned JSON fields, explaining the 'doorway' concept, and noting the API key requirement. No contradiction exists.

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

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

The description is dense but every clause adds information, defining important domain terms like fences, doorways, and lanes. It is somewhat compressed into a long single sentence and could be more scannable with bullets, but it stays purposeful and front-loads the core purpose well.

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 there is no output schema, the description compensates by enumerating the returned fields. It covers invocation context, read-only behavior, credential needs, use cases, and exclusions — everything an agent needs to correctly select and call the tool.

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

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

The tool has zero parameters, so the input schema carries no burden. The description explicitly confirms 'no parameters' and clarifies that the relevant context is the API key itself, which is appropriately meaningful for a parameterless tool.

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 purpose: provide a status overview of the calling API key, covering budgets, limits, volume, and recommendation. It explicitly distinguishes itself from get_usage, get_billing_status, and get_quote, making the tool's unique role clear.

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

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

Usage guidance is explicit: use it first in a session and whenever a call is refused, to decide what to do next. It also names alternatives with the conditions where they should be used instead of this tool, leaving no ambiguity.

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