robinx-mcp

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

The description provides extensive behavioral details: what data is included (immutable launch facts, current activity, deployer track record, price, social measurements), explains the epistemic status of fields (current_state vs observed), and discloses costs. Annotations already indicate read-only, non-destructive behavior, and the description adds significant context beyond that.

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

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

The description is quite lengthy and dense with details. While it is front-loaded with the main purpose, the extensive enumeration of fields and warnings makes it less concise than ideal. Some information could be condensed without loss of clarity.

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

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

Given the single parameter and no output schema, the description fully compensates by detailing the output structure, costs, and usage caveats. It provides sufficient context for an agent to understand and invoke the tool correctly.

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

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

The input schema already describes the single parameter 'token' with format '0x + 40 hex'. Schema coverage is 100%, so the description adds minimal additional semantic value beyond confirming the chain and usage context.

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

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

The description clearly states that the tool returns a 'token-level feature row' for a Robinhood Chain token, ready for model input. It distinguishes from siblings by focusing on a single token's comprehensive data for feature engineering.

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

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

The description explicitly states when to use this (for model input), warns about lookahead bias and no predictions, and specifies it's for Robinhood Chain only. However, it does not explicitly contrast with sibling tools like robinx_token or provide when-not-to-use guidance.

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

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

Annotations already declare readOnlyHint=true, and the description adds context: it is 'free live forward', 'every launch from a proven deployer, entered +30min, held', and 'lookahead-free'. This provides behavioral specifics beyond the annotations, though it could mention data freshness or scope limitations.

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

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

Two concise sentences that front-load the core purpose and add a clarifying second sentence. No fluff or repetition.

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

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

Although the tool has no inputs and annotations cover safety, the description lacks details about the output format or fields of the record. Without an output schema, the description should at least enumerate what data points are included (e.g., token addresses, timestamps). Current description is 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?

The tool has zero parameters, so the description has no burden to explain them. According to the rubric, 0 params yields a baseline of 4.

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

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

The description states it provides a 'live forward paper-basket' and 'lookahead-free public track record', indicating a read-only record of signals. However, it does not explicitly distinguish this tool from siblings like robinx_signals or robinx_report, leaving some ambiguity about its specific role.

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?

No guidance on when to use this tool versus alternatives. With many sibling tools, the absence of usage context forces the agent to rely on the tool name alone, which is insufficient.

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. The description adds behavioral context beyond annotations by stating 'calls preserved as captured, so deletion does not scrub the record', indicating immutability, and mentions measurement against real on-chain prices. 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?

The description is concise, with four sentences each adding value. It front-loads the purpose, lists output fields, and ends with a usage guideline. No fluff.

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

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

Without an output schema, the description lists key return fields (early_rate, momentum_rate, median 1h forward return, etc.) and explains data source. This is sufficient for a report card tool, though some detail on output format is omitted.

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%, fully documenting the 'handle' parameter. The description does not add new semantic information about the parameter beyond what the schema provides, so it meets the baseline for high coverage.

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

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

The description explicitly states it provides a 'Free MEASURED track record' for an X account that called tokens, listing specific metrics like early_rate and momentum_rate. It distinguishes itself from siblings by focusing on a report card for a single caller, not a list of calls or callers.

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

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

The description includes 'Use before trusting any "alpha caller"' as a clear usage guideline. While it doesn't explicitly exclude other uses, this directive provides clear context for when to apply the tool.

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

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

Annotations already declare it read-only and non-destructive. The description adds value by disclosing that calls are preserved even if deleted, a $0.02 USDC cost, and a truncation flag for total count. This goes beyond annotations without contradiction.

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

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

The description is dense but not overly verbose. It front-loads the main purpose and then details output, cost, and behavior. It could be slightly more concise, but every sentence adds value.

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

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

Given no output schema, the description thoroughly explains return values: per-call outcomes, true total, truncation flag. It also covers cost, persistence, and the handle parameter. This is more than sufficient for a simple 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?

With 100% schema coverage and only one parameter (handle), the description adds meaning by explaining that the output includes per-call outcomes, true total, and truncation flag. This enriches the parameter's purpose beyond the schema's 'X handle, with or without @'.

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

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

