loophole-tape

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

Annotations provide the safety profile, and the description adds important behavioral context beyond them: one-time $2.00 cost, bearer secret nature, non-expiring credit, header usage, and per-call deduction. It does not contradict any annotation.

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

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

Front-loads the price and purpose, then adds concise usage details and the alternative. Every sentence is dense and useful, with no filler.

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

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

For a zero-parameter purchase tool with an output schema, the description covers cost, key format, credit behavior, usage method, and the first-try alternative. Return values are left to the output schema, so nothing critical is missing.

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

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

There are zero parameters, so per the rubric the baseline is 4. The description's 'No arguments' confirms the empty schema, and no further parameter semantics are needed.

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

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

States a specific verb and resource: buy a prepaid API key for $2.00, returning a key like lt_... with credit. It distinguishes itself from the sibling buy_trial_key by naming the alternative and when to prefer it. An agent can identify the operation 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?

Explicitly states the use case: 'Use when your client cannot sign x402 on every call.' Also names the alternative 'Try first: buy_trial_key,' giving both when-to-use and a sibling route. No inference is required.

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

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

Adds real context beyond annotations: the price point, expected row volume (~15k-35k), and the return shape (one-hour download URL). Annotations mark readOnlyHint=false and idempotentHint=false, consistent with a purchase. Could go further on whether repeat purchases for the same day are re-charged, which idempotentHint=false implies but the description doesn't state.

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 tight sentences: price, purpose plus anti-use, inputs, and return. Front-loaded with the cost and purpose, 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?

Covers cost, scope, intended use, anti-use, and return value; an output schema exists so return format needn't be detailed. Missing only the re-charge/duplicate-purchase behavior for a non-idempotent paid call.

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 parameter description already documents the YYYY-MM-DD format and the /v1/datasets source. The description repeats format and source rather than adding syntax the schema lacks. Baseline 3.

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

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

States a specific verb and resource ('Buy one day of pump.fun launches'), includes the price ($5.00/day file) and the intended use (backtest or train a rug/graduation model). Distinguishes clearly from siblings like buy_trial_key and buy_api_key by scoping to a single UTC day.

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 it (backtesting/training on one UTC day) and when NOT to use it ('not for live decisions'). Also points to the free /v1/datasets index to discover available days, which is the key prerequisite an agent needs.

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 declare this is not read-only, is open-world, and not idempotent. The description adds crucial context: the key is prepaid with $0.10 of credit, is a bearer secret sent as X-API-Key, and is used on POST /mcp or any paid HTTP route. It also says 'no arguments,' which is helpful. However, it doesn't explain what happens after the trial credit is exhausted or whether the key can be reused.

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?

Extremely concise and front-loaded: price, purpose, key format, usage, alternative, and argument note, all in a few choppy but dense sentences. Every phrase earns its place.

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

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

Given the tool's simplicity (no parameters) and that an output schema exists, the description covers key aspects: cost, purpose, key format, and usage. It could mention what the return value contains (e.g., the key itself) but since an output schema exists, that is not strictly necessary.

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

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

There are zero parameters, so the baseline is 4. The description's 'No arguments' is accurate and helps set expectations, though no additional parameter meaning 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?

States a specific action (buy a $0.10 trial key) and the resource (prepaid key with $0.10 credit). It also distinguishes from the sibling buy_api_key by specifying 'larger credit' for that alternative, so an agent can 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?

Says 'Use to try the paid tools' and names the larger alternative buy_api_key, but doesn't explicitly state when not to use this or any eligibility constraints. Clear context for usage without full when-not 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 cover safety (readOnly, idempotent, non-destructive). The description adds useful context: it is free, contains payment terms in USDC on Solana or Base, and carries no market data. It does not detail rate limits or auth, but none are evident for a free catalog.

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

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

Two sentences, front-loaded with 'Free. Start here,' and every phrase adds value. No redundancy or wasted space.

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?

Complete for a parameterless catalog: it names the contents, payment context, and explicitly says no market data. An output schema exists, so return structure need not be explained.

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

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

The tool has zero parameters, so the schema description baseline is 4. The description correctly focuses on what the tool returns rather than parameter semantics, and no parameter meaning is missing.

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 it is a catalog of every tool with price, arguments, and x402 payment terms, and explicitly distinguishes itself from market-data siblings ('carries no market data'). An agent can tell it apart from all sibling tools without opening schemas.

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

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

Explicitly instructs to use it first for choosing a tool and budget, and states it carries no market data, preventing misuse. It does not name a specific alternative, but instead routes the agent across the whole catalog.

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, openWorld), and the description adds real behavioral context beyond them: flat $0.04 per call regardless of mint count, billing triggered if any mint is covered, partial-coverage items returned as unavailable, and a "not a safety guarantee" disclaimer. It does not mention rate limits or latency, keeping it out of 5 territory.

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?

Pricing is front-loaded and the sentences are short and information-dense with no filler. The third and fourth sentences are slightly cramped and telegraphic ("the compact check item per covered mint, others listed as unavailable"), 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?

Given an output schema exists, the description need not explain return values, and it correctly defers to the external fields reference. It covers cost, coverage semantics, and the safety caveat for a batch operation, leaving only minor gaps like concurrency or per-call limits.

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

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

Schema description coverage is 100%, so the parameter's accepted link formats (pump.fun/gmgn/solscan/birdeye) and the out-of-window behavior are already fully documented in the schema. The description only restates the 1–25 range, adding no syntax or format detail beyond the structured field.

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

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

