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

With no annotations, the description fully discloses behavior: explains irreversibility, account closure, rent reclaim, failure modes, and return values. Even includes advanced counter-burn defense strategy.

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?

Well-structured with clear sections, bullet points, and front-loaded main action. Every sentence is informative; no wasted words despite 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?

Given no output schema, the description covers return values, failure modes, irreversible nature, and advanced use. Provides a complete picture for an agent to use confidently.

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; description adds context by specifying that api_key must be from the wallet holding keys and that gameId is the round with held keys. Adds value beyond schema but not extensively.

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

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

The description clearly states the tool's purpose: burning one key to permanently boost share on remaining keys, explicitly mentioning the Anchor instruction and effect on dividend rate. It distinguishes from siblings like claim_dividend and place_bid.

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' section with mathematical reasoning and recommends use only when holding many keys. Lists failure modes and related tools, offering clear guidance on when not to use and 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?

No annotations provided, so description carries full burden. It details the action (invoke distribute), dividend calculation formula, return format with field names, and three failure modes with specific causes. Fully transparent about 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?

Well-structured with sections and bullet points, front-loaded with a clear summary. Could be slightly more concise (e.g., failure modes could be tighter), but still effective and easy to parse.

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

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

For a 2-param tool with no output schema or annotations, the description covers all aspects: purpose, usage guidelines, behavioral details, parameter semantics, failure modes, and distinctions from related tools. No gaps.

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

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

Schema coverage is 100%, but description adds valuable context: gameId is the round you hold keys on, api_key must be the wallet that holds the keys, and provides a reference to get_game to check yourKeys. This exceeds schema descriptions.

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

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

The description clearly states the tool withdraws accrued dividends from a specific round via the distribute instruction. It distinguishes from sibling claim_winnings by explaining the difference between per-key passive income and round-end pot.

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

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

Provides explicit guidance on when to use (any time post-bid, mid-round or after settle, suggests once per round after settle to minimize fees), who can call (agent with at least 1 key, api_key must match wallet), and differences from claim_winnings.

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

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

Despite no annotations, the description fully discloses behavioral traits: atomic distribution, marks gameOver=true, permissionless calling, and lists precise failure modes. No contradictions.

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?

Well-structured with clear sections (WHAT IT DOES, WHEN TO USE, etc.), front-loaded summary, and every sentence adds value despite 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?

Fully covers the tool's behavior, return fields (despite no output schema), failure modes, and relations to siblings, making it complete for a complex on-chain 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?

Input schema has 100% coverage with detailed descriptions; description adds meaningful context like expiry requirements and fee payer flexibility, going beyond schema basics.

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 'Settle a finished round and pay out the winner.' and elaborates on the on-chain instruction and fund distribution, distinguishing it from siblings like claim_dividend and get_game.

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 WHEN TO USE section specifying conditions (deadline passed, not gameOver), mentions autoclaim worker as alternative, and outlines failure modes for common errors.

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

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

Since no annotations are provided, the description fully covers behavioral aspects: it explains that it invokes an Anchor program, pays rent, makes the caller the creator, and details the pot splits. It also mentions that rent is refunded on settle. No contradictions.

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 with labeled sections (WHAT IT DOES, WHEN TO USE, DEFAULTS, RETURNS, RELATED) and is concise despite covering many details. Every part earns its place without redundancy.

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

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

Given 11 parameters and no output schema, the description explicitly states the return values (gameId, creator, tx, config) and provides context about related tools. It is complete for an agent to invoke correctly.

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

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

All 11 parameters have descriptions in the schema, and the description adds further meaning beyond defaults (e.g., 'Higher minBidRaw = fewer bids but bigger per-bid pot growth') and includes a critical constraint ('Splits MUST sum to 10000 bps').

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 'spawn' and clearly indicates it creates a new on-chain round. It also mentions that the caller becomes the creator, which distinguishes it from related tools like list_games and place_bid.

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

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

Explicitly states when to use ('when no live round suits your strategy, or when you want to earn a long-term creator share') and provides context about cost and defaults. It also references related tools (list_games, place_bid) to guide decision-making.

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

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

No annotations provided, but description discloses idempotent behavior, 404 for missing ids, and impact (stops POSTing events). Lacks discussion of authorization or reversibility beyond delete, but sufficient for most agents.

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?

Well-structured with sections (WHAT IT DOES, WHEN TO USE, RETURNS, RELATED). Every sentence adds value; no wasted words.

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

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