The description clearly states the tool retrieves the most recent 100 measured Robinhood Chain calls for a given X handle, with per-call token outcomes. This distinguishes it from sibling tools like robinx_caller (individual caller info) and robinx_callers (list of all callers). The verb 'retrieves' and resource 'call log' are explicit.

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

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

The description implies usage via cost and persistence details, but does not explicitly state when to use this versus alternatives like robinx_caller or robinx_callers. It provides context (cost, record persistence) but lacks direct guidance on selection criteria.

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

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

Annotations already indicate readOnlyHint=true and destructiveHint=false. The description adds value by detailing the measurement criteria (median 1h forward return, early-rate) and noting the paid nature ($0.01). No additional behavioral traits like rate limits or data freshness are disclosed.

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?

Single sentence with parenthetical note is concise and front-loaded. Every part adds information without redundancy.

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

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

No output schema exists, so description must explain return values. It explains the metric and paid aspect but omits output format, number of entries, and data refresh frequency. Adequate but has clear gaps.

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

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

No parameters exist (schema coverage 100%). Baseline score of 4 applies per instructions; description does not need to add parameter semantics.

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

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

The description clearly states this is a leaderboard of proven callers measured by median 1h forward return and early-rate, distinguishing it from follower-count-based metrics. The verb 'leaderboard' and specific resource 'Proven X caller-lift' provide clear purpose.

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

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

The description implies use for getting a leaderboard of callers who move price, and the sibling tools (e.g., robinx_caller, robinx_caller_calls) provide context for when to use alternatives. However, no explicit when-not or alternatives are 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 declare readOnlyHint=true and destructiveHint=false. The description adds meaningful behavioral context beyond annotations by detailing the output fields (tokens launched, real vs dead, etc.) and noting the cost ($0.01). It does not contradict annotations, and it provides additional transparency about what data is retrieved.

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 concise, packing key information into one sentence with a list of outputs. It avoids unnecessary words and front-loads the purpose. Slightly fragmented due to list format, but overall efficient.

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

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

Given the tool has one parameter, full schema coverage, and annotations, the description covers the purpose and output fields. However, the absence of an output schema means the description should provide more detail on the return format or structure, which it does not. The listing is helpful but incomplete for an agent to fully interpret the response.

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

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

With 100% schema coverage, the baseline is 3. The description adds minimal parameter semantics beyond the schema, implicitly indicating the address should be a deployer wallet. It does not specify format constraints or additional context, so it meets but does not exceed expectations.

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

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

The description clearly states what the tool does: provides a deployer reputation rap sheet with specific metrics (tokens launched, real vs dead, best-token volume, insider-distribution flag, score). This distinguishes it from sibling tools like robinx_wallet (general wallet info) and robinx_token (token info), making its purpose unambiguous and differentiated.

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

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

The description implies usage for assessing deployer reputation through the listed fields, but does not explicitly state when to use this tool versus alternatives, nor does it provide exclusions or prerequisites. The mention of paid cost is a side note, not a usage guideline.

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 annotations (readOnlyHint, openWorldHint, destructiveHint), the description adds behavioral details: the cost of $0.05, that the data is from a live archive that cannot be rebuilt retroactively. No contradictions with annotations.

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

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

The description is two sentences plus a cost note, which is reasonably sized. The core action is front-loaded. However, the cost information could be integrated more tightly, and some phrasing is slightly 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?

Given no output schema and moderate complexity (multiple return fields), the description lists outputs but does not detail their structure, pagination, or limits. It is adequate but leaves gaps for an agent needing precise format expectations.

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

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

Input schema has 100% coverage with a clear description for the single required parameter 'address'. The description does not add further semantics beyond what the schema already provides, so a 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 ('Follow a wallet') and resource ('accumulated holder-snapshot archive'), listing concrete outputs (tokens, balances, identity, insider/deployer records). It distinguishes from sibling tools like robinx_wallet by emphasizing cross-token archive scope.

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

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