The title and first sentence state a specific verb+resource (rug check) and scope (one to 25 mints), making it clearly the batch counterpart to single-mint tools like check_pumpfun_risk and check_watchlist_risk. It never names those siblings explicitly, so the differentiation is inferred from the batch framing rather than stated.

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

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

"Use when a screener checks a list, some possibly outside the live window" gives a concrete triggering context and even flags the tricky case of stale mints. It lacks any explicit when-not or a direct pointer to the single-mint alternatives, so it falls short of a 5.

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

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

Annotations already declare readOnly, idempotent, openWorld and non-destructive, so the safety profile is covered. The description adds genuinely new behavior: it is free, the freshness threshold is <=5s, and it deliberately omits risk findings — all useful for deciding whether to call it.

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

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

Two tight sentences with the cost ('Free.') front-loaded, then purpose and the preflight guidance. No sentence 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?

An output schema exists, so return-value detail is unnecessary; the description still clarifies what the response does and does not contain (coverage status plus exact prices, no risk findings). Complete for a preflight tool, though naming the paid counterpart it precedes would make it airtight.

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 there is only one parameter, whose schema description already documents cardinality and accepted link formats. The description's 'one to five pump.fun mints' restates the schema rather than adding syntax or constraint detail, so the baseline 3 applies.

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

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

States a specific verb and resource ('whether one to five pump.fun mints have full live coverage and a fresh feed') plus the payload ('the exact prices'). An agent can distinguish this from the risk-check siblings because the description explicitly says it returns 'no risk findings'.

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

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

Gives explicit timing guidance: 'Use it right before a paid check', which positions it as a cheap preflight for the paid risk tools. It does not name a specific sibling or state exclusions, 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 safety profile (readOnly, idempotent, non-destructive, openWorld), so the description adds genuinely new behavioral context: the $0.005 cost, the refuse-before-payment behavior for uncovered/stale mints, and the 'never a safety guarantee' limitation. It stops short of describing return shape or latency, but the additions are substantive.

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 cost and the core question, then scoping, usage, and return shape. Slightly noisy: the $0.005 price appears twice (title and first line) and the 'flags_observed | no_flags_observed' pipe notation is awkward, but no sentence 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 an output schema present and rich annotations, the description need not explain return values, yet it still summarizes the result category and the no-guarantee caveat. Coverage of failure modes (uncovered/stale refusal) makes it nearly complete for a paid single-mint check.

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

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

Schema description coverage is 100%, so both mint and cursor are fully documented (accepted link formats, cursor watch semantics) in the schema itself. The description adds no parameter-level meaning beyond that 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?

States a concrete verb+resource ('Solana token safety check (rug check) for ONE pump.fun mint') and names the output ('calibrated rug probability and observed flags'). The explicit 'ONE ... mint' scoping separates it from batch siblings like check_batch_risk and check_watchlist_risk.

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 clear timing guidance ('Use right before a swap or while holding it') and a precondition ('Uncovered or stale: refused before payment'). It does not explicitly name the alternative sibling for multi-mint needs, but the free check_coverage prerequisite is stated in the schema's mint description.

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 read-only/idempotent/non-destructive profile, and the description adds real behavioral context beyond them: per-call (not per-mint) billing, refusal before payment for uncovered/stale mints, and a disclaimer that this is not a safety guarantee. It stops short of describing what the 'compact check item' contains or any throttling details, keeping it from 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?

Effectively front-loaded with the cost/scope decision, then alternatives, then caveats. Dense but every clause carries information; the telegraphic fragments are readable and not wasteful.

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

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

With an output schema present, return-value detail is correctly omitted, and the description covers cost, coverage preconditions, alternatives, and a safety caveat. The only soft spot is the vague 'compact check item' phrase, which leaves the per-mint output content slightly underspecified.

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% (baseline 3), and the description adds meaningful semantics tying the cost model to the mints array ('$0.01 per call for 1-5 mints, not per mint'), which clarifies that adding mints is free. It adds little for cursor beyond what the schema already documents.

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+scope: a rug check covering 1-5 mints with per-call pricing, and explicitly differentiates itself from the single-mint sibling check_pumpfun_risk. An agent can tell exactly what this does and how it differs from check_batch_risk/check_pumpfun_risk.

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

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

Gives explicit when-to-use ('hold or watch 2-5 pump.fun mints') and a named alternative with the selecting condition ('for one mint check_pumpfun_risk ($0.005) costs less'). Also states a failure precondition (uncovered or stale mints are refused) and a limitation (not a safety guarantee).

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, non-destructive). The description adds genuinely non-obvious behavior: pricing at $0.02 per call, and that a stale feed is refused before payment, so no charge occurs. Rate limits and latency expectations are still unstated.

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?

Cost is front-loaded, then purpose, then input, then failure mode, then schema pointer. Every clause carries information; nothing is padding.

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?

An output schema exists, so return values need not be spelled out, and the description wisely just points to it. Cost, input, and failure behavior are all covered; the cryptic "loopholetape://schema/..." reference is the only slightly opaque element.

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

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

Schema coverage is 100%, so the single address parameter is already fully documented as a 32-44 char base58 Solana wallet. The description simply restates this ("Input: address (base58 wallet)") and adds no format or validation detail 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?

States a specific verb and resource: judging a new pump.fun token via its creator's prior launch history, with named evidence (graduations, rugs, median seconds to first sell). This distinguishes it clearly from siblings like mint_risk_card, token_check, and wallet_profile.

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

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