For a delete tool, covers purpose, usage, return format, and idempotency. With no output schema, the RETURNS section is valuable. Missing details on error scenarios beyond 404, but overall adequate.

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 schema already documents parameters. Description adds context for 'id' by referencing list_webhooks/register_webhook and notes 'api_key' can be from env, which adds slight value beyond schema.

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

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

Clearly states 'Unsubscribe one of the agent's webhooks by id' and 'deletes the subscription'. Distinguishes from siblings list_webhooks and register_webhook via explicit 'RELATED' section.

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?

Includes 'WHEN TO USE' with specific scenarios like rotating URLs, retiring agents, narrowing scope. Could be improved by adding explicit when-not-to-use, but current guidance is clear and helpful.

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

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

No annotations provided, so description must cover behavioral traits. It explicitly states 'Read-only, no auth required' and explains it fetches fresh state without a broker cache. This is sufficient for a safe read operation; no contradictions.

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

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

Description is concise with clear section headers. Every sentence adds value, and the most important info (purpose, usage, return fields) is front-loaded. No wasted text.

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

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

Despite no output schema, the description lists all return fields in detail. Combined with clear usage and behavior info, it provides a complete picture for a simple read tool. Siblings are mentioned appropriately.

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 one parameter gameId fully described. The description adds minimal value, only repeating the source of the ID. No additional semantics or constraints beyond schema.

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

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

Description starts with 'Read a single $fomox402 round's full on-chain state', clearly stating the verb and resource. It distinguishes itself from sibling tools like list_games (find ids) and place_bid, claim_winnings, claim_dividend, making the 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?

The 'WHEN TO USE' section provides specific scenarios: after place_bid to confirm, before claim_winnings, and when authoritative deadline needed. It also notes that list_games is stale. While it doesn't explicitly state when not to use, the positive guidance is clear and actionable.

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

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

With no annotations, the description carries full burden. It states 'Read-only — no on-chain side effects, no rate-limit cost' and explains the lookup and refresh process. It does not detail error cases but is transparent about core 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 structured with headings, bullet points, and clear sections. Every sentence adds value. It is concise yet comprehensive, with no redundant information.

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

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

Given no output schema, the description includes a full return structure. It also provides context on related tools. It is complete for a self-profile reader, covering purpose, usage, behavior, and return format.

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 parameter api_key is described in schema. The description adds context: 'Optional if FOMOX402_API_KEY env var is set.' This goes beyond the schema, providing useful guidance on when the parameter is needed.

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

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

The description clearly states 'Read the calling agent's profile + live on-chain balances.' The verb 'Read' and resource are specific. It distinguishes from siblings like register_agent and topup by explicitly noting it is read-only and has no side effects.

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 use cases: 'before every bid loop, before topup decisions, and after register_agent to verify the faucet drip arrived.' It also mentions cost (cheap). It could be improved by stating when not to use, but the guidance is strong.

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

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

With no annotations, description declares read-only, no auth, no side effects, and provides return fields. Also discloses visibility limitation regarding local stdio clients.

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?

Well-structured with labeled sections, but slightly verbose. Every sentence contributes, though 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?

Provides return structure, use cases, related tools, and important caveats. No output schema, but description fully compensates.

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

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

No parameters in schema; description adds value by explaining the data sources and caveats, meeting the baseline for zero-parameter tools.

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

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

The description states it returns aggregated MCP traffic and per-tool call telemetry as a public observability snapshot. It distinguishes from siblings by naming specific related tools and their scopes.

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 recommends use for dashboards, health checks, and verifying broker aliveness. Mentions related tools and a visibility caveat, though no explicit when-not-to-use guidance.

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

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

Description discloses that the tool is read-only, requires no auth, is safe to call frequently, and is cached server-side for 30 seconds. This goes beyond the lack of annotations, providing critical behavioral context.

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

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

Description is well-structured with clear sections (WHAT IT DOES, WHEN TO USE, PARAMS, RETURNS, RELATED). Every sentence is purposeful and concise, no redundant information.

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

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

Despite no output schema, the description details the return format with field names and types. It covers caching, auth, usage scenarios, and parameter details, making the tool fully understandable 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 100%, and the description adds meaning beyond the schema: it explains the default values and the interpretation of each sort option (e.g., 'bids' as activity proxy, 'won' as skill proxy).

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

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

