Toll

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

Annotations already declare readOnlyHint=true, openWorldHint=true, idempotentHint=false and destructiveHint=false, so the safety profile is covered. The description adds useful context that this is a live, right-now snapshot computed by Toll's engine, but it never states whether values are cached, how often they refresh, or the snapshot timestamp. Behavioral value added is modest relative to the annotation coverage.

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

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

One front-loaded sentence that leads with the headline ('How busy Robinhood Chain is right now') before the metric list, and the scope caveat is attached at the end. It is dense but every clause names a distinct returned metric, so little is wasted.

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

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

With no output schema, the description carries the return-value burden and does so by enumerating the metric families an agent can expect. It lacks freshness/latency expectations for a 'live' feed, which would be the last piece needed for full confidence in a no-argument tool.

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

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

The tool takes zero parameters, so per the rules the baseline is 4. The description correctly implies no filtering arguments are available, keeping the parameter story consistent with the empty 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 subject (real-time activity metrics on Robinhood Chain) and enumerates the concrete signals returned (launches, graduations, pools, trades, volume). Scope is pinned with 'Robinhood Chain only'. It stops short of distinguishing itself from the sibling fresh_launches, which appears to overlap with the 'launches in the last 5 minutes' portion.

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

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

There is no explicit when-to-use guidance and no routing to alternatives. The only boundary stated is a data-scope limitation ('Robinhood Chain only'), which is a constraint rather than usage direction. An agent must infer on its own when this summary beats fresh_launches or launch_record.

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

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

Annotations already declare readOnlyHint, idempotentHint and openWorldHint, so safety is covered; the description adds genuinely new context: the data source (live census vs 2026-10-28 snapshot), the 'never a verdict' framing, and that last-checked/changed timestamps are included. It does not discuss rate limits, authentication, or behavior when an agent id does not exist, which keeps 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?

Content is front-loaded with the resource and scope, and every clause carries real information (largely acting as a return-value summary since there is no output schema). However, it is delivered as one long comma-chained sentence that is dense and harder to parse than a short structured list would be.

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

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

With no output schema, the description carries the full burden of describing return values, and it does so item by item: card load and host, classification, MCP initialize result, x402 payment terms and payTo identity match, wallet activity, and last-checked/change data, plus provenance. For a read-only single-parameter lookup this is complete enough to call and interpret without opening anything else.

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 whose schema description is fully covered (token id, range 0–1000000000, example 20030). The prose only restates that the input is the agent id in the identity registry, adding no format or edge-case detail beyond 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?

The description names a specific verb (fetch/check) and a precisely scoped resource: one ERC-8004 agent on Robinhood Chain, identified by agent id, including the identity registry address. It enumerates exactly what is returned (card load, class, MCP initialize, x402 402 response, payTo vs agentWallet, wallet activity, last-checked/changes), which cleanly separates it from siblings like check_coin, check_tx and larp_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?

Usage context is clear: it is scoped to Robinhood Chain only, framed as plain census facts rather than a verdict, and it discloses that data may come from the live census or a dated snapshot. It never explicitly names an alternative sibling or states when-not to use it, so it stops short of 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, open-world, non-destructive, so the safety profile is covered. The description earns credit by disclosing what the analysis actually contains, the verdict taxonomy (AGAINST/CAREFUL/CLEAR/INCOMPLETE), the meaning of INCOMPLETE, and that the first answer line names the chain.

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

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

The verdict and tally explanation is valuable and front-loaded information about findings is decent, but the text repeats 'On Robinhood Chain' three times and packs a long clause-heavy list mid-paragraph. It could be tightened substantially without losing content.

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

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

There is no output schema, so the description must carry return-value semantics, and it does reasonably: it lists the finding categories, explains the tally and the verdict line, and warns about partial reads. Only the shape of individual fields (e.g. how 'what the maker holds and sold' is expressed) is 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 description coverage is 100%, so the baseline is 3: the schema already explains that chain is 'rh = Robinhood Chain (4663)' and may be omitted for auto-detection. The prose repeats the read target ('Reads Robinhood Chain (4663)') without adding format or behavior 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 ('Check one token on Robinhood Chain') and enumerates the subject matter it reports on (maker, launch record, snipers, bundles, flagged wallets, holdings, burned supply, curve/pool). This clearly separates it from siblings like check_tx, check_agent and check_hook, though the repetitive 'On Robinhood Chain:' phrasing dilutes rather than sharpens the opening.

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?