"Use to judge a new pump.fun token by its creator's earlier launches" gives a clear triggering context. It never names an alternative tool or states when-not to use it, so it stops short of 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 declare readOnlyHint, idempotentHint, openWorldHint and destructiveHint=false, so the safety profile is covered. The description adds the semantics of chain_lag_s/slots_behind (estimated from slots against the Solana RPC processed tip) and flags the tool as free, but an output schema already exists, so return fields are partly redundant.

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

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

Two sentences, front-loaded with "Free. Feed health:" and then the field roster plus the usage cue. The parenthetical explanations are dense but each earns its place by defining non-obvious lag metrics.

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?

Zero parameters, rich annotations, and a published output schema mean the description only needs to state what the tool is and when to reach for it, both of which it does. Nothing needed to invoke it correctly is missing.

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

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

The tool takes zero parameters, so there is nothing for the description to disambiguate; baseline 4 applies.

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

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

Names a specific resource (feed health) and enumerates the concrete signals returned: feed_lag_s, is_stale, last Solana slot, chain_lag_s, slots_behind. The purpose is unambiguous, though it never explicitly contrasts itself with the many risk/card siblings it warns about.

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

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

"Use it before trusting a card's freshness" gives a clear trigger condition tied to sibling card tools. It stops short of naming an alternative or stating when not to call it, so it is clear context without 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 only cover the read-only/idempotent safety profile, but the description adds materially more: per-call pricing ($0.01), refusal-before-payment behavior on stale feeds or empty screens, and an explicit 'not a safety guarantee' disclaimer. These are real behavioral traits an agent needs and cannot infer from 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?

Price is front-loaded, then purpose, then filter behavior, then disclaimer. Five short sentences, each carrying distinct 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?

An output schema exists, so return values needn't be described. The description covers cost, temporal scope, exclusion rule, ranking basis, staleness handling, and a liability caveat, leaving no material gap for invoking the tool correctly.

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

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

Schema description coverage is 100% and both params are documented in the schema. The description's 'last 15 min' hints at the max_age_s default but adds no syntax or format detail beyond what the schema already states, so the baseline of 3 applies.

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

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

Specifies concrete verb, resource, window (last 15 min), filter (fixed rule does not mark avoid), and ordering (ranked by P(true graduation)). This distinguishes it from siblings like launches_since and recent_launches, which lack the screening/ranking semantics.

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

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

'Use to get...' establishes the use case clearly, and the filter condition tells the agent what the tool will and won't return. However, it never names an explicit alternative (e.g. launches_since for unscreened data) or states when another tool is preferable.

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 safety (readOnly, idempotent, non-destructive). The description adds value beyond them: pricing ($0.001 per poll), the empty-page-still-costs rule, and that stale feeds are refused before payment. That last point is unusual and useful. It doesn't disclose rate limits or auth requirements, 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?

Front-loads the pricing and the core operation, then the polling instruction, then a schema reference. Compact and information-dense. Minor awkwardness from cramming cost/polling/staleness into two sentences, but every clause 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?

An output schema exists, so return-value detail is not needed here. Description covers pricing, staleness, polling cursor, and field contents pointer. Missing: which sibling to use for non-polling use cases and rate/limit guidance. Adequate but not complete.

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

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

Schema coverage is 100%, so the schema already documents all four parameters well. The description adds the polling pattern for `since` and next_cursor semantics but doesn't add meaning beyond the schema for limit/no_avoid/min_p_grad. Baseline 3 is appropriate.

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

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

States a specific verb-ish operation (list new launches after `since`) and resource (pump.fun memecoin launches with verdict and P(rug)). However, it does not clearly distinguish from siblings like `recent_launches` and `launches_screened` – an agent cannot easily tell which of these three to pick based on the text alone. The pricing embedded in the title ('$0.001') is unusual but does identify it as a metered endpoint.

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 'Use when polling: pass next_cursor back as since; an empty page costs the same.' This is real usage context and a non-obvious cost caveat. It stops short of naming alternatives (e.g. vs `recent_launches` or `launches_screened`), which would earn 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 declare readOnly, idempotent, non-destructive, and open-world behavior. The description adds useful access context ('Free'), confirms 'No arguments,' and enumerates the regime metrics, though it does not mention rate limits, auth, or data freshness.

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

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

Dense and front-loaded: free status, metric list, routing guidance, and zero-argument note in three short sentences. Every sentence earns its place without redundant explanation.

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

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

With an output schema present, the description need not explain return values. It covers scope, key metrics, and the relevant sibling alternative, which is sufficient for an agent to invoke this zero-arg tool correctly.

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

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

There are zero parameters, so the baseline is 4. The description states 'No arguments,' which matches the empty input schema and removes any lingering ambiguity about required inputs.

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 the exact domain (pump.fun market regime) and the metrics it returns, and explicitly distinguishes itself from check_pumpfun_risk for single-mint analysis. An agent can tell what this tool covers 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?

Explicitly instructs to use it to judge the market as a whole and to use check_pumpfun_risk for one mint. That gives both the intended context and the main alternative, leaving little ambiguity for a zero-argument aggregate 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 the safety profile (readOnly, idempotent, non-destructive, openWorld), so the bar is lower; the description adds genuinely new context beyond them — per-page cost ($0.01), incremental polling via the cursor, and ordering of curve buys/sells. It stops short of describing rate limits or auth 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?