Description clearly states it returns the top broker-registered agents by activity, with a specific verb ('returns') and resource ('public leaderboard of fomox402 agents'). It distinguishes from siblings by listing related tools like get_me and list_games.

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?

WHEN TO USE section provides explicit scenarios: scout opponents before bidding, find a name to follow, or measure standing. Related tools are mentioned, guiding the agent to alternatives when 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?

With no annotations provided, the description fully covers behavioral traits: 'Read-only, no auth required, cached ~5s server-side.' It also describes the return format and strategy hints, ensuring transparency.

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

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

The description is well-structured with clear sections: WHAT IT DOES, WHEN TO USE, PARAMS, RETURNS, STRATEGY HINT, RELATED. Every sentence adds value, and the length is appropriate for the complexity.

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

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

Despite no output schema, the description provides a detailed return structure. It also covers caching, auth, usage strategy, and sibling tools. For a list tool with one parameter, this is fully complete.

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

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

The single parameter 'warmup' has a schema description, but the tool description adds actionable context: 'Include pre-first-bid rounds... Useful for sniping cheap first bids; otherwise filter them out.' This enhances understanding 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 begins with 'List active and recently-settled $fomox402 game rounds,' which clearly specifies the verb 'list' and resource 'game rounds'. It distinguishes from siblings by stating 'Prefer over get_game when you don't already know the gameId.'

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

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

The description explicitly instructs 'WHEN TO USE: every poll cycle in autonomous mode, or whenever the agent needs to choose a round. Prefer over get_game when you don't already know the gameId.' This provides clear context and 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?

No annotations provided, so description carries full burden. States 'Read-only, no side effects' and mentions secret values are not returned. Could add more on error handling, but adequately transparent.

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

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

Structured with clear sections (WHAT IT DOES, WHEN TO USE, RETURNS, RELATED). Informative without being verbose, though slightly longer than necessary.

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?

Provides sample return format, field descriptions, and what is not returned. No output schema, but description compensates. Lacks pagination or error details, but sufficient for a list tool.

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

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

Schema coverage is 100% for the single parameter api_key, which already has a description. The tool description adds no further parameter details, meeting 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 clearly states 'List the agent's active webhook subscriptions' and explains what it returns. It distinguishes from sibling tools like register_webhook and delete_webhook.

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 when to use (audit subscriptions, find id for deletion) and mentions related tools. Lacks explicit when-not-to-use, but context is sufficient.

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

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

With no annotations, the description fully discloses behavior: details the 3-leg x402 micropayment dance, lists 4 failure modes with specific error names, describes the return object with all fields, and notes that each bid mints a key. This is comprehensive transparency.

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

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

Well-structured with clear section headers (WHAT IT DOES, WHEN TO USE, FEES, FAILURE MODES, RETURNS, etc.). Information is front-loaded. However, the description is long; some sentences could be tightened without losing clarity.

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, no output schema, and 3 parameters, the description is remarkably complete: it explains return values, failure modes, fees, side effects (minting keys), and relationships to sibling tools. Everything an agent needs to invoke correctly is covered.

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

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

Schema coverage is 100%, but the description adds value beyond schema: for amountRaw, it explains the rationale for using 'effective_min + 1' in loops and clarifies atomic units. For gameId, it repeats schema info but adds context. The api_key parameter is straightforward. Overall, adds meaningful nuance.

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

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

The description clearly states the tool's purpose: 'Place a $fomox402 bid on a game round.' It uses a specific verb ('Place') and resource ('bid on a game round'), and distinguishes from sibling tools by mentioning related tools like list_games and play.

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 'WHEN TO USE' section says 'any time you want to be the head bidder.' It provides clear prerequisites: get gameId from list_games and set amountRaw ≥ effective_min. It also lists related tools for alternatives, fulfilling the when-to-use vs. when-not-to criteria.

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

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

No annotations provided, but the description fully details the step-by-step behavior including balance checks, auto-topup, filtering games, bidding logic, error handling, and rate-limit swallowing, providing all necessary behavioral context.

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

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

The description is well-structured with bold headers and front-loaded purpose, but is somewhat long. Every section adds value, though minor trimming could improve conciseness.

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

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

Given no output schema, the description completely explains the return format, possible statuses, and error cases. It also relates to sibling tools, making it fully complete for an agent to decide to use this tool.

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

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

Schema coverage is 100% with clear parameter descriptions. The tool description references parameters in context but does not add significant new semantics beyond what the schema provides, meeting the baseline of 3.

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

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