Implicitly scopes use to a single token contract rather than a transaction or wallet, and gives one useful operational rule: an INCOMPLETE verdict must not be read as clear and 'says when to call again'. It never names an alternative sibling (e.g. dev_record, launch_record) or says when to prefer those, so selection guidance is only partially covered.

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

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

Goes well beyond the readOnly/openWorld annotations: discloses the 24-hour cache window, that stale entries return "not read yet", the exact verdict vocabulary (AGAINST / CAREFUL / CLEAR / INCOMPLETE) with tally and read age, and that no credits are consumed. This is the kind of context annotations cannot convey.

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

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

One dense paragraph, front-loaded with the scope and the cache-only constraint before the return shape and the fallback route. Every clause carries information, though the parenthetical about the 24 h window 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?

No output schema exists, so the description carries the return contract and does so fully: verdict word, tally, and read age per coin, plus the "not read yet" state. Combined with the cache/no-cost behavior, an agent has everything needed to call and interpret it.

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

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

Schema coverage is 100%, so the address format is already documented; the description nevertheless adds the meaningful cap of 20 coins per call. That cap conflicts with the schema's maxItems: 100, which could confuse an agent about the true limit, costing it a point.

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 and resource: return verdicts for up to 20 Robinhood Chain coins in one call, served only from Toll's existing cached checks. It also distinguishes itself from single-coin siblings by naming check_coin and pre_buy_check as the route for unread coins.

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 it reads nothing new, spends no free coin, and that unread coins should go to check_coin or pre_buy_check. The one gap is that it never states the batch-scan scenario is preferable to looping check_coin, so the choice for a single coin remains implied rather than stated.

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 carry readOnly/idempotent/non-destructive, yet the description adds real behavior: three data sources for the name (contract getter, Blockscout, Sourcify), an auth-dependent tier ('with a $TOLL holder's Toll key: also…'), and a framing rule ('Facts, never a verdict'). That gating and provenance disclosure is information the agent cannot get from the annotations.

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

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

The core identity and input are front-loaded, and every enumerated field maps to something the tool actually returns, so little is wasted. The weakness is that it is one long run-on sentence with stacked parentheticals, which makes scanning harder than a short structured list would.

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

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

With no output schema, the description carries the return-value burden and does so thoroughly, including conditional fields and the 24h-scored launch record. What is missing is failure handling: nothing says what happens for a non-hook address, a wrong-chain address, or a hook with no pools.

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 and the schema already specifies the format ('0x followed by 40 hex characters') at 100% coverage. The description only restates 'by its contract address' and adds no meaning about the argument beyond 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+scope: 'One Uniswap v4 hook on Robinhood Chain, by its contract address', then enumerates exactly what comes back (name and its provenance, permission bits, proxy/clone status, pool count, test-sell result). This cleanly separates it from siblings like check_coin, check_tx and check_agent, which address different entities.

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 is only implied: you have a hook contract address on Robinhood Chain and want facts about it. The scope constraint 'Robinhood Chain only' is a useful boundary, and the note that extra measured fields need a $TOLL holder's Toll key tells the agent about a conditional. But there is no explicit when-to-use/when-not or named alternative (e.g. check_coin for the token side, presign_risk_report for a scored verdict).

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 establish read-only, non-destructive, open-world; the description adds the substantive behavior: what categories get inspected (approvals, transfers, swaps, x402 payee verification), the fail-safe rule that undecidable calldata and in-progress coin reads degrade to WARN with a wait time, the BLOCK threshold for coin findings, and that payee data is read live from the Robinhood Chain or Base identity registry with the outcome in x-toll. The read-only hint is consistent with a check that returns a verdict rather than executing anything.

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

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

The lead clause is well front-loaded, but the remainder is two enormous sentences dense with nested parentheses and unexplained acronyms (ERC-8478, ERC-8004, x-toll). Content like the 40% rug calibration is useful but buried mid-sentence where an agent skimming for a verdict rule may miss it. Breaking the ALLOW/WARN/BLOCK rules into discrete statements would improve it materially.

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 10-parameter tool with nested objects and no output schema, the description does the heavy lifting: it states the return shape, the verdict semantics, the failure modes, and the chain restriction. Gaps remain around strict (a policy switch that changes a warning into a BLOCK) and around what happens when no input mode is supplied, neither of which is addressed.

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

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

Schema coverage is 100%, so baseline would be 3, but the description adds real semantics the schema lacks: it groups parameters by input mode (to/data/value/from for transactions, typedData for EIP-712, x402 plus optional agentId for payments) and enumerates the accepted typedData primaryTypes (Permit, Permit2, TransferWithAuthorization), which the schema does not. It never explains strict or registry as inputs, so coverage of meaning is partial.

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

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

The description names a specific verb-scope (pre-sign check), a specific chain (Robinhood Chain, chain id 4663), the three accepted input modes (transaction, EIP-712 typedData, x402 payment) and the output shape (ALLOW/WARN/BLOCK with reasons, as an ERC-8265 RiskAssessment). That is far beyond a restatement of the name. It does not, however, distinguish itself from the sibling presign_risk_report, which an agent could plausibly pick instead.

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

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

The trigger is explicit and front-loaded: call it before an agent signs anything. The scope limits ('Robinhood Chain only', and the note that unreadable calldata is WARN, never ALLOW) tell the agent when the answer is untrustworthy. It names no alternative tools and gives no when-not-to-call guidance relative to check_coin, check_agent or presign_risk_report.

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 useful content disclosure — counts, graduation status, whether the dev sold, and how the latest launches ended — but says nothing about ordering, limits on 'latest', or error behavior for a wallet with no launches.

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?

Short and front-loaded with the scope statement first, then the returned facts. Minor redundancy: 'on Robinhood Chain' appears in back-to-back sentences, and the second sentence is a compressed list rather than clean prose.

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

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

No output schema exists, so the description carries the return-value burden and does so by enumerating the aggregate and listing fields. It is nearly complete for a two-parameter read tool; only limits on the 'latest launches' list and empty-result behavior are unaddressed.

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

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

Schema description coverage is 100%, so both parameters are already documented (wallet 0x-pattern, chain rh=4663 with default). The description only restates 'one wallet' and 'Robinhood Chain', adding no syntax, case-sensitivity, or defaulting insight beyond the schema, 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?

Opens with a specific verb-resource framing: every coin a given wallet deployed on Robinhood Chain, plus aggregate stats (count, bonding-curve graduations, dev-sold flag, latest launches and outcomes). The deployer-wallet scope distinguishes it reasonably from siblings like launch_record or check_coin, though it never names those siblings 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?

There is no when-to-use or when-not-to-use guidance at all. The description never points to launch_record, check_coin, fresh_launches, or wallet_privacy as the alternative depending on whether the agent wants a single coin, a single wallet's general activity, or a dev's launch history.

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

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

Annotations already declare readOnlyHint=true, openWorldHint=true, idempotentHint=false and destructiveHint=false, so safety is covered. The description adds real context beyond that: the live engine as data source, freshness implied by 'newest first', the 20-item cap, and the per-coin fields returned (launchpad, age, pair, notes, link).

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

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

A single dense sentence front-loads the core purpose and packs scope, ordering, source, return fields and cap without padding. Slightly run-on, but every clause carries information.

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

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

With no output schema, the description does the work of naming the returned fields (launchpad, age, pair, engine notes, link) and the result cap, and it states the chain restriction. Only minor gaps remain, such as whether the feed is paginated or how 'live' is refreshed.

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 single 'limit' parameter is fully documented (1-20, default 10). The description only echoes the cap with 'At most 20', adding no new syntax or default information beyond the schema, so baseline 3 applies.

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

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

The description states a specific resource and scope: the newest coins launched on Robinhood Chain, newest first, drawn from Toll's live engine. It is clearly a launch-feed listing rather than a single-coin lookup like check_coin, though it never names a sibling to sharpen the contrast.

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

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

Usage is implied by 'newest coins ... newest first' and the 'Robinhood Chain only' constraint, but there is no explicit when-to-use, when-not, or alternative (e.g. use check_coin for a full audit of one token). The agent must infer the routing.

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

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

Annotations already cover safety (readOnlyHint, non-destructive), so the bar is lower, and the description adds real behavior: derived values are labelled, EPS is never summed across quarters, market cap and P/E appear only when share count, multiplier and a live reference align, otherwise the reason is returned. That conditional-availability disclosure is exactly what an agent needs to interpret output. It stops short of stating error behavior for unknown tickers or the cost/latency of EDGAR lookups.

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

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

The identity of the tool and its source are front-loaded, which is good, but the whole payload enumeration is delivered as one long semicolon-chained run-on sentence with nested parentheticals. Every clause is informative, yet the structure makes it hard to parse at a glance and would benefit from being split.

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

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

With no output schema, the description carries the return-value burden and does so thoroughly — it enumerates every metric group, the period semantics, derived labelling, and conditional market-cap/P-E behavior. The remaining gap is failure modes (unknown ticker, no EDGAR filings, non-US filers beyond 'say so').

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 both the id format (ticker or 0x contract) and the three period values, so semantic burden is largely carried there. The description reinforces period meaning ('four contiguous quarters', 'TTM to <end>') but adds little the schema does not already state; 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?

It names a specific resource (SEC EDGAR XBRL fundamentals for one Robinhood Stock Token) and enumerates the exact metrics returned, which separates it from the plural listing sibling stock_tokens and from stock_token metadata. The verb is implicit ('the company numbers behind') rather than a crisp 'returns', but the scope is unmistakable.

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

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

Usage is only implied: an agent can infer this is the financials tool rather than the token-metadata tool, and the ttm/annual/quarterly hint at depth choices. There is no explicit 'use this when…, use stock_token when…' routing, and no mention of what happens for tickers with no filings.

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

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

Beyond the readOnly/openWorld annotations, it discloses extraction methodology (a model selects the sentence or table cell, code reads the number), validation rules (unreadable figures and XBRL-disagreeing GAAP lines are dropped), quote length, filing links, and coverage limits. This is rich behavioral context and is consistent with readOnlyHint=true.

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

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

The description front-loads its purpose but is a dense, single paragraph with several parentheticals. Disclaimers such as 'Facts, not advice' and 'Quotes are the company's words' add little, and the structure could be cleaner for such a detail-heavy tool.

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

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

No output schema exists, so the description must explain returns, and it does: periods, quotes, filing links, validation drops, and coverage of the last four releases. It also covers both parameters and exclusions, making it complete enough for an agent to call 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 parameters are already described in the schema. The description mostly repeats the limit range and id forms, adding little syntax or meaning beyond what the schema provides, 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?

The description states the tool returns forward guidance, KPIs, non-GAAP measures, and reconciled GAAP lines from the last four earnings releases for a ticker or token contract. That is a specific resource and scope, but it does not name the sibling tools (e.g., fundamentals) it should be chosen over, so it stops short of full sibling differentiation.

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

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

It gives clear operational context: read once per release, and funds and foreign issuers (6-K) are not covered. It does not explicitly route the agent to an alternative when those exclusions apply, so alternatives are left implicit.

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, non-destructive, open-world), so the description's added context is what counts — and it delivers: row cap of 40, window disclosure, 4/A superseding the original, signed share counts, 'see footnote' prices, and P/S totals. It doesn't mention ordering or what happens when no filings exist.

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 and no filler, but the entire body is one semicolon-chained sentence that is dense to parse. Efficient, though a break into return-contents vs. caveats would help.

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

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