Front-loads the price, then the use case, then the inputs and schema reference — a sensible order with little waste. Dense but each 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 an output schema present, return values need not be explained. The description covers cost, purpose, inputs, and a coverage caveat is handled in the schema; only polling mechanics (backoff, staleness) are left implicit, which is acceptable for this complexity.

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

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

Schema description coverage is 100%, so the baseline is 3. 'Input: mint or link, since, limit' merely restates the schema, which already documents the mint-or-link acceptance, cursor semantics, and limit bounds in far more detail.

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 — who bought and sold ONE pump.fun token, trade by trade — with scope qualifiers ('one token', 'curve buys and sells in slot order') that separate it from portfolio-style siblings like mint_holders. An agent can distinguish it from rhc_curve_trades and mint_holders 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?

Gives clear when-to-use conditions: retrieving per-trade buyer/seller data for a single token, or polling its new trades. It does not explicitly name or exclude a sibling alternative, so a 5 isn't warranted, but the intended context is unambiguous.

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/no-destructive, so safety is covered. The description adds genuinely new context: per-call pricing ($0.01), the observation-vs-verdict framing for wallet labels, and the coverage caveat carried in the mint param. It does not mention rate limits or response shape, but the cost and interpretation caveat are meaningful additions.

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 cost and scope in the first two clauses, then enumerates outputs compactly. Dense but every clause carries information; only the field-pointer tail is boilerplate-ish.

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

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

With an output schema present, the description needn't explain return values, and it sensibly delegates field details to the schema reference. Cost, scope, and interpretation caveat are all covered; only prerequisites like the check_coverage dependency are left to the schema rather than the prose.

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

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

Schema description coverage is 100%, so both 'mint' and 'limit' are already well documented in the schema, including link formats and the coverage-check prerequisite. The description adds no syntax or format detail beyond that, so baseline 3 applies.

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

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

States a specific resource and scope: 'Solana token holder concentration for ONE pump.fun token,' plus the concrete outputs (top-5/top-10 share, HHI, cohorts). This clearly separates it from siblings like check_pumpfun_risk or token_check, which are risk/verdict-oriented rather than concentration-oriented.

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

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

'Use when you need who holds it now' gives a clear triggering context, and the emphasis on ONE token implies the batch alternative is elsewhere. It stops short of naming a specific alternative or an explicit when-not-to-use condition, so it is clear context without full routing guidance.

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

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

Annotations already cover read-only, idempotent, non-destructive and open-world status, but the description adds genuinely new behavior: cost ($0.001 per call), the fact that results are "null until settled," and that unrecorded mints are refused rather than silently returned. It does not detail latency or auth, but the added context is substantive.

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 price and then the purpose in a compact run of clauses; every element (price, use case, rule, null semantics, refusal) earns its place. The trailing "Fields: loopholetape://schema/mint_outcome" is a slightly cryptic append.

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

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

For a one-param paid lookup with an output schema present, the description needn't explain return values, and it does cover cost, usage, and the unsettled/refusal edge cases. Complete enough to call correctly, with only minor gaps around response timing.

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

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

Schema coverage is 100%, so the schema already documents the mint parameter including the accepted link formats. The description adds nothing beyond the schema for this parameter – a baseline 3 is appropriate.

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

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

States a specific verb+resource: returning "the outcome of ONE pump.fun launch by a fixed public rule (rugged and when, graduated and when)" – concrete and scoped. The word ONE implicitly distinguishes it from the sibling mint_outcome_batch, though that sibling is never named outright.

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 it: "grade your own rug or graduation calls or backtest a signal." It also flags an edge case (a mint never recorded is refused unpaid) but gives no named alternative for the batch case, nor 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?

Annotations already cover readOnly/idempotent/non-destructive/openWorld, so the bar is lower. The description adds genuinely useful context beyond them: flat pricing ('$0.01 per call whatever the answers') and that mints need not be in capture. It does not elaborate on latency or result shape, but the output schema covers returns.

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 pricing, then purpose, then the alternative, then input — a sensible order with no wasted sentences. The final 'Fields: loopholetape://schema/...' pointer is terse but functional.

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 full annotation coverage, an output schema, and 100% schema description coverage, the description has little left to carry. It supplies pricing and a single-vs-batch routing note, which is sufficient 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 there is only one parameter, so the schema already documents the mints array fully (including the link-acceptance detail). The description's 'Input: mints' adds nothing beyond the schema; baseline 3 is appropriate.

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

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

States a specific verb and resource: batch outcome labels for 1-40 pump.fun mints. It explicitly contrasts with the sibling mint_outcome ('$0.001 alone'), so an agent can distinguish batch from single without opening 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?

Gives a clear use case ('grade a list of your own calls') and implicitly routes single-mint use to mint_outcome. The when-not condition is implied rather than stated as an explicit rule, so it falls just short of a 5.

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

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

Annotations already declare readOnly/idempotent/non-destructive/openWorld, so the description needn't restate safety. It does add the per-call price ($0.025), which is material decision context for a paid tool, but says nothing about rate limits, billing units, or failure modes.

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 price and scope and is compact, but several fragments are cryptic ('coverage thin = any other SPL mint', the bare schema URI) and require interpretation rather than reading cleanly.

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

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

With an output schema present, return values need no explanation, and the field list tells the agent what the card contains. The one gap is that the phrase 'coverage thin = any other SPL mint' is ambiguous about what the tool actually covers for non-pump tokens.

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 single 'mint' parameter is fully documented in the schema (base58, length, link formats, pump suffix). The description adds no parameter-level detail beyond that, so the baseline 3 for schema-driven params applies.

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

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