The description mentions the cost ($0.05 on Base) and that the archive is live and non-rebuildable, providing some context. However, it does not explicitly state when to use this tool versus alternatives like robinx_wallet or robinx_token, nor does it provide 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 indicate readOnlyHint=true and destructiveHint=false. The description adds useful behavioral context: polling design, cost ($0.01), and the effect of min_score=70 (filtering to proven deployers). No contradiction with annotations.

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

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

Two sentences plus parenthetical. Front-loads purpose, then parameter hints. Efficient but 'see instructions' points to missing detail. Not overly verbose.

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

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

Adequate for a polling feed: explains what the feed contains and parameters. However, lacks output format description (what each launch item includes beyond score). Could be more complete given no output schema.

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

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

With 0% schema coverage, the description explains min_score, since, and limit but leaves ambiguity: since cursor format unspecified, limit as string (likely numeric), and no examples. Adds value but incomplete.

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

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

The description clearly states it is a feed of newest launches scored by deployer reputation, with specific verb and resource. It distinguishes from siblings like robinx_pulse or robinx_signals by focusing on new-launch scoring.

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 'Designed to be polled' and explains parameter usage (min_score, since, limit). Provides context for use but does not explicitly exclude alternatives or state when to use this vs sibling tools.

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

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

Annotations provide readOnlyHint, openWorldHint, destructiveHint. The description adds key behavioral details: only watched accounts are considered, and the provenance of 'already_following_when_tracking_began' with null followed_at is honestly stated, beyond annotation scope.

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

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

The description is two sentences, front-loaded with the core purpose, and each sentence adds essential information. No fluff; highly efficient.

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

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

Given a simple tool with one parameter and no output schema, the description fully explains what the tool does, its scope (only watched accounts), and data provenance. No gaps for the complexity level.

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

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

Schema coverage is 100% with one parameter 'handle' described as 'X handle, with or without @'. The description reinforces this (given X handle) but does not add significant meaning beyond the schema, so baseline 3 is appropriate.

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

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

The description clearly states it checks which watched Robinhood Chain principal accounts follow a given X handle, including since when and history. This is specific and distinguishes from sibling tools like robinx_follows (which shows who a principal follows) and robinx_entity (more general).

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

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

The description implies a 'free check' for quick lookup but does not explicitly state when to use this tool versus alternatives like robinx_follows or robinx_entity. No when-not-to-use guidance or prerequisites are mentioned.

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

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

Beyond the annotations (readOnlyHint, destructiveHint false), the description adds critical behavioral details: 'X exposes only CURRENT following state, so this history cannot be reconstructed after the fact' and 'Edges that already existed when tracking began are marked baseline and never reported as dated follows.' This adds significant value.

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 purpose and each of the four sentences adds essential context. There is no fluff or redundant information.

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

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

Given no output schema, the description explains the nature of the data (timestamped events, crossed with RobinX caller records) but does not detail the exact output structure. Overall, it provides sufficient context for most use cases.

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

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

Schema coverage is 100%, so baseline 3 is appropriate. The description confirms parameter uses (e.g., 'filter by watched=<handle> or event=follow|unfollow') but does not add meaning beyond what the schema already provides.

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

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

The description clearly states the tool tracks 'Follow/unfollow transitions by the X accounts that matter on Robinhood Chain — the chain's principals and launchpad accounts'. It uses specific verbs and resources, distinguishing this from sibling tools like robinx_followed_by which likely focuses on a different aspect.

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

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

The description provides explicit usage context: 'Pollable with since=<cursor>; filter by watched=<handle> or event=follow|unfollow.' It also mentions the checking frequency (roughly every 6 hours) and cost ($0.02), but does not explicitly state when not to use this tool or name alternatives.

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

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

Annotations declare readOnlyHint=true, openWorldHint=true, destructiveHint=false. The description adds significant behavioral context: matching algorithm details (exact ticker or ±20% band with volume rank), cross-chain resolution via DexScreener, and pricing (5 free/day then $0.02 USDC). 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?

The description is somewhat long but well-structured and front-loaded with the main action. Every sentence adds value. Could be slightly more concise, but no wasted words. Effective communication.

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

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

Given the complexity (image recognition, live matching, cross-chain), the description is complete: explains matching logic, confidence score, alternates, and pricing. No output schema but description gives adequate output hints.

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

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