There is no output schema, and the description compensates by enumerating the returned fields (owner/relationship, date, transaction code, shares, price, holdings after, 10b5-1 flag, filing link) plus the 13D/G section. An agent knows exactly what it will get before calling.

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 are already documented, including the ticker-or-contract format for id. The description only restates the limit range and default, adding no meaning beyond the schema — 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 precise verb+resource: insider trades at the company behind a Robinhood Stock Token, sourced from SEC Form 4 filings over the last 90 days. Highly specific about scope and contents, though it never names a sibling (e.g. fundamentals or stock_token) to contrast with, so differentiation is inferred 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?

Implies usage through scope statements (90-day window, newest 40 rows, Schedule 13D/G included) and gives one useful when-not caveat ('Foreign filers file no Form 4'). It does not explicitly say when to prefer this over fundamentals or stock_token, so the agent must infer 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 this a read-only, open-world operation, and the description adds substantial behavior beyond them: only managers filing both quarters appear in the change column, a first-time filer is labeled, a suspicious thousands-scaled value is flagged, and every response is prefixed with a fixed quarter/publish-date sentence. It also explains the non-idempotent feel (latest quarter changes) and the exact degraded-case message.

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

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

Purpose and key qualifiers are front-loaded and every clause carries information (quarter semantics, exclusions, error case). The delivery is one dense run-on sentence chain, which slightly hurts scanability for a tool with only two parameters.

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

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