States a specific resource and scope: 'Solana token safety card for ONE token', then enumerates the fields it returns. That distinguishes it from the lighter-weight siblings (check_pumpfun_risk, token_check), though it doesn't name those siblings directly.

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

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

'Use when you need every field: holders, creator, flags, odds, market, authorities, cohorts with holder reputation' gives a clear selection condition relative to thinner alternatives, and the 'any other SPL mint' line scopes coverage. It stops short of explicitly naming the alternative tools to use when you don't need every field.

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

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

Annotations already declare read-only/idempotent/open-world, and the description adds substantial context beyond them: 5-second refresh cadence, two ranked lists of ten, ranking methodology, and each entry carrying its paid check. It is still silent on rate limits or behavior when no fresh mints exist, so it is 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?

Front-loads 'Free.' and packs the essentials into one dense sentence followed by a short usage sentence; nothing is wasted. The main sentence is information-heavy enough to risk being hard to parse, keeping it from a 5.

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

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

For a no-argument, read-only listing tool with an output schema and full annotation coverage, the description supplies everything needed to invoke it correctly: freshness, list size, ranking basis, and the free-tier framing.

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 and 100% schema coverage, the baseline is 4, and the description confirms this by stating 'No arguments,' removing any ambiguity about required inputs.

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 (new Solana token launches from pump.fun), with the exact coverage windows (ten <30s, ten <15min) and ranking criteria (P(rug within 300s), P(true graduation)). This distinguishes it from siblings like pumpfun_recent_launches, recent_graduations, and launches_screened 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 clear context: 'Use it to find new memecoin launches worth a paid check,' which implies it is the free discovery step before paid checks. It does not explicitly name an alternative tool or state when NOT to use it, so it falls short of a 5.

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

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

Annotations already declare readOnlyHint and idempotentHint, so the safe-read profile is covered. The description adds non-annotation behavior: the price, the refusal-before-payment guarantee on a stale feed, and the divergence from launches_since. It doesn't cover pagination or rate limits, so it stops 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?

Dense and front-loaded: price first, then the resource, then the value-add (screening), then the alternative, then the stale-feed guarantee, then the schema URI. No sentence is padding.

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?

Five optional parameters are schema-described, an output schema exists for return shape, and annotations carry the safety profile. The description still supplies the business context an agent cannot get from structure: cost, the polling sibling, and the stale-feed refusal.

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

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

Schema description coverage is 100%, so all five parameters are already documented in the schema. The description mentions the field meanings only through the card summary ('curve SOL, buyers, concentration, flags') and does not add syntax or defaults beyond the schema. Baseline 3 applies.

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

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

The description opens with the price, then the resource ('the newest pump.fun memecoin launches'), the format ('compact cards'), and the field set. An agent can distinguish this from new_launches_free and launches_since purely from the text.

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 not only when to use it ('screen new launches') but names the polling alternative ('poll with launches_since ($0.001)') and the failure mode ('Stale feed: refused before payment'). That is an explicit when/when-not/alternatives triad.

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, so the safety profile is covered. The description adds meaningful non-obvious context: per-call cost, that a stale feed is refused before payment, and the 84 SOL threshold that defines graduated=true. It omits latency, feed freshness bounds, and rate limits.

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

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

Tight, front-loaded on price and purpose, with no filler sentences. The trailing schema URI and shorthand phrasing ('84 SOL', 'instant_bundle or organic') are dense but functional rather than wasteful.

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?

An output schema exists, so return-field detail is not required, and the description still explains the key label semantics (instant_bundle/organic, graduated=true). Cost and stale-feed refusal round it out; only freshness/latency expectations are left unspecified.

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 both parameters (limit, window_s) are already documented, and the description only echoes the default window ('last 6 h'), which matches window_s default 21600. No added syntax or semantics for limit. Baseline 3 applies.

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

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

States a specific verb (list) and resource (recent pump.fun migrations to PumpSwap), with a scope qualifier (default last 6 h). The phrase 'Not a live rug check' separates it from siblings like recent_rugs and check_pumpfun_risk without schema inspection.

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

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

'Use to list recent pump.fun migrations' gives a clear use context, and 'Not a live rug check' rules out one wrong use. It stops short of naming the alternative tool (e.g. check_pumpfun_risk) for live rug screening, so routing is implied rather than explicit.

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

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

Annotations already declare readOnly/idempotent/non-destructive and open-world, so the safety profile is covered. The description adds real value beyond that: per-call cost, the stale-feed refusal-before-payment behavior (an important billing/error trait), and the enumerated flag reasons.

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

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

Dense and front-loaded: price, purpose, exclusion, behavior, schema pointer. Every sentence carries information, though the trailing 'loopholetape://schema/recent_rugs' pointer is cryptic without context and slightly interrupts the flow.

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?

An output schema exists so return values needn't be explained, and the description still covers cost, failure mode, and flag taxonomy. For a two-parameter read tool this is nearly everything an agent needs, missing only pagination/ordering guarantees.

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

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

Schema description coverage is 100% and both parameters are documented there with ranges and defaults, so baseline 3 applies. The description only gestures at 'window' and 'newest first' ordering without adding syntax or format detail 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?

