PumpPill — token safety and measured outcomes

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

Annotations already declare destructive/non-idempotent/open-world, and the description substantially adds: auth header format, the pre-trade safety read and refusal policy (HIGH/CRITICAL, unread, thin reads), member-level limits, the write-before-place ordering, and the real-money warning. This is rich behavioral context well beyond 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?

Front-loaded with the core action and funding source, then layers prerequisites, refusal behavior, and the money warning. Dense but each sentence carries operational meaning; only the nested clause about refusal conditions is a touch heavy.

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 destructive, no-output-schema trading tool, the description covers auth, safety gating, limits, order-result polling, and the real-money caution, so an agent can act correctly. The unexplained 'again' parameter is the main remaining gap.

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

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

Schema description coverage is 0% and the schema itself provides no titles beyond single words. The description implies address=token and eth=size but never says so explicitly, and the 'again' parameter is entirely unexplained in both schema and description. With three undocumented parameters, the description fails to compensate for the coverage gap.

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

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

States a specific verb+resource+funding source: 'Buy a Robinhood Chain token with ETH from the member's PumpPill trade bot wallet.' It is clearly distinct from the sibling agent_sell and names the chain and wallet context an agent needs to route 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?

Gives concrete prerequisites (the X-Agent-Key credential and where to obtain it), states the refusal conditions that gate the call, and routes the agent to 'poll agent_order for the result.' It stops short of explicitly contrasting with agent_sell or specifying when not to use this tool, so it is clear context without full exclusions.

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

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

Annotations already declare read-only, idempotent, non-destructive behavior; the description adds valuable context by enumerating the possible state outcomes (filed, running, done with transaction, failed/refused with reason, skipped) and the required X-Agent-Key authentication. This goes beyond structured annotations, though it does not mention rate limits or idempotency explicitly.

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-loads the tool's purpose and return states. The second sentence on authentication is somewhat dense but still earns its place by providing necessary access details.

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

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

For a simple read-only tool with rich annotations and no output schema, the description adequately covers output states and authentication. However, it omits any explanation of the order_id parameter, leaving a key invocation detail unaddressed.

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

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

Schema description coverage is 0%, and the description never mentions the order_id parameter or what it represents. With one undocumented parameter, the description fails to compensate for the schema gap.

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

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

The description clearly states it returns the state of one order filed by agent_buy or agent_sell, enumerating possible states. It distinguishes from the sibling action tools but does not explicitly contrast with agent_status, so it is clear but lacks sibling differentiation.

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

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

It implies the tool is used to check an order's status and states a prerequisite (needs the member's agent key). However, it does not say when to use this versus alternatives like agent_status, and there are no explicit exclusions.

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

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

Annotations already declare destructiveHint=true, non-idempotent and open-world, so the risk profile is covered. The description adds real value beyond them: the auth key format and where to obtain it, that the order is recorded before placement, and the instruction to confirm with the member because real money moves. The phrase 'a sell is never refused for the token's read' is cryptic but hints at no pre-trade safety gate.

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?