Schema coverage is 100%. The description adds extra meaning for the 'image' parameter: 'Pass image as base64 (raw or data: URL)', clarifying the format beyond the schema. For 'media_type', no additional meaning beyond schema. Baseline 3 raised to 4 for image clarification.

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

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

The description clearly states the tool's purpose: paste a crypto price-chart screenshot and identify which Robinhood Chain token it shows. It specifies the method (Vision reads ticker/price, matches against live data) and differentiates from siblings by being the only image identification tool.

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

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

The description provides explicit guidance on when to use (screenshot) and how (pass base64). It also mentions handling of charts from other chains (detects and resolves cross-chain). However, it does not explicitly state when not to use or suggest alternatives, but given siblings, no alternative exists.

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

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

Beyond the readOnly annotation, the description adds meaningful behavior: it requires a $0.01 USDC payment on Base, explicitly notes that payment is covered, and specifies the exact scoring threshold that determines inclusion. These details go beyond what annotations alone 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?

The description is a single front-loaded sentence that delivers the core purpose, inclusion criteria, and output contents. The pricing note is slightly redundant ("Costs $0.01" and "paid $0.01") but not distracting.

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 zero parameters and no output schema, the description sufficiently covers what the tool returns, the target chain, the qualifying reputation score, and the cost. It could go further by stating the exact ranking metric, but not enough to block correct use.

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

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

The tool has zero parameters and the schema coverage is 100%, so no parameter explanation is needed. This matches the baseline for a parameterless tool; the description appropriately focuses on output behavior instead.

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 exactly what the tool returns: highest-reputation deployers on Robinhood Chain, with a concrete inclusion threshold (score >= 70), launch counts, and track record. It clearly distinguishes this from sibling tools like robinx_deployer or robinx_wallet by presenting itself as a ranked leaderboard.

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 use case is implied through the ranking criterion: an agent should call this when it needs a filtered leaderboard of trusted deployers. However, the description does not explicitly say when to avoid it or mention alternatives among the many sibling tools, so usage guidance remains tacit 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 safe read-only behavior. The description adds non-obvious details: cost of $0.02, tweet text not redistributed, the presence of accuracy record and velocity metrics. This contextualizes the returned data 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?

The description is verbose with marketing language ('The social×price join only RobinX has') and repeated cost notice ('paid $0.02 — see instructions'). It could be trimmed for clarity and brevity.

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

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

Despite lacking an output schema, the description enumerates several output fields (early_rate, median 1h price move, cluster flag, truncation flag, hourly velocity, first mention, voice counts). It also mentions cost and data handling. This gives a fairly complete picture of what the tool returns.

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?

Only one parameter 'token' with schema description 'Token contract address 0x…'. Description does not add further parameter semantics; it only mentions the token. With 100% schema coverage, baseline is adequate.

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

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

The description clearly states the tool retrieves the latest 200 X mentions of a token with associated metrics. It specifies the verb 'get' implicitly and the resource 'mentions'. However, it does not explicitly differentiate from sibling tools, though the unique data join suggests distinct purpose.

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

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

No guidance on when to use this tool versus alternatives like robinx_social_momentum or robinx_feed. The description mentions cost and data limitations but lacks explicit use cases or exclusions.

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

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

Annotations already declare readOnlyHint=true and destructiveHint=false. The description adds behavioral details such as being real-time, fusing multiple data sources, being 'skeptical by design', and costing $0.04, which goes beyond annotations without contradiction.

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

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

The description is moderately concise, front-loading key outputs and differentiator. The parenthetical about cost and instructions adds minor clutter but overall remains structured and informative.

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

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

Given the tool's complexity (synthesizing live X, caller data, on-chain) and lack of output schema, the description comprehensively outlines return components and behavioral traits, providing sufficient completeness for an agent to understand what it does and expects.

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 input schema has 100% coverage with a clear parameter 'token'. The description does not add additional parameter semantics beyond the schema, so baseline 3 is appropriate.

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

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

The description clearly states the tool synthesizes real-time X data for a Robinhood Chain token, covering narrative, sentiment, conviction, red flags, and early-caller activity. It differentiates by focusing on proven early-callers rather than follower counts, distinguishing it from siblings like robinx_caller or robinx_signals.

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

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