There is no output schema, so the description carries the burden of describing return content, and it does: per-manager share counts plus prior-quarter change, totals, filer counts, flagged anomalies, and the mandated leading sentence. Combined with the unmapped-ticker explanation, an agent has everything needed to call and interpret it.

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

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

Schema coverage is 100% and both parameters are already described there, including the exact ticker/contract format and the 1-20 range with default 10. The description adds only marginal semantics beyond the schema (that limit selects the top managers ranked by shares), 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?

States a specific verb+resource: institutional holders from SEC quarterly Form 13F data sets for the company behind one Robinhood Stock Token. It names the accepted key forms (ticker such as NVDA or 0x contract) and the exact payload (top managers by shares, quarter-over-quarter change), which distinguishes it from siblings like insider_trades or fundamentals without opening their 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 usage context and exclusions: options (puts/calls) excluded, amendments applied, funds and foreign issuers not covered, and a ticker without a reviewed CUSIP returns '13F not mapped'. What it lacks is explicit routing to an alternative sibling (e.g. insider_trades for Form 4, fundamentals for financials), so the agent must infer the boundary.

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, non-destructive and open-world behavior, yet the description adds substantial context beyond them: an asynchronous queue for never-before-read coins, a returned wait time before retry, a free-tier quota of 10 new coins per day with already-read coins free, and the caveat that results are "never a verdict." The queueing also explains the otherwise puzzling idempotentHint=false, though the description does not say what happens when the quota is exhausted.

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

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