States a specific verb (see) plus resource (pump.fun rug/close flags) and scope (windowed, newest first), and enumerates the flag types so the agent knows what comes back. It explicitly distinguishes itself from single-mint checks, separating it from check_pumpfun_risk and token_check.

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 a clear use case ('which tokens fired flags in a window') and an explicit exclusion ('Not a check on one mint'), which is the key routing decision in this sibling set. It stops short of naming the alternative tool to use for a single mint.

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 and open-world, so safety is covered. The description adds genuinely new behavioral facts: the $0.02 per-call cost and that unknown addresses are 'refused before payment' — a payment/billing behavior an agent cannot infer from annotations or schema.

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

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

Cost and the usage trigger are front-loaded, followed by the output fields, then input and the payment-guard note. It is telegraphic but every clause carries information; nothing is padded.

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

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

With an output schema present, return values needn't be detailed, yet the description still previews the field set for routing. Cost, refusal-before-payment, scope, and input format are all covered; only explicit sibling routing is missing.

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

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

Schema coverage is 100% and the schema already documents the 0x-prefixed 42-char address and its examples. The description adds only 'Input: address (0x).', which is redundant; baseline 3 is correct when the schema does the heavy lifting.

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

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

States a specific verb+resource: it produces a risk card ('verdict, basis, reasons, deployer record, sell_check, taxes, holders, ring screen') for ONE pons v2 token on Robinhood Chain. The chain/contract-scope qualifier separates it from generic risk tools like token_check or mint_risk_card, though it never names a 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?

"Use when you hold or are about to trade ONE pons v2 token on Robinhood Chain" gives a clear contextual trigger and scopes it to a single token. However, it never names an alternative (mint_risk_card, check_pumpfun_risk, token_check) or states when NOT to use it, so routing among the crowded risk-check family is left to inference.

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

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

Annotations already cover the safety profile (readOnly, idempotent, non-destructive) and an output schema exists, so the burden is lower. The description still adds real behavioral context: page-based pricing ($0.02), cursor-based pagination via next_cursor, and the 90-minute age window for ETH-paired curves.

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 price, then purpose, then inputs and scope, so an agent can skim the essentials. It is dense and uses stacked colon-chains, but nearly every clause carries information; the schema URI is the only borderline 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 an output schema present and full parameter descriptions, the description only needs to supply cost, scope window, pagination, and the field set, and it does all of those. Nothing an agent needs in order to invoke it correctly appears to be missing.

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

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

Schema description coverage is 100%, including an explicit example and semantics for 'since', so the baseline is 3. The description only lists 'address, since, limit' without adding format or usage meaning beyond what the schema already documents.

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: 'index or price a pons curve', with what is returned (reserves rebuilt to the wei, per buy/sell/buyback in block order). It is distinguishable from generic trade listings, but it never contrasts itself with the closest sibling rhc_curve_card, leaving the boundary to inference.

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

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

'Use to index or price a pons curve' gives an implied purpose, and the 90-minute ETH-paired constraint scopes applicable inputs. However, there is no explicit when-not-to-use clause and no naming of the alternative (e.g. rhc_curve_card for a summary), so 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 read-only, idempotent, non-destructive, open-world behavior, so the safety profile is covered. The description adds pricing ($0.01 per call), the default time window, and the shape of the returned structure cards (raised, taxes, concentration, ring block with verdict and basis), which is genuine added 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?

Front-loads price then purpose then usage, and each sentence carries information. It is telegraphic to the point of being choppy ('Not Solana. Fields: ...'), but there is little waste.

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

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

With an output schema present, return values need not be explained, yet the description still sketches the card contents, adds pricing and the default window, and rules out the Solana variant. Adequate for an agent to call it correctly, though a pointer to the RHC siblings would complete the picture.

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

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

Schema description coverage is 100%, so all seven parameters are already documented in the schema. The description names only 'ring_only' and 'since' by way of filter mention and adds no syntax or format detail beyond the schema, which is the expected baseline when the schema does the work.

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 ('new token launches on Robinhood Chain') and explicitly disambiguates from the Solana sibling with 'Not Solana'. The 'pons memecoins' jargon and 'structure cards' framing are a bit insider-y but the core action is clear.

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

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

'Use to screen or poll new pons memecoins (default last hour)' gives the intended context and notes the default window. It stops short of naming the sibling alternatives (recent_launches, launches_since) the way an explicit when-to-use rule would, so it's clear context rather than full routing guidance.

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

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

Annotations already declare readOnly, idempotent, openWorld and non-destructive, so the safety profile is covered. The description adds cost transparency ('Free.') — meaningful given paid siblings like buy_dataset and buy_api_key — plus 'No arguments' and the aggregate nature of the metrics, which goes 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 'Free.' then purpose, metric list, routing note and no-arg statement in three compact sentences. The dense metric enumeration is listy but each item is informative and nothing is redundant.

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

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

With an output schema present (return fields needn't be explained), no parameters, and annotations covering the safety profile, the description supplies what an agent needs: cost, scope, and the sibling alternative. It could note the observation window behind terms like 'per hour' or 'median seconds', but overall it is complete enough 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?

There are zero parameters, so the baseline is 4. The description's 'No arguments' merely confirms what the empty schema already shows and adds no call syntax, but nothing is missing.

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 pons regime) and enumerates the metrics returned: launches/graduations per hour, graduation rate, median seconds to graduate, buys per minute, unique buyers, snipe-tax facts. It also explicitly distinguishes itself from rhc_curve_card, so an agent can route without opening 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 gives a clear use condition ('gauge launch activity as a whole') and names the sibling to use instead for a single curve (rhc_curve_card). That is strong routing guidance, though it stops short of stating when this tool is not appropriate (e.g. per-token or per-wallet analysis besides the one sibling named).

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

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