The description provides context on what the tool analyzes and its unique differentiator, implying use when deep crowd sentiment and early-caller insights are needed. However, no explicit when-not or alternatives are mentioned, though sibling names provide context.

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. The description adds value by detailing the composite nature of the output and the pricing model (free tier then paid). No contradiction with annotations.

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

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

The description is two sentences, each serving a purpose: the first lists the comprehensive contents, the second positions its use case and pricing. No wasted words.

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

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

Given the complexity of a composite report, the description outlines the major output categories and includes pricing details. With no output schema, this is sufficient for an agent to decide to invoke the tool and understand what it returns.

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% (the parameter 'token' is described). The description does not add new parameter-specific details beyond the schema, but it sufficiently contextualizes the purpose of the token (Robinhood Chain 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 clearly states the tool provides the 'FULL token dossier in one call' and enumerates specific components like composite verdict, deployer rap sheet, token vitals, callers analysis, etc. It distinguishes itself from siblings by calling itself 'the single best first call on any Robinhood Chain 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?

The description explicitly positions the tool as the first call to make and notes a free tier of 25 calls per day, with paid beyond. It does not explicitly list when not to use or provide alternative tool names, but the context is clear enough for a decision.

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 indicate readOnlyHint=true and destructiveHint=false, but the description adds value by explaining the ranking order (real + liquid first) and the symbol-collision warning about scammers. No contradictions.

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

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

Two sentences with no wasted words. Front-loaded with the action and purpose. Every sentence contributes useful 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?

For a simple one-parameter search tool with annotations, the description covers the input, output (ranked candidates, warning), and usage context. Missing details like pagination or limit are not critical given the tool's nature.

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

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

Schema coverage is 100% for parameter q, with description '$SYMBOL, name, or 0x address'. The tool description reinforces this and adds context about the search behavior (free text, ranking). This adds meaning 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 explicitly states that the tool searches tokens by symbol, name, or address, and returns ranked candidates with a warning. This clearly distinguishes it from sibling tools like robinx_token or robinx_report, which deal with specific token data or reports.

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

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

The description advises using this tool before buying a report or verdict to resolve token identity due to scams. While it doesn't explicitly list alternatives, it provides clear context for when to use this tool.

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

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

Annotations already declare readOnlyHint=true and destructiveHint=false. The description adds valuable context: it costs $0.02 USDC, is a pollable stream, and returns specific data (caller's measured record, deployer score, FDV). No contradictions with annotations.

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

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

The description is two sentences plus a brief cost note. It is well-front-loaded with the core concept. The cost note and instructions reference are slightly extraneous but do not harm clarity. Could be slightly tighter, but overall efficient.

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

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

Given no output schema, the description explains what each item carries (caller record + deployer score + FDV). It covers filtering criteria and cost. It does not detail pagination or ordering, but as a pollable stream with a since cursor, the essential mechanics are implied.

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

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

All three parameters are documented in the schema with 100% coverage. The description adds extra context by stating default filter values (early_rate >= 0.5, >=4 calls) and that the since parameter is a captured_at cursor, enhancing understanding beyond the schema.

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

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

The description clearly states it is a pollable stream of fresh Robinhood Chain calls filtered by measured early-callers with specific criteria (early_rate >= 0.5, >=4 calls, excluded clusters). It uniquely positions itself as the highest-alpha event in the corpus, distinguishing it from siblings like robinx_caller_calls or robinx_feed.

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

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

The description implies usage for high-alpha signal retrieval and mentions it is pollable. It does not explicitly list when to use versus alternatives or when not to use, but the context of 'measured early-callers' and 'highest-alpha event' gives clear contextual 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 indicate readOnlyHint and non-destructive behavior. The description adds valuable context beyond annotations, such as the $0.05 cost, the off-market extraction history, identity data, and the caveat that it's not a buy call. This gives the agent a richer understanding of tool behavior.

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

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

The description is fairly concise, packing key information (holder set, measured record, identity, cost, signal ambiguity) into a few sentences. The front-loading is effective, though the mention of 'paid $0.05 — see instructions' adds minor redundancy.

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

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

Given the simple input (one required parameter, no output schema), the description adequately explains what the tool returns (wallets with specific attributes and identity). It covers the core output and signal interpretation, making it mostly complete for an experienced agent.

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 only one parameter (token) and 100% schema description coverage, the schema already fully documents the parameter. The description does not add any additional meaning or format details for the parameter, so it meets the baseline but does not exceed it.

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

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

The description clearly defines the tool's purpose: listing wallets from a token's notable holder set that have a measured record on Robinhood Chain, with specific data like extraction history and identity. It distinguishes from sibling tools by focusing on cross-referencing holders with off-market 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?

The description provides some guidance, noting the signal is ambiguous and not a buy call, and mentions the cost. However, it does not explicitly state when to use this tool over alternatives or identify preconditions, leaving some ambiguity for the agent.

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. The description adds substantial behavioral info: the ranking algorithm (caller-accuracy weight, independent voices, mutual-follow cluster collapse), the time window, and the cost ($0.02 USDC on Base). This exceeds 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?

The description is compact but not overly terse, covering algorithm, time window, cost, and quality emphasis in three sentences. It is front-loaded with the ranking method and avoids unnecessary detail.

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

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

No output schema exists, so the description should explain the return format (e.g., list of tokens with scores). It only says 'tokens ranked,' leaving agents to guess the output structure. Given the algorithm's complexity, this is a significant gap.

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

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

The only parameter 'hours' has full schema coverage (100%) with a clear description. The description adds context (default 6, range 1-48) and explains that it's the lookback window for the ranking, adding value beyond the schema's minimalist description.

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

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

The description clearly states the tool ranks tokens by a specific methodology (caller-accuracy weight, independent voices, mention count) and emphasizes attention quality over raw hype. It distinguishes itself from simple mention counters by specifying the de-hyped ranking algorithm.

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

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

The description implies use for quality-adjusted social momentum by contrasting with 'raw hype counts,' but it does not explicitly mention when to use this tool over siblings like robinx_mentions or robinx_signals. The cost and time window are noted, but usage context is only 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 already declare readOnlyHint, openWorldHint, and destructiveHint, and the description adds useful behavior beyond them: venue scoping, found:false for unknown wallets, and a $0.03 USDC cost on Base. There is no contradiction with 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 behavior is front-loaded, and the scope and cost details are compact. The parenthetical '(paid $0.03 — see instructions)' is somewhat redundant and ambiguous, slightly weakening an otherwise efficient description.

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-parameter read tool with no output schema, the description covers what the receipt contains, the activity scope, the not-found behavior, and the cost. It is sufficient for invocation, though exact return field formatting is not specified.

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

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

The schema already documents the single address parameter with base58 format (100% coverage), so the baseline is 3. The description adds meaningful context by clarifying the address must be a wallet in the fomo-routed universe and that unrecognized wallets will return found:false.

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

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

The description states it produces a chain-derived receipt for a wallet in the fomo-routed Solana trade universe and lists the specific returned data: FIFO realized PnL in USD, win rate, hold style, and open bags at cost. It also distinguishes itself from a full-history wallet receipt by explicitly narrowing scope to a single venue.

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 context and an important exclusion: activity is only through this venue, not the wallet's full history, and unknown wallets return found:false. It does not explicitly name the sibling tool for full-history receipts, so it stops short of fully explicit alternative guidance.

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

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

Annotations already declare readOnlyHint=true, openWorldHint=true, destructiveHint=false, so the safety profile is clear. Description adds specific metrics returned but doesn't disclose additional behavioral traits (e.g., caching, rate limits, data freshness). It does not contradict 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?

Single sentence, front-loaded with 'Free coverage stats for RobinX', lists all metrics without redundancy. No wasted words.

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

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

Given no parameters, no output schema, and a simple purpose, the description covers essential information. It could mention output format or update frequency, but the lack is not critical for a straightforward stats 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?

No parameters exist (empty input schema, 100% coverage). Description does not need to add parameter meaning. Baseline 4 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?

Description clearly states it provides 'coverage stats' for RobinX and lists specific metrics (deployers scored, tokens indexed, etc.). Verb is implicit but clear. Distinguishes from siblings like robinx_deployer or robinx_token by being a general stats 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?

No explicit guidance on when to use this tool vs alternatives. It describes what it does but not the context (e.g., 'Use this to get an overview; for specific token details see robinx_token'). With many siblings, some usage advice would help.

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 indicate readOnly and non-destructive; description adds behavioral details: the scan takes 10-60 seconds, first call is free then paid, it provides enriched wallet stamps and a structure verdict. Adds context beyond annotations about cost, time, and data enrichment.

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

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

The description is dense and front-loaded with the main purpose. Each sentence adds value, though some phrasing (e.g., 'to the wei') could be trimmed. It is efficient but slightly verbose, earning a 4.

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

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

Despite no output schema, the description fully explains what the tool returns (diff, wallet stamps, verdict), the scan process, and limitations. It covers inputs, outputs, and usage flow, making it highly complete for a single-parameter 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 sole parameter 'token' is fully described in the input schema (type and description). The description does not add extra parameter-specific details, but schema coverage is 100%, so baseline 3 is appropriate.

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

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

The description clearly states it produces a 'labeled holder-structure diff' for a token, detailing specific changes (who froze, added, trimmed, exited). It distinguishes itself from sibling tools like robinx_token and robinx_verdict by focusing on holder structure changes over a 24-hour window.

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

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

The description implies usage: first call queues a free scan, second call retrieves results (paid). It mentions a limitation (cannot make price calls) but does not explicitly state when to use this tool vs alternatives like robinx_smart_holders or robinx_signals. Guidance is present but 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?

The annotations already mark it read-only and non-destructive, and the description adds substantial behavioral context: private Telegram corpus, no purchasable alternative data source, no message text returned, room-count only, and the presence of corpus_through in every response. It also discloses the ~70/30 corpus-wide split as an important data trait.

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

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

The description is information-dense and front-loads the core output, then explains sourcing, privacy, caveats, and cost. It loses a point for redundancy: 'Costs $0.03 USDC on Base' and '(paid $0.03 — see instructions)' say basically the same thing.

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

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

Even without an output schema, the description explains what the agent will receive: first Telegram timestamp, first X timestamp, lead in minutes, room count, and corpus_through. The unit for lead is specified, privacy limitations are clear, and this is enough to call the tool correctly for the single required parameter.

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

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

The input schema already fully documents the one token parameter as a Robinhood Chain token address, so the description does not need to add much. The description reinforces that the outcome is per-token and requires a single Robinhood Chain token, but it adds no new syntactic or semantic 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?

The description names a specific verb and resource: comparing the first Telegram timestamp, first X timestamp, and lead in minutes for a Robinhood Chain token. This clearly distinguishes it from sibling tools centered on mentions, tokens, or callers.

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

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

The description gives clear interpretative guidance: use the per-token number, not the corpus-wide average, because the distribution is bimodal. It also clarifies limits (source rooms never identified, no message text) and cost, though it does not explicitly name sibling alternatives or state when not to use the tool.

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

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

Annotations already declare readOnlyHint=true, openWorldHint=true, and destructiveHint=false, so the description adds the cost detail and a reference to instructions. It does not disclose further behavioral traits like rate limits, authentication needs, or return format, making it only marginally additive.

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

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

The description is a single sentence that efficiently lists the output contents, followed by a brief cost note. Every word is purposeful, with no redundancy or fluff.

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

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

With no output schema, the description should ideally explain the return structure. While it lists data fields, it does not confirm whether the response is a single object or requires pagination. Given the low parameter complexity, the description is adequate but not fully complete.

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

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

Schema coverage is 100%, so the baseline is 3. The parameter 'address' is described in the schema as 'Token contract address 0x…', which is sufficient. The tool description lists the output data but does not add new parameter semantics beyond the schema.

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

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

The description clearly defines the tool's purpose: providing on-chain stats for a Robinhood Chain token, listing specific data points like swaps, WETH volume, unique traders, real-activity flag, and deployer score. It distinguishes from sibling tools like robinx_signals or robinx_stats by focusing on token vitals.

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

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

The description does not explicitly state when to use this tool versus alternatives among the many sibling tools. The phrase 'paid $0.01 — see instructions' hints at a cost consideration but provides no direct guidance on selection criteria or exclusions.

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

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

Annotations already declare readOnlyHint=true and destructiveHint=false. The description adds behavioral traits: it combines multiple data sources, mentions a cost of $0.02, and emphasizes it works on very new tokens. This provides useful context beyond annotations.

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

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

The description is a single, well-structured sentence that front-loads the core purpose, lists input factors, specifies output format, and includes a key usage characteristic and cost note. No unnecessary words.

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

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

Given no output schema, the description adequately explains inputs (deployer reputation, insider flags, on-chain activity) and outputs (signal with reasons and possible values). It also mentions the cost and applicability to new tokens. Lacks mention of prerequisites or additional constraints.

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 describes the single 'token' parameter as a contract address. The description adds no further parameter details, meeting the baseline of 3.

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

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

The description clearly states the tool's purpose: providing a composite BUY-RISK verdict for a Robinhood Chain memecoin by combining deployer reputation, insider-distribution flags, and on-chain activity to output a signal (trusted/mixed/avoid/serial_spammer/new_deployer) with reasons. This distinguishes it from sibling tools that provide individual components (e.g., robinx_deployer, robinx_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?

The description specifies that the tool works on tokens that just launched ('seconds ago'), indicating its suitability for new tokens. It also implies a composite verdict versus individual data points, but does not explicitly list when to use this versus alternatives or state exclusions.

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

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

Annotations already declare readOnlyHint=true and destructiveHint=false. The description adds value by detailing the specific data returned (deployer record, insider-flow history, WETH realized, ranking), though it could mention data freshness or 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?

Two sentences effectively summarize the tool's purpose and output, with no wasted words. The key information is front-loaded.

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

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

For a simple query tool with one parameter and no output schema, the description adequately covers what the tool returns. A brief note on response format would improve completeness, but it is sufficient as-is.

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 100% schema coverage for the single parameter 'address', the schema already documents it. The description does not add further meaning beyond 'Wallet address 0x…', hence a baseline score 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 clearly states the tool provides 'free wallet reputation for any Robinhood Chain address' including deployer record and insider-flow history, and labels it as the 'who is this wallet' call, which distinctly separates it from sibling tools like robinx_token or robinx_deployer.

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

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

The description implies usage for checking wallet reputation but does not specify when to use this tool versus alternatives or provide any exclusions, leaving the agent to infer context.

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

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

Despite readOnlyHint/openWorldHint/destructiveHint already declaring a safe read operation, the description adds substantial behavioral detail: FIFO-matched PnL, routed-hop exclusion, dual open-bag valuation, withholding conditions for the reconciliation price, roster membership behavior, and the $0.03 cost. This goes well beyond what annotations provide and discloses important edge cases.

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

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

The description is information-dense but packaged as a long, run-on sentence that is harder to parse. The cost is mentioned multiple times ('Costs $0.03', 'still one $0.03 call', 'paid $0.03 — see instructions'), which is redundant and not concise despite the overall richness.

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 explaining what the caller gets: the PnL metric, win rate, hold style, open-bag markings, leaderboard comparison, reconciliation price, and the found:false case. It also covers the cost, the chain, and the roster constraint, making it complete for a complex paid 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?

The schema already describes the single address parameter at 100% coverage. The description adds meaningful domain semantics by explaining that the address must be in the tracked 100-wallet roster and that an outside address still returns found:false, informing the agent about valid inputs and the fallback response.

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 (a Robinhood Chain wallet trading receipt) and the specific content (realized PnL, win rate, hold style, open bags, leaderboard comparison). It also distinguishes this from the sibling Solana receipt tool by naming the chain and the tracked roster, so an agent can tell them apart without opening schemas.

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

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

The description makes clear this is for Robinhood Chain wallets and that only a tracked roster of 100 wallets is supported, with an outside address returning found:false. It does not explicitly name the alternative Solana receipt tool, but the context strongly implies the chain-specific usage and the roster limitation serves as practical usage guidance.

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