The purpose is front-loaded in the opening clause, but the body is one long run-on sentence with stacked parentheticals (app page, API, MCP server, x402 payments, Chrome extension, Telegram bot, public code) that is hard to parse on a single read. The rate-limit and quota details earn their place, but the delivery could be split into shorter, scannable statements.

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

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

With no output schema, the description carries the return contract and does so well: the label set (product found / partly found / not found / not read), per-claim verdicts with the supporting line, and which components answered. Combined with queueing and quota behavior, an agent has enough to call and interpret it; only edge cases like quota exhaustion or unreadable sites remain 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 description coverage is 100%, with both parameters documented in the schema (chain defaulting to rh, token requiring a 0x contract address), so the baseline of 3 applies. The description contributes no additional parameter meaning such as accepted identifier forms or chain values beyond what the schema already states.

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: it reads a coin's site, launch post and README, then checks each stated claim against the chain and against live components. The framing question ("is there a real product behind a coin on Robinhood Chain?") makes the intent unmistakable, but it never names or contrasts with a sibling such as check_coin, so an agent must infer the boundary.

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

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

Usage is implied rather than stated: it is for a coin on Robinhood Chain whose product claims you want verified, and the polling instruction ("the answer says how many seconds to wait before calling again") is genuinely actionable. However, there is no explicit when-to-use versus check_coin or check_tx, and no stated conditions where this tool is the wrong choice.

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

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