Adds substantial context beyond the annotations: the exact 0.25% fee, the recipient address, the router address, the refusal conditions, and the explicit 'holds no keys; nothing is sent' assurance. The readOnlyHint is consistent with a builder that returns an unsigned payload and never broadcasts.

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 purpose, then constraints, in a compact paragraph with no filler. The raw hex addresses are dense but earn their place as verification data for an agent building calldata.

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 5-parameter unsigned-transaction builder with an output schema, the description covers purpose, pricing, refusal guards, and key-handling. It could state whether the returned calldata is chain-specific or note rate-limit behavior, but nothing essential to correct invocation is missing.

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

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

Schema description coverage is 100%, so the schema already documents side, token, amount, wallet, and slippage semantics. The description adds no parameter-level detail beyond what the schema provides (default side=buy, 18-decimal amount, 42-char addresses are all in the schema), so the baseline 3 applies.

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

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

States a specific verb+resource: builds the UNSIGNED KyberSwap transaction to swap a graduated pons token on Robinhood Chain. It distinguishes itself from the read-only curve/card siblings by making clear it produces a transaction payload, not data about a token.

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 it is refused (verdict 'avoid' or quote older than 30s) and points to rhc_curve_card for a live curve check. It stops short of contrasting itself with the near-identically-named sibling swap_build_checked, so the agent still has to infer that routing.

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

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

Annotations already declare readOnly, idempotent, open-world, and non-destructive behavior. The description adds useful context beyond them: free cost, delayed result, server-side mint selection, and eligibility criteria. It does not discuss rate limits or repeat-call behavior, but otherwise gives strong behavioral expectations.

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

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

Three short sentences, front-loaded with 'Free.' and then packing the sample shape, selection criteria, delay, and non-use into minimal text. 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?

An output schema exists, so return-field details need not be repeated. The description covers cost, selection method, delay, and the key limitation that it is not a check on a chosen mint; annotations cover safety. Complete for a zero-argument sample tool.

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

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

The schema has zero parameters, so the baseline is 4. The description reinforces this with 'No arguments,' matching the empty schema; no further parameter meaning 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?

States a specific resource and action: a free sample risk card with the exact paid mint_risk_card shape. It includes eligibility criteria (mint aged >= 300 s, >= 3 buys) and explicitly says it is not a check on your mint, distinguishing it from the paid sibling without opening schemas.

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

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

Explicitly says to use it to preview every field before paying, and gives the when-not condition: the server picks the mint, so it is not a check on yours. The paid mint_risk_card is named as the alternative shape, making the routing clear.

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

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

Annotations only cover the generic safety profile; the description adds real operational context beyond them: a $0.10/30-day charge, a test message sent first with failed tests left unpaid, and a hard cap of 20 messages per hour. These are behaviors an agent could not infer from 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?

Pricing is front-loaded, then the when-to-use clause, then input shape, then test-message and rate-limit details. Every sentence carries distinct information with no filler.

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

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

For a paid, open-world mutation tool with a full schema and an output schema, the description covers cost, auth/destination handling, test semantics, and rate limits. Nothing needed to invoke it correctly is missing.

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

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

Schema description coverage is 100%, so the schema already documents destination syntax, kinds enum, and all filter parameters. The description restates destination format and 'kinds' but adds no syntax or constraint information the schema lacks; baseline 3 is appropriate.

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

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

States a specific verb+resource (subscribe for push alerts to Discord/Telegram) with concrete scope: pump.fun and Robinhood Chain alerts, no server required. No sibling tool does push delivery, so the agent can distinguish it immediately from the query-style tools in the list.

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 a clear triggering condition: 'Use when a Discord or Telegram room you own should get pump.fun and Robinhood Chain alerts without a server.' It does not name alternatives or exclusions, but the condition is specific enough to route correctly.

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?

Adds substantial behavior beyond the annotations: the 0.25% / 25 bps disclosed fee destination, the fact that it holds no keys, that the output is an UNSIGNED transaction, and the refusal policy. readOnlyHint=true is consistent with a builder that returns an unsigned tx and mutates no state, so there is no contradiction.

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

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

Front-loads 'Free. Use it when...' and every clause carries information (fee, key custody, refusal, mode split). It is dense and semicolon-heavy, bordering on run-on, which costs it the top score.

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 5-parameter tool with an output schema, the description covers the essential context: fee, mode behavior, refusal conditions, and key custody. It leaves 'avoid/block' undefined (presumably a verdict signal from a sibling tool), which is a minor gap rather than a blocker.

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

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

Schema description coverage is 100%, so the baseline is 3. The description earns extra credit by explaining the semantic split of the optional wallet parameter (quote mode vs. unsigned-swap mode) and the reserve sources used for estimates, which the schema only gestures 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 (build a Solana swap for a pump.fun token) and splits the behavior precisely: quote without a wallet, unsigned Jupiter swap with one. An agent can distinguish it from discovery tools like pumpfun_recent_launches or risk tools like check_pumpfun_risk 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 clear triggering context ('when you buy or sell a pump.fun token (curve or PumpSwap pool)') and an exclusion ('Refused on avoid/block'), plus the wallet/no-wallet branching. It does not name a sibling alternative explicitly, so it falls short of the 5 bar.

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), so the description earns credit for adding real behavioral context: the exact verdict vocabulary, the coverage field, and the important limitation that certain Solana mints get only a 'thin on-chain answer'. The 'Not a safety verdict' disclaimer is genuinely useful. It does not disclose rate limits or latency, which is a minor gap.

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

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