The description clearly states the tool is a 'One-shot autonomous playbook' that collapses multiple steps into a single call, providing a specific verb+resource ('play') and distinguishing it from siblings by mentioning they are for fine-grained control.

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 'WHEN TO USE' section explicitly says it is for recurring agent loops, and 'RELATED' lists alternatives for fine-grained control, giving clear guidance on when to use this tool vs. siblings.

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

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

Despite no annotations, the description fully discloses side effects (on-chain funding, off-chain leaderboard appearance), idempotency, and the one-time visibility of the API key. No contradictions.

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 with sections, front-loaded with purpose, and uses concise bullet-like formatting. Every sentence adds value.

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

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

Given no output schema and no annotations, the description is remarkably complete: it details return fields, advises saving the API key immediately, and explains side effects. Little is left ambiguous.

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

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

The single parameter 'name' already has a thorough schema description (100% coverage). The description adds context about leaderboard display and idempotency, going slightly beyond the schema.

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

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

The description clearly states it mints a new agent identity, provisions a wallet and API key, registers in leaderboard, and triggers a faucet drip. This distinguishes it from siblings like get_me, topup, and withdraw.

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 'Always the FIRST tool you call' and 'once per agent identity,' with idempotency details. It lists related tools but does not explicitly state when not to use, though the context implies one-time use.

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

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

Despite no annotations, the description fully discloses behavior: returns a secret for signature verification, URL constraints (HTTPS, SSRF allowlist), event list, body size, and return structure.

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?

Well-structured with clear sections but slightly verbose; every section adds value, so it earns its 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?

Without an output schema, the description provides a complete return structure, event details, and usage context, making it sufficient for an agent to use correctly.

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

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

Schema coverage is 100%, so baseline 3. The description adds meaning by detailing events, URL constraints, and return fields, going beyond schema descriptions.

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

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

The description clearly states the tool subscribes a URL to receive HMAC-signed event POSTs, and distinguishes from siblings like list_webhooks and delete_webhook.

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 'WHEN TO USE' section advises long-lived agents to use this over polling list_games, and tells stateless agents to poll instead. Also mentions related tools.

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

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

Discloses atomic transaction details, rate limits (6h cooldown, 10 lifetime), failure modes, and return fields, compensating for lack of annotations.

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

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

Well-structured with labeled sections, front-loaded main action, no redundant sentences, and every section provides value.

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

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

Covers purpose, usage, behavior, limits, failures, and related tools fully, leaving no gaps despite lack of output schema.

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

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

Schema coverage is 100% with a clear description for api_key; description does not add extra meaning but also does not detract.

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

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

Description states the tool triggers a faucet drip for SOL and $fomox402, clearly distinguishing from siblings like get_me, withdraw, and play which are mentioned in the RELATED section.

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 (when balances are low) and notes that play calls this automatically, providing clear context for when not to call directly.

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

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

With no annotations, the description carries full behavioral transparency. It details that it builds and signs a Solana transfer, that the broker submits the tx, the return format (signature), authority model (api_key risk), failure modes (three specific errors), and special behavior like keeping a 5000-lamport reserve for SOL. This is comprehensive.

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

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

The description is well-structured with sections (WHAT IT DOES, WHEN TO USE, etc.) and front-loaded with a one-line summary. Every sentence adds value, though the length is slightly more than minimal. The structure aids readability.

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

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

Given the complexity (4 parameters, no output schema, no annotations), the description covers all necessary aspects: purpose, usage, parameter details, return format, failure modes, and related tools. It leaves no gaps for an agent to misinterpret.

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 significant context: for 'asset' it explains 'sol' vs mint pubkey and the 'fomo' alias; for 'amountRaw' it clarifies 'all' behavior and reserve; for 'to' it mentions automatic ATA derivation for SPL. This enriches the schema descriptions.

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

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

The description clearly states the tool's purpose: 'Sweep funds out of the calling agent's Privy wallet to any address.' It uses a specific verb ('sweep') and resource, and distinguishes from siblings like 'topup' (opposite) and 'get_me' (balance check). Explicit usage scenarios (retiring agent, cashing out, routing) further clarify purpose.

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

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

The description includes a dedicated 'WHEN TO USE' section with three bullet points (retiring an agent, cashing out, routing tokens). It also mentions related tools ('get_me' for checking balances, 'topup' for bringing funds in), providing clear guidance on when to use this tool vs alternatives.

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