Annotations already cover read-only, idempotent, non-destructive, open-world. The description adds the key behavioral fact annotations cannot express: the data is 'frozen and never edited' at launch time and includes a 24-hours-later outcome, so the agent knows it is a historical snapshot, not live state. No return-format or pagination detail, but the snapshot semantics are the important disclosure here.

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

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

The core distinction from check_coin is front-loaded and useful, but the middle clause ('against / careful / clear (or launch facts only), the findings tallied, why...') is dense, elliptical, and hard to parse on first read. The information earns its place; the phrasing does not.

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

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

There is no output schema, so the description carries the burden of saying what comes back, and it does enumerate the payload: launch facts, tallied findings/rationale, dev and funder's other coins of the week, and the 24h outcome. Combined with the annotations and fully documented single parameter, an agent has enough to call it correctly.

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

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

Schema description coverage is 100% and the sole address parameter carries its own pattern and format documentation. The description adds no syntax or validation detail beyond that, so baseline 3 applies; it does reinforce the Robinhood Chain scoping of the address.

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 conveys a specific resource: a frozen, point-in-time record of a coin's launch call on Robinhood Chain, including findings, rationale, dev/funder history, and 24h outcome. It explicitly distinguishes itself from check_coin ('Not the coin now'), though the phrasing is idiosyncratic rather than a clean verb+resource statement.

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 names the alternative explicitly ('use check_coin for that') and states a hard scope constraint ('Robinhood Chain only'), which is exactly the routing information an agent needs. It stops short of an explicit 'use this when...' trigger, but the implied context (historical launch snapshot vs. live state) is clear.

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

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

The annotations already cover the safety profile (readOnlyHint true, destructiveHint false, openWorldHint true), so the description's job is to add context beyond that. It does: it states that there is no input ("No input"), that every figure carries its own date (freshness semantics), that "P = preliminary" flags provisional values, and it discloses the EFFR Terms of Use plus the NY Fed non-affiliation. It stops short of describing the shape or units of the returned payload, which matters because there is no output 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?

It leads with the useful framing (what the figures are, sourced from primary public data, each with its date), which is well front-loaded. But it then strings everything into one long run-on sentence, and the closing "Toll is not affiliated with the New York Fed" legal disclaimer adds little for tool selection.

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

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

With no output schema, the description has to carry the return-value burden, and it does: it enumerates each series returned (yield curve maturities 1m-30y, EFFR plus target range, CPI-U YoY, unemployment rate, NFP monthly change) and notes the date on each. The remaining gap is the payload's shape and units (percent vs thousands of jobs), which an agent would still have to discover by calling it.

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

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

The schema has zero parameters and the description explicitly states "No input." That confirms the tool takes no arguments, so the baseline of 4 applies with no ambiguity for the agent.

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 the specific datasets it returns: the Treasury daily par yield curve, the NY Fed EFFR with its target range, and BLS CPI-U, unemployment, and nonfarm payrolls. This is a concrete statement of the resource. However, it does not explicitly contrast the tool with siblings such as fundamentals or stock_token, so the agent must infer that this is the market-wide macro series rather than per-token data.

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?

Naming the audience ("agents reading Robinhood Stock Tokens on Robinhood Chain") and calling the sources "public primary sources" implies when the tool fits: macro context attached to token research. But there is no explicit rule for when to call it versus siblings such as fundamentals, and no stated exclusion or prerequisite. Usage is therefore implied rather than directed.

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

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

Annotations already cover read-only and idempotent safety. The description adds crucial output behavior: the four decision states, up to 3 reasons ordered by severity, the BLOCK threshold, WAIT retry semantics, and the ALLOW caveat. That is rich context beyond structured fields.

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

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

The description is front-loaded with the core action and remains dense with useful detail. It could be slightly easier to scan, but every sentence contributes to correct invocation and interpretation.

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 gate tool with no output schema, the description explains the return values, retry conditions, and limitations. Combined with annotations that cover safety, an agent has everything needed to call and interpret it.

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

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

Schema coverage is 100% and the single address parameter is fully described in the schema. The description does not add syntax or meaning beyond what the schema already provides, so baseline 3 applies.

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

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