Front-loaded with 'Free' and the check scope, and the sentences are dense with no filler. The upsell sentence listing four sibling prices is slightly cluttered but still earns its place for routing.

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?

An output schema exists, so return values need not be explained, and the description still names the verdict values and coverage. Combined with annotations and rich schema descriptions, an agent has enough to call this correctly; only escalation criteria between the paid siblings remain underspecified.

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

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

Schema description coverage is 100%, and the schema already documents accepted link formats and length constraints in detail. The description repeats that a mint or link is accepted, adding little beyond the schema, so the baseline of 3 is appropriate.

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

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

The description states a specific verb and resource: a 'coarse pre-trade rug check for one token' across two chain types, with the accepted identifiers named. It's differentiated by being the free, coarse tier, but the sibling landscape (verdict, mint_risk_card, etc.) is only referenced by price in the upsell line, not by function.

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

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

'Use it first before you buy' gives a clear triggering context, and the 'thin on-chain answer...never avoid on that evidence' clause tells the agent what NOT to conclude. It names next-tier alternatives by price but does not describe when to escalate to verdict vs mint_risk_card vs rhc_curve_card.

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 annotations already covering readOnly/idempotent/destructive/openWorld, the description still adds real behavioral context: a per-call price ($0.01), a refusal path for uncovered or stale mints before payment, and the fact that a free card page is produced. It also disclaims that no_flags_observed is not a safety guarantee, which meaningfully corrects a likely misreading of the verdict label.

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 front-loaded with price and the core question, but 'no_flags_observed is not a safety guarantee' is stated twice in near-identical form, and the trailing 'Fields: loopholetape://schema/verdict.' is cryptic and under-explained. The repetition costs it a point.

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?

Because an output schema exists, return values need not be spelled out, yet the description still enumerates the three verdict outcomes and the refusal case for uncovered mints. Combined with the price and card-page note, an agent has enough to decide and invoke, though the missing sibling routing keeps it short of 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?

There is a single parameter with 100% schema description coverage, so the schema already documents that it accepts a mint or a pump.fun/gmgn/solscan/birdeye link and that check_coverage should be called first. The description adds no further parameter-level meaning, so the baseline of 3 applies.

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

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

It names a concrete verb and resource: a rug-check/safety verdict for ONE pump.fun mint, enumerating the outcome labels (avoid, caution, no_flags_observed). The scope qualifier 'ONE pump.fun mint' implicitly separates it from batch siblings like check_batch_risk, but no sibling is named explicitly (e.g. check_pumpfun_risk, token_check, mint_risk_card), so the differentiation is left to inference.

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

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

'Use when you need one bounded answer before you buy or hold it' gives a clear trigger context, and 'Uncovered or stale: refused before payment' usefully flags a precondition. However, no alternative tool is named and no when-not guidance is given, even though siblings such as check_pumpfun_risk and token_check appear to overlap.

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, non-destructive, open-world), but the description adds genuinely new behavioral context: cost per call ($0.02), the classification categories returned, and that a stale feed is 'refused before payment' so no charge occurs. This goes beyond what annotations provide.

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 cost and purpose, then moves to exclusion, input format, payment behavior, and schema reference in a tight, waste-free sequence. 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?

An output schema exists, so return-value explanation is unnecessary, and the description points to it via the loopholetape schema reference. Cost, usage, exclusion, input, and stale-feed behavior are all covered, leaving nothing an agent needs 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 a single parameter at 100% schema coverage, the schema already documents the base58 address (32-44 chars) fully. The description's 'Input: address (base58 wallet)' merely restates the schema rather than adding format or validation detail, so the baseline of 3 is appropriate.

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

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

States a specific verb and resource: classify a wallet that buys pump.fun tokens into named categories (insider, latency_bot, skilled) and read its PnL. It explicitly distinguishes itself from sibling mint-risk tools with 'Not a mint's risk', so an agent can tell it apart without opening other schemas.

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

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

Gives clear context for use ('classify a wallet that buys pump.fun tokens' and read PnL when it ranks on the leaderboard) plus an exclusion ('Not a mint's risk'). It stops short of naming the specific alternative tool an agent should use for mint risk, so it doesn't reach a full 5.

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

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

Annotations already declare readOnly/openWorld/idempotent, but the description adds genuinely non-structured behavior: the cursor expires after 24 h, polling should be 15 s or slower, and an unchanged watched set yields an unpaid result. It does not, however, state what happens on mint-set changes or errors.

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

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

Four tight sentences, front-loaded with 'Free.' and the paid/free boundary. Every clause carries information: scope, payload type, lifetime, cadence, use case. 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 an output schema present, return-shape detail is unnecessary and correctly omitted; the description still clarifies the semantic nature of the return (existence, not contents). Only the polling/expiry edge cases and failure behavior are left thin.

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

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

Schema coverage is 100%, so the baseline is 3, but the description adds real meaning: the cursor is bound to one to five mints and only lives 24 h, and mints must be held positions. That constrains how the opaque cursor parameter should be reused between calls.

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 (start/poll), resource (watch cursor), scope (one to five mints) and the crucial distinction that it reports *whether* events exist rather than *what* they are. An agent can separate this from the paid event-returning siblings without opening 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?

Gives concrete when-to-use guidance: 'Use it to watch held mints without paying.' It also implies the alternative (a paid check that returns event contents) but never names a sibling tool, so routing between watchlist_updates, check_watchlist_risk and subscribe_alerts remains partly inferential.

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