Content is front-loaded with purpose first, then prerequisites, behavior, and safety. It is slightly dense and one clause ('never refused for the token's read') is ambiguous filler, but each sentence largely earns its place.

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

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

With no output schema, the description correctly redirects the agent to agent_order to retrieve the result, and it covers auth, irreversibility context, and human confirmation for a real-money mutation. Only the address parameter's meaning is left unexplained.

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

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

Schema description coverage is 0%, so the description must carry both parameters. It explains pct well (percent of holding, 1-100), but the address parameter is never mentioned or disambiguated, leaving half the input undocumented.

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 first sentence gives a specific verb (sell), resource (Robinhood Chain token held in the member's wallet), and scope (part or all, as percent of holding 1-100). This cleanly separates it from the sibling agent_buy without needing to open either 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 the prerequisite (agent key from PumpPill's Telegram bot), the required human-in-the-loop step (confirm with the member first), and the follow-up (poll agent_order for the result). It does not name an explicit condition for choosing this over agent_buy, but the buy/sell split is self-evident from the purpose.

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, openWorldHint, and destructiveHint=false, so the safety profile is covered. The description still adds genuine context beyond them: the required X-Agent-Key header, its ppa_ format, and where to create it. It does not cover failure modes or rate limits, so it is strong but not exhaustive.

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

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

It front-loads the returned fields, then usage timing, then the auth prerequisite, which is a sensible order. The first sentence is dense with comma-separated clauses but each clause names real returned data, so nothing is wasted.

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 carries the return-value burden and does so by listing the reported fields plus auth and invocation timing. It leaves out error/pagination behavior, but for a read-only status probe the description is enough 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?

With zero declared parameters the baseline is 4, and the description actually adds value the schema cannot carry: the required X-Agent-Key header authentication credential. No argument syntax or formats are needed for an empty-argument 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 enumerates exactly what the tool reports: agent on/off state, wallet ETH, agent limits and today's remainder, red-flag refusal, and the last five orders. That is a specific resource with a concrete payload, distinct from the sibling membership_status, so an agent can pick it without opening 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?

Explicit timing guidance is given: 'Call it before a first trade and after any error.' It also states the precondition (member's agent key) and where to obtain it, which is precisely what an agent needs to know before invocation.

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, indicating safe, non-mutating behavior. The description adds useful context: it's cache-only, open to everyone, and that unknown fields are null rather than guessed. It also warns about the meaning of have_record=false, which is beyond the annotations. However, it doesn't elaborate on response structure or potential rate limits, but the annotations cover the safety profile.

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

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

The description is two sentences, highly concise, and front-loads the core purpose and key behaviors. Every sentence adds value: the first details what facts are checked, the second clarifies open/cache-only and introduces the have_record warning. No fluff or 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 the tool's moderate complexity (one parameter, no output schema), the description is largely complete. It covers what the tool checks, the safety profile (via annotations), and the cache-only behavior. The only minor gap is the absence of explicit return value description, but since there's no output schema, a brief note on response format could be beneficial. However, the 'Facts, not advice' line and the have_record clarification add necessary context.

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

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

The schema has one parameter (address) with 0% description coverage, so the schema provides no semantics. The description doesn't explicitly mention the 'address' parameter, but it's implied by 'token' context and the tool's purpose. It doesn't explain the format of the address (e.g., Solana vs Ethereum) or provide additional meaning beyond 'the token address.' Since there's only one parameter, the description partially compensates, but a bit more specificity would 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 states what the tool does: checks if a token can be sold and what the deployer can still do (mint/freeze authority, dev share, liquidity position). It uses a specific verb ('check') and resource ('token'), and the title reinforces the purpose. It could be slightly more explicit about the 'exit_check' name, but overall it distinguishes itself from other tools by focusing on exit/liquidity and dev 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 description implies usage—'Open to everyone, cache-only'—and sets expectations for when to use it, but it doesn't explicitly state when NOT to use it or name alternative tools. It mentions 'have_record=false means no read, not safe,' which is a form of guidance but somewhat cryptic. It could benefit from clarifying that this is for token safety checks versus general token info (like sol_token_detail).

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

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

Annotations already declare readOnly/idempotent/non-destructive/openWorld, so the safety profile is covered. The description adds genuinely useful behavior: no side effects ('never triggers a scan') and error behavior ('a missing read says so'). It does not discuss auth requirements, rate limits, or failure modes beyond the missing-read case.

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 dense sentences, front-loaded with the id-source constraint, then return shapes, then side-effect/error guarantees. No filler and every clause carries information an agent needs.

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 describing the return payloads for both id families (stored read text + citation + as-of time; lesson text + optional transcript). Combined with the annotation coverage and the missing-read note, nothing essential is missing 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 0% and the single 'id' parameter has no schema-level documentation, so the description carries the full burden — and it does, spelling out the three id namespaces and their value formats (address, mint, slug). This is meaning that cannot be recovered from 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?

States a specific verb (fetch) and resource (one result) and immediately ties it to the sibling 'search' as the id source, with concrete id formats (rh:<address>, sol:<mint>, learn:<slug>). An agent can distinguish this from search and from the rh_* scan/detail tools without opening 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?

The description says the id must come from search and that the call 'never triggers a scan', which implicitly routes scanning to a different tool (rh_scan_now). It gives clear context for use but does not name the alternative tool explicitly or state when-not-to-use beyond the scan note.

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

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

Annotations already declare readOnly/idempotent/openWorld, so the bar is lower, and the description adds real context beyond them: the default thresholds, the data-limitation warnings (large buys only, FOMO users only, no trade sizes), and the interpretation of pumppill_read including that 'none stored' is a gap rather than a clean result. It stops short of stating auth/rate-limit behavior, which keeps it off a 5.

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 dense sentences with no filler; the core concept is front-loaded and caveats follow. It is long but each sentence adds information (scope, output shape, limitations), so the size is defensible even if slightly heavy.

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 does the work of explaining the return shape (latest/first buy, market caps, how many traders still in, pumppill_read per token), which is what an agent needs. For a parameterized read query with annotations covering safety, the only real gap is the unexplained limit parameter.

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

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

Schema description coverage is 0%, so the description must carry parameter meaning. It partially does: 'default 3 traders in 60 minutes' pins min_traders and window_minutes defaults, and 'Robinhood Chain and Solana' hints at the chain values. However, 'limit' is never mentioned and the chain value syntax (free string vs enum) is left ambiguous.

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

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

The description names a specific resource (tokens bought by several distinct FOMO traders inside a window) and scopes it to two chains, so the agent can tell what it returns without opening the schema. It does not name or contrast any sibling (e.g. fomo_trader, whats_moving), so the differentiation is implicit rather than explicit.

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

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

Usage is implied by the description of what the data is (tokens multiple traders are converging on), but there is no explicit 'use this when' or 'prefer X instead' guidance against the 25 sibling tools. The caveat about FOMO's large-buys-only feed hints at when the data is appropriate, but the agent must infer it.

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

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

Annotations cover the safety profile (readOnly, idempotent, non-destructive), and the description adds real behavior beyond them: large trades only, no sizes, the 15-buy scoring threshold, the PumpPill wallet matching, and the critical found=false vs inactive distinction with a data start date. It stops short of 5 only because return shape/pagination is not characterized.

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?

It is a single dense run-on sentence stuffed with semicolon-separated clauses. The purpose is front-loaded, but the operationally critical found=false and large-trades-only caveats are buried at the tail, hurting scannability.

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

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

There is no output schema, so the description must carry the return semantics – and it does, enumerating buys with market cap, sells with realized profit, tokens touched, scored records, and the Robinhood Chain wallet. The found=false/data-start note closes the biggest ambiguity; only paging or volume limits are left open.

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

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

Schema coverage is 0% and the single 'handle' property carries no description, so the description must compensate. It does clarify the handle is a FOMO name, but it adds no format, casing, or lookup-failure detail beyond that single phrase.

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 opening sentence states a specific verb+resource: what one FOMO trader did in the last 7 days, keyed by FOMO name. It is clearly distinct from chain-oriented siblings like rh_wallet_record or sol_early_wallets, but it never explicitly names or contrasts an alternative, so it falls short of a 5.

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

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

Usage is implied by 'one trader ... by FOMO name' and the found=false note explains how to read absence of data, but there is no explicit when-to-use versus alternatives (e.g., a chain-level wallet record tool). The data start date is helpful context but not 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?

Beyond the annotations (readOnly, idempotent, etc.), the description discloses that unauthenticated calls return signed_in=false instead of an error, and that the claim itself is not returned. This adds meaningful behavioral context 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?

The description is two concise sentences that front-load the core purpose, then add an edge-case behavior. No wasted words; 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 tool with no parameters and no output schema, the description fully covers what an agent needs: the result (active status, tier, renewal), the unauthenticated behavior, and the explicit limitation of what is not returned. 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?

With zero parameters, the schema is trivially covered. The description explains what the tool returns based on the client's claim, effectively substituting for parameter documentation. It meets the baseline for a no-parameter 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 the tool's function: it determines whether the claim is an active PumpPill membership, its tier, and renewal date. It also specifies what it does not return, distinguishing it from potential claim-inspection tools. With no sibling tool for membership status, it is unambiguous.

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

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

The description implies usage for checking membership status but does not explicitly state when to use it versus alternatives, nor does it mention exclusions. The unauthenticated behavior hint provides some context, but no explicit routing guidance is given.

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

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

Annotations already cover readOnly/idempotent/non-destructive, and the description adds substantive semantics beyond them: capital is size not correctness, a rate is never shipped without its denominator, no activity means not observed moving rather than quiet, sell sizes are floors. It also discloses the auth/payment model. Missing only return shape or window/pagination 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?

Front-loads the resource and return fields, which is good, but the back half compresses four distinct caveats into clipped clauses that read as dense shorthand. Every clause is informative, yet the packaging costs readability without saving much 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?

No output schema exists, and the description does enumerate the returned fields and their interpretive caveats, so an agent knows what comes back and how to read it. The weak spot is the unexplained 'days' parameter, otherwise this is complete for a read-only listing tool.

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

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

Schema description coverage is 0% for the single parameter 'days' (default 7), and the description only alludes to 'the window' without ever stating that a window length parameter exists, its unit, or its default. It fails to compensate for the schema gap, so the agent must infer 'days' from the schema name 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?

Names a specific resource (the Robinhood Chain wallets this member follows) and enumerates the returned facets: capital, record, activity in the window, fired events. An agent can distinguish this from rh_wallet_record or rh_whale_wallets without opening anything else.

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?

States the access prerequisites clearly (PumpPill membership via Bearer claim, or one x402 USDC-on-Base payment per call), which is real usage context. However it never says when to prefer this over the sibling inventory tools (rh_wallet_record, rh_whale_wallets, membership_status), so the routing guidance is only implied.

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, and the description adds substantial behavioral detail beyond them: entry is captured at the moment of logging and never backfilled, losers remain in the denominator, and results are recomputed hourly with possible 45s latency or error='recomputing' followed by instant retries. This equips agents to handle transient failures and interpret results correctly.

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

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

The description consists of three purposeful sentences: the first front-loads the core purpose, the second adds critical methodological caveats (entry timing, denominator), and the third covers recompute timing and error behavior. Every sentence contributes unique, actionable 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 zero-parameter read-only tool with no output schema, the description thoroughly explains what the returned outcome shares represent, clarifies the population vs. track-record interpretation, and covers the recompute delay and error case. It addresses likely agent questions about interpretation and handling transient failures, leaving no material gaps.

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

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

The tool has zero parameters and the schema coverage is 100%, so the baseline of 4 applies. The description naturally doesn't need to elaborate on parameters, and it effectively communicates that the tool requires no inputs, making any further detail unnecessary.

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 measures forward outcomes for PumpPill-logged tokens across both chains, specifying the exact thresholds (doubled, 5x, 10x, never moved) and clarifying the entry price definition. It distinguishes itself from a 'track record' and is distinct from all sibling tools, none of which describe outcome measurement.

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

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

The description provides clear context for when to use: to get population-level outcomes across both chains, not individual track records. It also discloses recompute timing, which guides when to call or retry, but it does not explicitly name alternative tools or provide comprehensive when-not-to-use guidance beyond the track-record exclusion.

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?

Goes well past the annotations by disclosing the exact auth mechanics (Bearer claim from pumppill.org/premium, or one x402 USDC-on-Base payment per call), the semantics of the attention filter, and that narrative/trend columns are deliberately withheld. This is the kind of context annotations cannot carry.

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?

Front-loads the resource and contents, then layers access and filter caveats. Dense but every clause carries information; no filler sentences.

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 still sketches the row contents (market cap at logging, move since) and explicitly names withheld columns, plus the access model. The remaining gap is the unexplained hours/limit parameters.

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

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

Schema description coverage is 0% and neither of the two parameters (hours, limit) is explained in the description. The defaults (24, 25) are inferable only from the schema, but the meaning and interaction of the time window and result cap are left undocumented.

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 resource (the premium call table), the exact contents (Solana tokens PumpPill logged for members, newest first, with market cap at logging and move since), and the audience. It is clearly distinguishable from siblings like sol_token_detail or rh_flagged_recent.

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?

Implies usage via the 'MEMBERS' framing and the paywall, but never states when to reach for this over outcomes_measured, exit_check, or the rh_*/sol_* scanners. The access condition is given; the selection condition against alternatives is not.

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 the safety profile (readOnlyHint=true, destructiveHint=false), so the bar is lower. The description adds genuinely useful behavioral context beyond annotations: the hourly recomputation cadence, a staleness warning (quote computed_at, not request time), and the interpretation caveat that these are counts rather than a success rate. This is real value-add with no contradiction to the readOnly/destructive 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?

A single dense paragraph that front-loads the core purpose and packs provenance, cadence, metric list, staleness warning, and interpretation caveats without redundancy. It is efficient but slightly run-on; separating the staleness warning into its own sentence would improve scannability marginally.

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 carries the burden of explaining returns, and it largely does: it enumerates the metrics, clarifies that these are counts not rates, and warns about data freshness. It could specify the response format or the computed_at value's format, but the substance an agent needs to interpret results 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?

There are zero parameters, so the empty schema (trivially 100% covered) leaves nothing to document. The description instead explains the data semantics of what the tool returns — the metric set and the market-cap-at-logging entry definition — which is the relevant semantic content for a 0-param tool. Baseline 4 is warranted.

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 resource (Robinhood Chain statistics) and provenance (PumpPill's index), enumerating concrete metrics: tokens seen, forward-measured outcomes, doubled/5x/10x/$100K crossings, stock-quoted counts. This identifies it as the aggregate stats tool among siblings like rh_scan_now or rh_flagged_recent, though it never names a differentiating sibling explicitly.

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 offers interpretive guidance — 'Counts, not a success rate', 'entry is the market cap at logging', and 'Quote computed_at, not the time you asked' — which helps an agent use the results correctly. However, it never states when to prefer this tool over overlapping siblings such as rh_scan_now or outcomes_measured, so no explicit when/when-not routing exists.

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 readOnly/idempotent annotations, the description discloses important result behavior: no record for factory/relayer wallets above the launch ceiling, no record for single-launch wallets, no success rate computation, and rows containing only crossed events. This is exactly the kind of non-obvious behavior an agent needs.

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

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

Three sentences in a logical order: what the tool returns, when it returns nothing, and the calculation caveat. Every sentence adds distinct, non-obvious information and the description is appropriately sized for a single-parameter lookup.

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 gives a reasonable picture of the return rows and the key filters. It does not fully specify the output shape or field formats, and the term 'liveness' is not defined, but for a one-parameter query the description is largely complete.

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

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

With 0% schema description coverage, the description carries the burden for parameter meaning. It implies that `address` is a Robinhood Chain wallet address, but it never explicitly states the expected format, checksum requirements, or that the address must be a deployer wallet. This is minimally sufficient but leaves room for misinterpretation.

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 (one Robinhood Chain wallet's launched tokens) and the kind of data returned (tokens, liveness, liquidity, $100K crosses). It is specific but stops short of naming a contrasting sibling tool, so it gets a 4 rather than a 5.

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

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

The usage context is implied rather than explicit: an agent can tell it is for deployer history of a single Robinhood Chain wallet, and the exclusion conditions (factory/relayer wallets above ceiling, single launches) describe when no record exists. No alternative tools are mentioned, so there is no explicit when-to-use/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 readOnlyHint, idempotentHint and destructiveHint=false, so the safety profile is covered. The description adds genuinely new behavior: the base rate (meta.early_base_rate) accompanies every rate, records are timing facts rather than forecasts, and wallets can vanish from the feed for spraying, underperforming, or silence. The last point is important because it tells the agent the list is dynamic and not a stable set.

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

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

Three sentences, front-loaded with the selection criteria, then the interpretation rule, then the removal policy. Dense but each sentence carries distinct information; there is 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?

No output schema exists, so the description should carry the return-shape burden; it usefully names the meta.early_base_rate field but says nothing about record fields beyond the rate. Combined with two unexplained parameters, an agent can invoke it but cannot predict the payload well.

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

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

Schema description coverage is 0% and neither 'limit' nor 'window' is explained in the description; 'early window' hints at a time concept but never ties it to the window parameter or its '30d' default, nor does it state that limit caps rows. With two undocumented parameters the description fails to compensate.

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

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

The description states a specific resource and a non-trivial selection criterion: Robinhood Chain wallets whose first buy fell in the early window of tokens that later crossed $100K. That is far more than a restatement of the name. It does not, however, explicitly distinguish itself from siblings like sol_early_wallets or rh_whale_wallets, so an agent must infer the chain/behavior boundary.

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

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

There is no when-to-use guidance and no named alternative; the description never says to prefer this over rh_wallet_record or sol_early_wallets. The interpretive rule ('quote a wallet's rate only with the base rate') is about reading results, not about selecting the tool, so it doesn't satisfy this dimension.

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 and idempotentHint, and the description adds that findings are evidence-based, not accusations, and that it reflects recent scans. This complements the annotations without 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?

Two concise sentences, with the core definition front-loaded and the caveat placed at the end. No fluff.

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

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

For a simple read-only list tool with one optional parameter and no output schema, the description covers the nature of results, the time window, and the intended interpretation. It lacks only an explanation of the limit parameter's effect, which is a minor gap.

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

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

The description does not mention the 'limit' parameter, which has no schema description (0% coverage). The agent is left to infer its meaning from the default value, so the description fails to compensate for the missing schema documentation.

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

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

The description clearly states the tool returns tokens with HIGH or CRITICAL structural risk from scans in the last 30 days, with findings named. It explicitly distinguishes itself from price verdicts and trade lists, making it distinct from siblings like rh_token_safety.

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 explains the purpose is to show the current wave of bad launches and explicitly warns against using it as a trade list, giving clear context on when it's appropriate. It doesn't name alternative tools but provides solid situational 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 cover only the safety/idempotency profile; the description layers on auth requirements (Bearer membership claim or x402 USDC payment on Base), latency and retry guidance (10-20s cold, do not retry), per-member/per-day caps, refusal semantics naming the cap and its 00:00 UTC reset, and caching behavior. This is exactly the operational context the structured fields cannot express, and it is consistent with idempotentHint=false.

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?

Front-loaded with the member designation and the core action, then layered with auth, cost, latency, and cap caveats in compact clauses. Dense but nearly every sentence carries an operational constraint; slightly long for a one-parameter tool.

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

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

For a slow, metered, paid read with no output schema, the description covers everything an agent needs: authorization options, time cost, retry policy, quota mechanics, refusal shape, and cache short-circuit. No meaningful gap remains.

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

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

There is one parameter at 0% schema description coverage, and the description never explains its format or how it resolves (e.g., checksummed address vs. ticker). It only implies 'one contract' is passed. The implied meaning is adequate to call the tool but adds little beyond the schema field name.

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

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

States a specific verb and resource ('read one Robinhood Chain contract FRESH') and scopes it against the sibling trigger ('when rh_token_safety said found=false or the stored read is stale'). An agent can distinguish this from rh_chain_stats or rh_token_safety without opening any 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?

Gives both when-to-use (after rh_token_safety returns found=false, or when the stored read is stale) and an implicit when-not ('a read from the last few minutes is served from the store without spending'), which tells the agent to skip the call entirely. The alternative path is named explicitly.

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, destructiveHint=false, so the safety profile is covered. The description adds behavioral context: it returns 'unflagged tokens' with 'liquidity and latest scan risk', and notes the pairing is unique to Robinhood Chain. It doesn't describe pagination or output format, but with annotations covering safety, this is adequate.

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

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

Three sentences with no waste. The primary usage is front-loaded, the optional behavior is explained, and the unique-chain note is a single clause. Every sentence earns its place.

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

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

For a single-optional-parameter read-only tool with no output schema, the description covers the key decision (pass vs omit stock) and the return content (unflagged tokens, liquidity, risk, counts). It doesn't describe output structure, but with no output schema and simple return semantics, this is a minor gap.

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

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

Schema description coverage is 0%, so the description must compensate. It does: it explains the 'stock' parameter accepts a symbol like NVDA, SPY, TSLA, and that omitting it returns every stock with a count. This adds meaning beyond the bare schema, though it doesn't specify exact format or validation rules.

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

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

The description clearly states the tool's function: it lists memecoins quoted in tokenized stocks on Robinhood Chain, with a specific verb ('Pass a stock symbol') and resource ('tokens quoted in it'). It distinguishes itself from siblings by noting this pairing exists on no other chain, and the optional parameter behavior is explicitly described.

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

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

The description provides clear usage context: pass a stock symbol for trading, unflagged tokens with liquidity and risk; omit it for every stock with a count. It doesn't explicitly name alternative tools or when-not-to-use, but the context is clear enough for an agent to decide when to invoke it.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true, and destructiveHint=false, so the safety profile is covered. The description adds meaningful behavioral context: the filtering criteria (alive, $10K+ pool, not flagged HIGH/CRITICAL), the fact that other contracts come back as a count, and the interpretation of found=false. This goes beyond the annotations and helps the agent understand expected outcomes.

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

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

The description is two sentences, front-loaded with the core purpose and criteria. It is efficient and avoids fluff, though it could be slightly more structured. Every sentence contributes to understanding the tool's behavior, so it earns a high score for 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?

For a simple read-only tool with one parameter and no output schema, the description covers the key behavioral aspects (criteria and found=false semantics). However, it does not describe the output structure beyond the found flag, nor does it clarify domain-specific terms like 'alive' or 'pool.' It is adequate but leaves some gaps for an agent to infer.

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

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

Schema description coverage is 0%, so the description must compensate for the undocumented 'symbol' parameter. It only mentions 'for a ticker,' which is vague and does not clarify the expected format, case sensitivity, or what symbols are valid. The description adds minimal value beyond the schema's bare type definition.

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 ('resolve') and resource ('the ONE Robinhood Chain contract worth naming for a ticker') with clear criteria (alive, $10K+ pool, not flagged HIGH/CRITICAL). It distinguishes the tool's purpose from generic lookups and clarifies that other contracts are returned as a count, not a list. This is specific and unambiguous, not a tautology.

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

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

The description implies when to use this tool (when you need the 'real' ticker contract) but does not explicitly state when not to use it or mention alternative sibling tools. It does not guide the agent toward or away from any of the many siblings like rh_chain_stats or rh_token_safety. No exclusions or alternative routing is provided.

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

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

Beyond the readOnly/idempotent annotations, the description discloses interpretation-critical behavior: found=false means not indexed rather than safe, the miss is queued for reading, deep=true means economics/lock/operator/thesis passes ran, and 'a flag is a finding, not a prediction'. With no output schema this is exactly the semantic context an agent needs.

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

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

Purpose is front-loaded in the first clause, followed by result and edge-case semantics. The single dense paragraph packs many distinct facts, but each clause carries information; only slight over-compression reduces it below 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?

With no output schema, the description takes on return-value explanation and does it well, covering the safety fields, the move metric, and the fomo payload (counts, recent trades, first buy, no sizes). It stops short of detailing pagination or error shapes, but for a single-address stored read it is essentially 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 0% and the single address param has no schema description, but the description supplies the required format ('0x + 40 hex'), which is genuine added meaning. It does not, however, clarify the referenced deep=true flag against the schema, which only exposes address and could confuse an agent into trying to pass 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?

States a specific verb and resource: 'Stored safety read for one Robinhood Chain token', then enumerates exactly what is returned (sellability, launch flags, launch money, move since first log). The 'Never triggers a scan' clause implicitly distinguishes it from sibling rh_scan_now, so an agent can route between the two without opening a 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?

Clear context: it is a stored read that never triggers a scan, and found=false means 'not yet indexed, not safe' with the miss queued. This tells the agent it is a safe non-scanning lookup, but it does not explicitly name rh_scan_now as the alternative for a fresh scan, leaving that routing 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 readOnly/openWorld/idempotent/non-destructive, but the description adds genuine interpretive context: a sell's size is a router minimum-out floor rather than profit, many addresses are routing contracts, and `fomo_trader` signals a FOMO app match. These caveats materially change how an agent reads the data.

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

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

Four compact sentences, each delivering distinct information with no filler; the core purpose is front-loaded before the data caveats. Slightly dense but nothing is wasted.

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 does outline the record's contents (holdings, trades, `fomo_trader`) and reading caveats, which is helpful. However it omits usage routing and any explanation of the required address parameter, leaving real gaps for an agent deciding whether and how to call it.

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

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

With one required parameter and 0% schema description coverage, the description carries the burden of explaining `address`. It gestures at address types (contracts vs people) but never specifies the expected identifier or format, leaving the single required input essentially undocumented.

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

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

The description names a specific resource and scope: one Robinhood Chain wallet's holdings and trades, sourced 'off the chain's own feed.' It is clearly distinct from rh_deployer_record and rh_whale_wallets by implication, though it never states an explicit retrieval verb or directly names a sibling it is 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?

There is no statement of when to reach for this tool versus rh_deployer_record, rh_whale_wallets, rh_early_wallets, or my_watched_wallets. The note about `fomo_trader` explains a field, not when or why to invoke the tool.

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

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

Annotations already cover read-only and non-destructive behavior. The description adds meaningful behavioral context beyond that: most listed wallets hold rather than trade (meta.trading_30d), and the tool measures capability not intent. 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?

Four sentences each add unique information: thresholds, tiers, caveat, and sort behavior. Slightly dense but not wasteful; the sort note could be integrated, but overall the description is efficient.

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

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

Given no output schema, the description explains core return fields (positions_top, meta.trading_30d) and the tool's purpose. It does not mention limit semantics or full sort options, but for a read-only list with two optional parameters, this 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 description coverage is 0%, so the description must compensate. It explains the 'active' value for sort but does not enumerate other sort options or explain the limit parameter. This is partial compensation for a simple 2-parameter 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 a specific verb ('read') and resource ('wallets holding 10+ ETH or $50K+ in tokens'), and adds distinguishing details like tiers, positions_top, and the 'CAN move a pool' framing. This clearly differentiates it from siblings such as rh_wallet_record and rh_early_wallets.

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

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

The description gives a clear when-not ('never who is right or who to follow') and a usage tip (sort='active' orders by trades). It does not explicitly name alternative tools for specific use cases, so it stops short of a 5.

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

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

Annotations already cover read-only/idempotent/non-destructive, but the description adds real behavioral context: newest-first ordering, inclusion of losers, a tiered access model with delay_minutes, and a warning that a count of calls is not a success rate. It stops short of rate limits or auth details, but adds meaningful disclosure 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 core purpose is front-loaded in the first sentence, and each subsequent sentence adds usable information. Parenthetical asides make it slightly dense, but there is 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?

With no output schema, the description usefully enumerates return fields and ordering, which is a meaningful contribution. However, it leaves the three input parameters essentially undocumented, so an agent cannot know how to scope days, chain, or limit from the description alone.

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

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

Schema coverage is 0% for three parameters, so the description carries the full burden but explains almost none of them. It implies chain values (Solana, Robinhood Chain) and newest-first ordering, yet never clarifies days, limit, or the chain filter.

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 resource and scope: the calls PumpPill's room posted on Solana and Robinhood Chain, with the fields each call carries. It is clearly distinguishable from vague siblings, but it never names an alternative tool to route against, so it stops short of full sibling differentiation.

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

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

There is no when-to-use guidance, no condition selecting this over premium_calls_recent or outcomes_measured, and no stated prerequisites. The access-delay note describes visibility, not when an agent should call 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 establish read-only, idempotent, open-world behavior, so the bar is lower, and the description adds real context beyond them: results are capped at 40, ordered biggest-first, include each filter's reading, and are judged on PumpPill's side. No contradiction. It stops short of covering error cases (invalid code, empty rule) or refresh cadence, so not a 5.

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 return value is front-loaded in the first clause, followed by param provenance, result contents, the non-recommendation caveat, the workflow hint, and the cap/ordering. Five dense sentences, all carrying information, though the 'judged by PumpPill on its side' phrase is slightly awkward.

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 adequately covers what comes back, how many items, in what order, and what each item contains. The main omission is behavior for the optional/empty `rule`, which is the one thing an agent could get wrong.

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

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

Schema coverage is 0%, so the description carries the param burden and mostly does: it defines `rule` as the code with a concrete prefix format (pp1....) and tells the agent where the user obtains it (pumppill.org/customize). The gap is the unexplained empty-string default and whether the call is meaningful without a rule.

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

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

The description names a specific resource (Robinhood Chain tokens), a specific operation (those passing every filter of a member's rule), and the evaluator (PumpPill, server-side). It explicitly separates itself from recommendation-style siblings by stating a pass is 'a match to the member's own rule, not a recommendation.' An agent can distinguish this from best_calls/premium_calls_recent without opening any 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 implies when the tool applies (checking which tokens currently satisfy your rule) and gives a workflow hint to 'compare with the last check to find NEW passes.' However, it names no alternative sibling and gives no when-not guidance, and it never explains how the tool behaves when the optional `rule` is omitted despite the empty default.

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 convey read-only, idempotent, and non-destructive behavior. The description adds significant behavioral context beyond that: it explains the base-rate field, that sprayers/at-or-below-base/silent wallets are removed with reasons, and that wallet identity showed no out-of-sample edge.

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 dense sentences carry only meaningful information: the dataset definition, the filtering behavior, and the critical interpretation caveat. There is no padding or repetition of the title or 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?

The description covers the dataset, filters, base rate, and the main limitation, which is enough for an agent to understand what the tool returns. Since there is no output schema, it could be slightly more explicit about the exact response shape and ordering, and it does not explain how limit behaves.

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

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

The only parameter, limit, is not mentioned in the descriptionched, and schema description coverage is 0%. The schema itself gives the type and default, and 'limit' is semantically conventional, so the gap is minor; still, the description adds no parameter-level meaning and does not fully compensate for the low 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 identifies a specific resource and selection criteria: Solana wallets that were among a token's first buyers on tokens that later reached 5x the scan cap. It also clearly distinguishes this from the generalized early-wallet sibling tools by focusing on Solana and winners.

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

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

The description gives a clear when-not: 'this answers who was early, not who to copy,' which is an explicit caveat against using it for copy-trading. However, it does not name an alternative sibling tool for that use case, so it stops short of full explicit 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 cover the safety profile (readOnly, idempotent, openWorld, non-destructive). The description adds real behavioral context beyond them: that depth='quick_scan' means an unlogged token with contract and holders only and no entry/peak, and that the fomo field reports 24h counts, recent large trades only with no sizes, and the first buy plus still-in traders.

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 primary purpose is front-loaded, but the body is a dense, jargon-heavy run-on that mixes return contents, reading advice, a phantom parameter, and field semantics without clear structure. Several clauses could be trimmed or separated.

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 appropriately takes on explaining return fields (meta.verdict, fomo). But the phantom depth parameter leaves the actual callable signature ambiguous, and no guidance links this tool to the many siblings an agent must choose between.

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

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

Schema coverage is 0% and the single mint parameter is undocumented in the schema, but the description supplies its format (base58). However, it references depth='quick_scan' as if it were a parameter, and no such parameter exists in the input schema, which risks misleading the agent about the call signature.

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 (fetch any Solana token by mint) and enumerates the returned evidence: holders, bundled-launch read, deployer holdings, socials, and meta.verdict. It is clear what the tool does, though it does not explicitly differentiate from siblings like sol_early_wallets or rh_token_safety.

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?

'Start from the verdict; the rest is evidence' and 'a clean read is not a reason to buy' are interpretation advice, not selection guidance. No when-to-use conditions, prerequisites, or named alternatives versus the many sibling tools are given.

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

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

Annotations already cover readOnly/idempotent/non-destructive/openWorld, so the description adds genuine extra context: room calls lag 'a few minutes behind unless a member asks,' and the explicit disclaimer that flags are findings and trader counts are counts, not buy signals. No latency on the other streams or rate limits are mentioned, keeping it short of a 5.

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?

Front-loads the core purpose, then the three streams, then the incremental-polling instruction, then the caveat. Dense but every clause carries information; the nested parentheticals make it slightly heavy 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 an aggregation call with no output schema, the description covers what comes back, the cross-chain scope, incremental-refresh behavior, and interpretability caveats. The remaining gap is the underspecified parameter formats, which the schema leaves bare.

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

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

Schema coverage is 0% and both parameters are undocumented in the schema. The description indirectly explains `since` (pass the prior as_of to get only changes) and implies `chain` via 'Robinhood Chain and Solana,' but omits the timestamp format and the accepted chain values, leaving gaps an agent must guess at.

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 ('what is happening right now') and enumerates the three content streams it aggregates (FOMO app tokens with PumpPill's read, PumpPill room calls, newly flagged Robinhood Chain tokens). It is clearly an aggregation tool, though it does not explicitly contrast itself against siblings like fomo_gathering, room_calls, or rh_flagged_recent that supply the same data individually.

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 concrete usage guidance: 'Pass the as_of from the last answer as `since` to get only what changed,' which tells the agent how to use it for polling. It also frames the use case ('what is happening right now'), but offers no explicit when-not or alternative-steering guidance against the sibling single-stream tools.

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