States a specific verb and resource: a single gate call before buying a coin, and it answers a Decision. It explicitly differentiates from check_coin (same read) and check_tx (rules used), so an agent can select it over siblings.

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

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

Clear when-to-use: one call before buying on Robinhood Chain. It references check_coin as the underlying read but does not spell out when to skip this gate or use presign_risk_report instead; still, the context is strong.

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

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

Annotations only declare read-only/open-world/non-destructive; the description adds substantial context beyond them — that every finding is read at one pinned block, that the report is bound by digest and EIP-712 signed by a named ERC-8004 agent, and that the tool deliberately returns no verdict. This explains the non-idempotent hint (state-dependent reads) as well.

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

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

Purpose is front-loaded in the first clause and the routing guidance is placed at the end where it matters. The middle is dense jargon in one long sentence, and the parenthetical finding list is lengthy, though each item is informative rather than 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?

There is no output schema and the tool takes nested objects, yet the description compensates fully by enumerating the report's finding categories and their interpretation caveats. An agent could call this correctly and reason over the response without further documentation.

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

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

Schema coverage is already 100%, so the baseline is 3, but the description adds real meaning: it lays out the PresignRequest shape (version, subject with calls/typedData, optional context with payment/texts/tokens) and enumerates which facts each read yields. The optional top-level 'kinds' filter is left to the schema, keeping it below a 5.

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 verb+resource pair (send a PresignRequest, get a PresignReport) and enumerates exactly what the report contains. It explicitly distinguishes itself from the sibling check_tx, which returns a verdict rather than raw facts.

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 an explicit when: use this when you want typed facts and will apply your own policy. Gives an explicit when-not plus the alternative: 'For an ALLOW / WARN / BLOCK answer use check_tx (which carries this report too).' It also warns how to interpret missing findings ('treat not read as unknown, never as clean').

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, non-destructive, open-world, non-idempotent), yet the description adds substantial behavior the annotations cannot: oldest-first ordering, cursor semantics tied to the previous answer, freshness/access tiers, and the caveat that funds without an SEC CIK produce no filing events. It also defines the trigger condition for feed_stale/feed_paused (a Chainlink feed past its heartbeat while a session is open). Return shape is only partly sketched (id, at, discovery time), keeping it just 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?

The lead clause front-loads the resource and the event taxonomy well, but the rest is a dense chain of parentheticals and semicolon-joined clauses that is harder to parse than it needs to be. The 'Facts, not advice' closer and some tier detail could be trimmed without losing selection-relevant meaning.

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

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

For a three-parameter, no-output-schema feed tool, the description covers ordering, cursor pagination, filtering, freshness by tier, and a real coverage limitation (no CIK → no filings), plus a partial sketch of returned fields. An agent can call this correctly and interpret staleness without any other source.

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 kind, limit, and since, including the keyless-preview override — the baseline of 3 applies. The description's added value is modest: it explains what the kind values mean in the world (corporate_action = status changes, filing = 8-K/10-Q/10-K/Form 4/13D/G by acceptance time) and reiterates the 'since = last answer's next' cursor, but adds no syntax or edge cases beyond the schema.

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

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

The description names a concrete resource and scope — 'What changed on Robinhood's Stock Tokens on Robinhood Chain' — and enumerates the exact event kinds (listed, delisted, multiplier_scheduled, feed_stale, filing, etc.), so the agent knows this is a change feed rather than a token lookup. It never names siblings like stock_token or stock_tokens, so differentiation from them is inferred 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?

Usage is implied rather than prescribed: polling for newer events via 'since' and narrowing via 'kind' are described, but there is no explicit 'use this instead of X when Y'. The tier rules (Team live, Pro 15 minutes late, keyless = last 10 events an hour old) do tell an agent when the answer will be stale, which is useful context but not a when-to-use rule.

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

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

Annotations already declare readOnlyHint=true and destructiveHint=false, so safety is covered. The description adds genuinely non-obvious behavior: every value carries a source and timestamp, unread values are explicitly declared as such, and the stale-price rule is spelled out (stale only past the feed's heartbeat while a session is open). It doesn't explain failure behavior for an invalid ticker/contract, which keeps 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?

It is one very long run-on sentence packing ~10 data categories plus a disclaimer. Almost every clause carries real information given there is no output schema, so it isn't padding, but the lack of any structural break makes it hard to scan and it is not front-loaded beyond the opening identity clause.

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

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

With no output schema, the description carries the full burden of describing the return and does so field by field (listing, Chainlink price with age, pool price/venue/liquidity, spread, supply, oracle pause, corporate actions, SEC EDGAR data). What's missing is only the error/not-found path for an unrecognized ticker or contract.

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 `id` parameter is fully documented including the '0x' + 40 hex contract form. The description repeats the ticker/contract duality with the same examples (NVDA, AAPL) rather than adding format details the schema lacks, 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?

Opens with a precise verb-less but specific identity statement: 'One Robinhood Stock Token ... by its ticker ... or its token contract', and even defines what the asset legally is (debt instrument, not a share). The singular 'One' implicitly separates it from the sibling stock_tokens, but that contrast is never made explicit, so it falls short of a 5.

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

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

Usage is inferable — look up a single token by ticker or contract — but the description never states when to prefer this over stock_tokens for listing, nor any preconditions. No exclusions or alternatives are named despite the sibling's near-identical name.

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?

While annotations already cover safety (`readOnlyHint: true`), the description provides significant behavioral context by listing the specific data points returned (e.g., Chainlink reference price, SEC filings count, corporate actions). This informs the agent exactly what kind of data aggregation to expect.

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

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

The description is dense but highly efficient. It front-loads the nature of the data and the function of the parameters before adding the specific instructions for usage and tool differentiation, minimizing unnecessary jargon.

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?

Since there is no output schema, the description is highly complete, detailing the core attributes of each token object returned (ticker, issuer's name, contract, reference price, status, and action counts). This allows the agent to understand the data structure without external documentation.

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

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

Even though schema coverage is 100%, the description adds semantic value by explaining the purpose of the query parameter—it allows filtering by either ticker or partial company name (e.g., 'NVDA, nvidia'). This context helps an agent choose the correct query format.

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

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

The description clearly identifies the resource (Stock Tokens listed on Robinhood Chain) and provides necessary context (details returned, filtering capabilities). Crucially, it distinguishes this listing function from the singular `stock_token` tool sibling, making it immediately clear what this tool achieves.

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

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

It provides explicit instructions on how to use the filtering parameters: `query` for ticker/name matching and `limit` for quantity. It also provides an explicit usage guideline for when *not* to use this tool, directing the agent to `stock_token` when a single item is needed.

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

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

Annotations already declare readOnly, idempotent, openWorld, and non-destructive, so the safety profile is covered. The description goes beyond that by disclosing the categories of 'leaks' surfaced (funder, linked wallets, holdings, active hours, launches, trading record, linked accounts) and an important interpretive caveat that the grade measures visibility rather than wallet quality, which prevents misuse of the result.

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

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

Two sentences, front-loaded with the returned artifacts and followed by the interpretive caveat and scope. The chain scope is stated twice ('from Robinhood Chain alone' and 'Robinhood Chain only'), a small redundancy, but nothing else 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?

There is no output schema, so the description carries the burden of describing the return and does so by naming each output component. Missing only finer details such as grade thresholds or the shape of the 'tips' payload, which are secondary for a one-parameter read 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?

There is a single parameter with 100% schema description coverage, so the schema already documents the 0x + 40 hex address format. The description adds no further parameter detail, which is acceptable given full coverage but earns only the baseline.

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

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

The description states a specific verb (analyze what anyone can learn) and resource (a wallet on Robinhood Chain), and enumerates the exact artifacts returned: a letter grade, a 0-100 score, individual leaks, and tips. It also scopes the analysis to Robinhood Chain data only, which separates it from the launch/coin-oriented siblings without ambiguity.

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

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

Usage is implied by the resource being a wallet and the phrase 'Robinhood Chain only', which tells the agent not to expect cross-chain coverage. However there is no explicit when-to-use statement, no exclusion language, and no routing to or from siblings such as dev_record or check_coin.

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