The Undesirables TCG Oracle

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

With no annotations, the description carries the transparency burden. It discloses the free/paid nature, 'FREE — no payment required', and mentions the paid alternative. It also explains edge cases like card_name resolution ('resolved to the best match') and momentum grade returning 'NA' on a drift spike. However, it does not cover error behaviors 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?

The description is organized with a leading summary, a bulleted return list, usage guidance, and a tip. It is slightly verbose with repeated 'FREE' emphasis and a detailed field list, but the structure makes it easy to scan.

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

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

The tool has no output schema and only two flat parameters, so the description covers the key context: purpose, inputs, return fields, usage conditions, and relationship to siblings. It lacks specifics on API path (except the tip) and error handling, but these are not critical for selection.

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 no property descriptions (0% coverage), so the description must explain parameters. It does: 'Pass a card_name (resolved to the best match) or a TCGplayer product_id.' It clarifies the either/or relationship but does not discuss what happens if both are omitted, despite the schema defaults indicating optionality.

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 exact purpose: 'The FREE 30-day read on ONE card: point forecast, bands, VaR, and the Safe-Hold / Momentum letter grades, in one call.' It also differentiates from siblings like simulate_price by noting escalation for other horizons.

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

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

Explicit guidance is provided: 'Use this FIRST for "is this card a safe hold?", "30-day outlook?", "how risky is X?".' It also names the alternative: 'For other horizons, the full percentile curve, or Monte Carlo paths, escalate to simulate_price (paid).'

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

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

With no annotations, the description carries the full burden of behavioral disclosure. It discloses key behaviors: lineups are merkle-committed before games, points come from daily stat panels, sealed souls return 404 until minted, and there are two output modes depending on token_id. It does not mention authentication, rate limits, or other potential constraints, but for a read-only feed tool the provided behavior is substantial.

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 longer than minimal, but every sentence adds valuable context. It is well structured: first the league overview, then the two parameter modes, then usage guidance and a human link. It is front-loaded with the core concept and avoids redundancy, though it could be tightened slightly without losing information.

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

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

Given the tool's complexity (two modes, token_id semantics, edge cases like sealed souls) and the absence of an output schema or annotations, the description covers everything an agent needs: what it does, what it returns in each mode, the 404 case, and concrete use cases. It even provides a human-facing URL. This is complete for the tool's purpose.

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

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

Schema coverage is 0%, so the description must fully explain the token_id parameter. It does so precisely: no token_id yields the league feed, while a token_id (1..minted) yields that soul's full card, and sealed souls return 404. This is comprehensive and leaves no ambiguity about 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 the tool's function: it provides access to a fantasy league feed for AI personalities, with two distinct modes (no token_id for league-wide data, with token_id for a specific soul's card). It also includes the context of merkle-committed lineups and daily stat panels, making the purpose unambiguous and distinct from sibling tools.

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 lists the intended use cases ('Use this when: an agent wants...') with concrete examples, which gives clear guidance on when to invoke the tool. It does not explicitly name alternative tools or state when NOT to use it, but the specificity of the use cases effectively differentiates it from siblings.

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

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

With no annotations provided, the description fully carries the behavioral burden and does so admirably: it discloses the $0.10 paid cost, the three accepted rails, that Solana settlement is verified, the exact returns (PSA/Beckett subgrades + overall score + free ROI verdict), and the underlying methodology (Qwen, OpenCV, BGS capping). This is rich disclosure beyond mere mutation.

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

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

Well-organized and front-loaded with the core purpose and pipeline before the payment details. Slightly verbose in places — the internal audit reference ('Audit 2026-07-30, BUG-12') is arguably noise for an agent — but every functional sentence earns its place.

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

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

Strong coverage for a complex paid, multi-rail tool with 2 params and no output schema. The pipeline, returns, cost, rails, and usage are all present. Remaining gaps are the unexplained game parameter and whether the $0.10 payment is required before the call or settled after, which are material but minor against an otherwise complete definition.

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

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

Schema description coverage is 0%, so the description must compensate for the two parameters, but it largely does not. image_url is only implicitly covered by 'trading card image,' and the required/default game parameter is never explained at all (what games are supported beyond the Pokemon default, what values are valid). The description adds almost no parameter-level meaning.

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 ('AI-grade a trading card image') and details a 3-stage pipeline that anchors the purpose. It distinguishes itself from the sibling grade_or_not by clarifying it produces an actual PSA/Beckett-calibrated grade rather than just a go/no-go verdict.

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?

Ends with an explicit 'Use this when: a user has a card image and wants to know what grade it would receive from PSA or Beckett,' which gives clear invocation context. However, it never names alternatives like grade_or_not or check_accuracy, nor states when NOT 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?

The description discloses a key behavioral trait: 'PAID: $0.10 USDC per call.' It does not mention side effects, data modification, or permissions, and since no annotations are provided, the description carries the full burden. The cost is transparent, but the lack of any statement about read-only behavior or side effects leaves some ambiguity, yielding a middling score.

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 extremely concise and well-structured: it leads with the core questions, explains the methodology, states the output, and adds a usage condition. Every sentence adds value and there is no fluff, making it highly efficient for an agent to parse.

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

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

Given the tool's moderate complexity (4 parameters, no output schema), the description provides sufficient context: it explains the inputs' general role, the calculation approach, and the output format (GO/NO-GO with best/predicted/worst profit). It does not cover error cases or edge conditions, but for a straightforward decision-support tool this is adequate, so it earns a strong but not perfect score.

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 provides only parameter names and defaults with no descriptions (0% coverage). The tool description mentions concepts like 'AI grade prediction' and 'PSA fee schedules' that implicitly relate to predicted_grade and service_tier, but it does not explicitly define each parameter or clarify nuances such as the meaning of raw_price or allowed values for service_tier. This falls short of compensating for the absent schema documentation.

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

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

The description clearly states the tool answers 'Should I grade this card?' and 'Will I make money?' by combining AI grade prediction with PSA fees, shipping costs, and market values to return a GO/NO-GO verdict and profit scenarios. This is a specific, verb-driven purpose that distinguishes it from sibling tools like market_snapshot or grade_card.

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 'Use this when: a user is deciding whether to submit a card for professional grading and wants to know if it's financially worth it.' This provides a clear trigger condition, though it does not explicitly contrast with alternatives or state when not to use the tool, so it falls just short of a perfect score.

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 description discloses that it's informational only and not financial advice, and that it returns 404 for cards not on the free board. It also mentions it provides a worked derivation with steps and links. However, it doesn't mention side effects (it's read-only) or rate limits, but for a simple preview tool, this is adequate. No annotation contradicts.

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 verbose, with repeated mentions of 'FREE', the URL, and the paid quote. It could be more succinct, but the core information is present and front-loaded. The 'Use this when' sentence is helpful.

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

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

Given the tool's simplicity (2 params, no output schema), the description covers the purpose, use case, and key behavior. It mentions the free board limitation and the alternative paid quote, which is useful context. It could be more explicit about the exact output format, but not necessary.

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

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

The description adds value for term_days by specifying allowed values (7, 14, or 30), which is not in the schema. It does not elaborate on product_id, but that is likely straightforward. The schema has a default for term_days, but the description clarifies the valid range.

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

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

The description clearly states the tool's function: it derives safe lending terms for a trading card on the free board, with a specific process (value → calibrated 99% tail → liquidation buffer → liquidity cap → max LTV). It distinguishes itself by noting it's for the free board and that off-board cards return 404, differentiating from paid quote.

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 says 'Use this when: an agent wants collateral math for a card, or to explain how the Loan-Terms Oracle derives an LTV before paying for a full quote.' It also mentions the 404 behavior for off-board cards, providing clear conditions 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?

With no annotations provided, the description carries the full burden of behavioral disclosure. It explicitly reveals that this is a PAID call, details the payment method and cost, and warns that the server returns a 402 unless payment is made. It also notes the previous misdocumentation (BUG-2) to prevent budget surprises. This goes beyond typical disclosure and is highly transparent about the operation's side effects (cost, potential failure).

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 efficiently organized: the first sentence states the purpose and scope, the second block conveys critical cost/payment information, and the final sentence provides usage guidance and the alternative. No sentence is wasted; even the audit reference is compact and relevant. The structure is front-loaded with the core functionality, making it easy to parse.

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

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

Given only one optional parameter, no output schema, and no annotations, the description covers the essential aspects: what the tool returns (gainers/losers, volume leaders, per-game breakdown), when to use it, the cost, and the alternative. It does not list the 25 game names or specify the response structure, but that is a minor gap for a single-parameter, read-only summary tool.

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

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

Schema description coverage is 0%, so the description must compensate. It does so by explaining the 'game' parameter indirectly: 'optionally for one game' and 'per-game breakdown across all 25 supported card games' imply that passing a game filters the snapshot to that game, while omitting it returns the whole-market summary. It doesn't list the 25 games or the expected string format, but the meaning is clear enough for a single optional parameter.

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

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

The description opens with a clear, specific statement of what the tool does: 'The DAY'S MARKET REPORT in one call, optionally for one game: biggest gainers and losers by % change, volume leaders, and the per-game breakdown across all 25 supported card games.' It also explicitly differentiates from a ranked pick list and later names the sibling tool (trending_cards) that serves that alternative purpose, making the distinction 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?

The description gives explicit when-to-use guidance: 'Use this when: a user asks "what happened in the card market today?" or "which games are moving?".' It then states the alternative: 'For a ranked list of individual cards with a risk row each, use trending_cards.' This covers both when and when-not, fully orienting the agent to choose correctly.

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

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

No annotations are provided, so the description carries the full burden. It describes the analytical method, expected outputs (position sizing, allocation weights, Sharpe ratios, rebalancing recommendations), and implicitly indicates a read-only optimization action. Good transparency for a non-destructive tool.

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 overall, but includes a redundant 'PAID' line that is not necessary for tool selection. The core information (purpose, inputs, outputs) is presented in a straightforward manner.

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, the description covers the main aspects: what it does, what inputs are needed, what outputs to expect, and when to use it. Missing details about the 'days' parameter and possible values for risk_tolerance are minor gaps.

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

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

Schema description coverage is 75% (3 of 4 parameters mentioned). It clarifies that 'cards' is comma-separated, and explains the role of budget and risk_tolerance. However, 'days' is not mentioned at all, leaving its purpose ambiguous.

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

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

The description states a specific verb ('Optimize'), resource ('trading card portfolio'), and method ('Markowitz mean-variance analysis with Merton jump-diffusion Monte Carlo simulations'). It clearly distinguishes from sibling tools like market_snapshot or card_forecast.

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

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

Provides an explicit when-to-use scenario ('a user has a budget and wants to know how should I allocate my money across these cards?'). Lacks an explicit when-not-to-use, but the use case is clear enough.

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

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

With no annotations, the description carries the full burden of explaining behavior. It clearly discloses the outputs: calibration coverage, on-chain track record, grading study, and verifiable merkle-commitment timing. It does not mention potential errors, rate limits, or exact output format, but for a no-argument scorecard tool, the key behavioral aspects are covered.

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 stylized with rhetorical flourishes like 'check us before trusting us' and the parenthetical 'do the 90% bands actually cover 90%?', but it remains reasonably compact. The key details are front-loaded, and the 'Use this when' section provides actionable guidance without excessive bloat.

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 compensates by summarizing the main returned elements: rolling 30-day coverage, recent 93.3% figure over 181K+ predictions, on-chain track record, and grading study. It also provides the merkle-commitment context for verifiability. It could be more precise about the exact response structure, but for an agent deciding whether to call this scorecard, the context is sufficient.

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 zero parameters, and the description explicitly states 'no arguments.' There are no parameter semantics to explain, and the statement removes any ambiguity about invocation requirements.

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 tool as an oracle scorecard that returns rolling 30-day calibration coverage, on-chain track records, and a blind grading study. It states that it takes no arguments and frames its purpose as a trust-but-verify check, making the tool's function easy to distinguish from forecast or loan tools.

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 says 'Use this when: an agent wants evidence the calibration claims are real, or a trust-but-verify check before paying for forecasts or loan terms.' This gives clear conditions for use, though it does not name specific sibling tools or explicitly state when not to use it.

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

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

No annotations exist, so the description carries the full burden. It discloses the free nature ('FREE — no payment required') and implies read-only behavior (it recommends calls rather than executing them), though it does not explicitly mention side effects or limitations. Adequate but not exhaustive.

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

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

The description is well-structured with clear sections: purpose, free note, examples, and usage guidance. It is concise despite the examples, with no redundant or unnecessary 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?

For a tool with a single parameter and no output schema, the description gives all necessary context: what it does, when to use it, and how to provide the input. It is complete for an agent to decide and invoke 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?

The schema has only a 'goal' property with no description. The tool description explains how to fill it ('Describe your goal in natural language') and provides concrete examples, significantly adding 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?

States a specific verb ('get') and resource ('recommended sequence of TCG Oracle API calls') with a clear purpose (accomplish a goal). Differentiates from siblings by focusing on workflow recommendation rather than performing a specific action.

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

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

Explicitly provides usage guidance: 'Use this when: you're not sure which tool to call first, or need a multi-step workflow recommendation.' This clearly indicates when to choose this tool over siblings.

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

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

With no annotations present, the description carries the full behavioral burden and does solid work: 'FREE — no payment required', the fact that adding a set splits printing into separate entries, and the critical quirk that rarity/condition words are not indexed and can 'sink' a query, with a concrete fallback. It does not address pagination or limit semantics, but the behaviors most likely to be misconceived are explicitly 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?

The description is well-structured and front-loaded: one-line summary, why-use, then actionable search tactics as bullets. Every bullet carries working examples and earns its place. It is somewhat longer than strictly necessary and mixes alert-style emphasis with guidance, so a 5 is not quite earned, but nothing is filler.

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

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

For a tool with 3 params, no output schema, and no annotations, the description covers most of what an agent needs: query construction, result shape ('set' field, product_id), pricing, and downstream tool handoff. The most meaningful gap is the undisclosed 'game' parameter—the agent could call the tool correctly with just query, but would not know how to leverage or validate the optional game filter.

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

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

Schema description coverage is 0%, so the description must explain parameters itself. It does an exceptional job on 'query'—with do/don't examples and a fallback strategy—but 'game' gets zero explanation and 'limit' is never mentioned. For a 3-parameter tool, coverage is uneven: query is over-specified while the other two parameters remain undocumented.

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

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

The description opens with a specific verb-resource pair ('Search 449K+ TCG products') and a concrete output (card names, IDs, market prices). It clearly differentiates from siblings like card_forecast, grade_or_not, and simulate_price by positioning itself as the discovery/primer search step, not an analysis step.

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?

An explicit 'Use this when' block names the common triggers (finding a specific card or pricing). It also gives routing guidance—pass the result's product_id to card_forecast, grade_or_not, or simulate_price—which clarifies how it relates to siblings. It lacks an explicit 'when not to use it' or exclusions, but the context is clear enough that the agent is unlikely to reach for it for the analytical 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?

With no annotations, the description carries the burden of behavioral disclosure. It mentions the paid nature (USDC per call), required parameters (current_price), and default settings. While it does not explicitly state read-only or side-effect-free behavior, the simulation context implies it, and the description is transparent about prerequisites and costs.

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 mostly concise but contains some redundancy (e.g., reiterating the paid cost and default model). It is well-structured with clear sections, but could be tightened slightly by removing repeated mentions. Still, it gets the point across efficiently.

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

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

The description covers key contextual aspects: the tool's output (5th-95th percentiles, model parameters, confidence intervals), usage differentiation from card_forecast, prerequisites (current_price), and pricing. Given the absence of an output schema, it adequately describes what the caller can expect. No critical information is missing for a correct invocation.

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

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

The schema has no parameter descriptions, so the description must compensate. It explains 'days' (range 30-365, default 90), 'model' (options like gbm/merton, default conformal), and the required 'current_price'. However, it does not explicitly define 'card_name' or 'simulations', though these are self-explanatory to some degree. Partial compensation for the missing schema descriptions.

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

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

The description clearly states the tool's purpose: to simulate a card's price path over a chosen horizon. It explicitly differentiates from card_forecast by highlighting the key distinctions (custom horizon, full percentile curve, Monte Carlo models). This leaves no ambiguity about what the tool does.

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 when-to-use guidance: 'use simulate_price only when the user wants a different horizon, the full percentile curve, or a Monte Carlo model.' It also contrasts with card_forecast, making the decision between sibling tools straightforward. Pricing is mentioned, which is a relevant usage consideration.

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

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

With no annotations, the description carries the burden. It discloses that the data is free, includes cryptographic proof elements (lock_hash, merkle root, on-chain tx), and is checkable. This goes beyond the schema, though it doesn't explicitly state it's read-only or handle 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 well-structured, leading with the purpose, then usage, then argument. It's slightly verbose with the 'FREE' note and explanatory sentence about verifiability, but each part adds value. The argument definition is brief.

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

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

For a single-parameter tool with no output schema, the description explains the output composition (open predictions and scored results) and mentions key fields (lock_hash, merkle root, on-chain tx). It's sufficient for an agent to understand what will be returned, though pagination or size limits are not 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?

The schema provides no description for token_id. The description adds meaning by defining it as 'minted soul' and giving a range (1-273), which is essential for correct usage. This compensates for the 0% schema 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 clearly states the tool's function: retrieving the full public record for a single soul, including open predictions and scored results. It differentiates by emphasizing 'ONE' soul and the verification aspect, which sets it apart from broader tools like souls_in_wallet.

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 'Use this when' with two scenarios: inspecting details or verifying a soul. This provides clear guidance on when to invoke the tool, though it doesn't mention alternatives or when not to use it.

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

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

Even without annotations, the description fully discloses behavior: it is free, requires no signature or wallet connection, reads public Ethereum data, only covers minted souls 1-273, and explains that UNRATED results before 2026-07-31 are expected rather than errors. This is exemplary transparency.

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

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

The description is well-organized with clear headers, bullet points, and an explicit Args section. It is detailed but every sentence adds value, including important caveats and output field explanations.

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

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

With no output schema, the description still enumerates the returned fields (souls, wallet_totals, best_soul) and call outcome values. It also covers the multi-soul roster behavior and the scheduled maturity caveat, making the tool fully understandable.

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?

Although the schema itself has no descriptions, the tool description explicitly defines 'address' as a 0x-prefixed EVM address and 'calls' as recent scored calls per soul with a 0-12 range and default 5. This fully compensates for the missing schema descriptions.

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

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

The description clearly states the tool shows every Undesirable soul in a wallet with ratings and recent calls. It also specifies concrete use cases like asking what souls a user owns, how they are performing, and which is most accurate, making the purpose 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?

The description gives explicit 'Use this when' scenarios and explains that any address can be looked up without ownership proof, asking the user for an address. It does not explicitly state when to prefer an alternative sibling tool, but the use-case list is strong enough for practical 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?

With no annotations provided, the description carries the full behavioral burden and does so well: it discloses the tool as FREE, states that the off-season leagues report themselves dormant rather than serving frozen numbers, and says every response includes an out-of-sample calibration verdict. It leaves rate limits, authorization, and failure modes unspecified, which keeps it shy 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 definition is compact (about 115 words), front-loaded with the core purpose, and organized with a distinct 'Use this when' paragraph. Only 'provable, not vibes' borders on fluff, though it does earn some value by restating the on-chain provenance claim.

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 no output schema and no annotations, the description compensates well by enumerating what returned content looks like (players, forecast context, grades, headshots, calibration verdict). It does not describe response shape or pagination, and the 'limit' parameter remains opaque, so it is strong 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 description coverage is 0%, so the description must encode parameter meaning. It does for 'league' via examples ('hot in MLB') and league-specific behavior, but 'limit' is never mentioned, leaving its bounds and effect entirely implied. The partial compensation for the parameter that actually concerns the table yields a 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 states a specific resource and action: 'Daily sports movers board — hot, high-performing players per live league' with forecast context, Heat/Form grades, and headshots. It is clearly distinguished from the sibling tools (cards, games/tech) and from the paid /api/v1/sports/forecast endpoint that the description names 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?

A literal 'Use this when' block lists three triggers: hot-player queries ('who's hot in MLB'), fetching player ids for the paid forecast endpoint, and fantasy-adjacent context. It does not name alternative sibling tools or give any explicit when-not-to-use rule, so it is clear context but not the spread-sheet exclusions that would earn a 5.

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

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

The description discloses some data structure (agent entries include a flag and model label) but does not explicitly state side effects, authentication requirements, or rate limits. It does not say whether the tool is read-only or if it modifies anything. Since no annotations exist, the description carries the burden, and this partial disclosure is insufficient for full transparency.

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

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

The description is concise, using two sentences and a dash/semicolon style. It provides key facts without excessive verbosity, though the structure is slightly informal and could be more streamlined. Overall, it is well-organized and easy to parse.

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

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

The description lacks contextual information about when to call this tool, what a typical use case would be, or how it fits into the broader workflow. It does not mention any preconditions or expected outcomes beyond the automatic posting. An agent would have limited basis to decide when this tool is appropriate.

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 fully documents that fact (100% coverage). The description adds no parameter-specific details, but none are needed. This aligns with the baseline of 3 for high schema coverage where parameter info is already complete.

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 tool as a shared leaderboard for 'Biggest Scores' involving humans and AI agents, and notes that winning a game posts scores automatically. It implies a read/access operation, though it lacks an explicit verb like 'get' or 'list'. This is a minor gap, but the overall purpose is evident.

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 is provided about when to use this tool vs. alternatives. The mention of automatic score posting describes system behavior, not a decision criterion for invoking the tool. There is no comparison to sibling tools or any context that would help an agent choose this tool over others.

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

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

With no annotations provided, the description carries the full burden of behavioral transparency. It discloses key behaviors: advancing the day, resolving events, returning new state, the one-order-per-crew-member limit, and the effect of an empty orders list. It does not mention potential side effects such as turn consumption or failure modes, but covers the primary behavioral aspects.

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 overall but contains slight redundancy: the orders structure and the empty orders behavior are each mentioned twice. It could be tightened into a more structured format, but it remains readable and directly to the point without unnecessary 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?

The description covers the input format, action types, the special empty-orders case, and the source for targetId. It gives a high-level expectation of the output ('events + new state'). It does not detail error handling or additional constraints, but for a game move tool the provided context is adequate for an agent to use 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?

The description fully explains both parameters. For 'orders', it specifies the list structure (agentId, targetId, actionType) and enumerates all valid actionType values. For 'targetId', it directs the user to obtain valid values from syndicate_state lists. 'session_id' is implied as the game session identifier. The schema itself has no descriptions, so this textual coverage is comprehensive.

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 specific function: submitting one day of orders to the Syndicate game and receiving the resolved day with events and new state. It uses a specific verb ('Submit') and distinguishes the resource ('one day of orders'). While it doesn't explicitly contrast sibling tools, the purpose is unambiguous and self-contained.

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 explains what the tool does but does not explicitly state when to use it versus alternatives like syndicate_state or syndicate_leaderboard. It implies usage (for submitting orders) and covers edge cases like empty orders (passing the day), but lacks direct when-to-use or when-not-to-use guidance relative to 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?

With no annotations, the description carries the burden of explaining side effects. It mentions starting a new game and returning a sessionId, crew, capital, and target list, but does not disclose whether starting a new game overwrites or creates additional sessions, or whether re-reading has any side effects.

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 contains marketing language ('FREE', 'you (the agent) can play', 'Same city, same rules, same leaderboard') and a strategy tip that are not essential for invoking the tool. A more focused description of the state retrieval/creation behavior would be significantly more concise.

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

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

The description provides the main usage pattern and a link to full rules, and it lists the fields returned on a new game. However, there is no output schema and the response shape for an existing session is not explicitly described, leaving some ambiguity about what 'current state' includes.

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

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

The single parameter session_id is explained in the description: omitting it starts a new game, while providing it re-reads the current state. This compensates for the schema's lack of a parameter description, though it does not specify the expected format or source of session_id.

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 indicates that the tool starts a new Syndicate game when no session_id is provided and re-reads the current state when a session_id is included. However, it does not use a crisp verb-noun phrase like 'get game state' and includes some promotional framing.

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?

Some usage guidance is present: omit session_id to start, include session_id to re-read. But it does not explicitly contrast this with sibling tools like syndicate_move or syndicate_leaderboard, nor does it state when this tool should be preferred over them.

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 description states the tool is read-only, free, and takes no arguments, which gives some behavioral transparency. However, it does not concretely describe what the returned data will look like or what 'can and cannot do' actually encompasses, leaving some ambiguity.

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 relatively brief and front-loads the core purpose. The formatting is a bit cluttered with slash-separated phrases, but it remains compact and does not waste 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?

The description gives enough context to choose the tool and understand its general scope, but it lacks detail about the output format or the exact contents of the API docs and proof feed. Since there is no output schema, a bit more specificity would improve completeness.

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 no parameters, and the schema coverage is 100% with an empty properties object. The description reinforces that there are no arguments, so parameter semantics are fully satisfied.

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 is a read-only reader for technocore.chat API docs and a verifiable price feed, with a clear use case for learning about the API or verifying the feed. It is somewhat convoluted but sufficiently distinguishes this tool from the room/message/note readers.

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 says 'Use this when: an agent wants to learn the technocore API itself or verify our feed.' It also gives an exclusion: 'For rooms, messages, or notes use the other three readers,' providing clear when-to-use and 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?

With no annotations, the description carries the full burden. It clearly states 'FREE, read-only' and 'READ', disclosing the non-mutating nature. It does not cover error handling or edge cases (e.g., missing key), but for a simple note read this is acceptable. It adds the context that this is a shared store for agent-published state, which is useful.

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 short, focused sentences. The first sentence front-loads the purpose and key constraints (read, key-value, namespace+key, free, read-only). The second provides usage guidance. Zero wasted words.

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

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

For a simple read-only note retrieval tool with no output schema, the description covers the essential aspects: what it does, when to use it, and how it differs from siblings. It does not explicitly state the return format, but the phrase 'READ one shared KEY-VALUE NOTE' implies the value is returned. Given the simplicity, this is adequate.

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

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

Schema description coverage is 0%, so the description must compensate. It explains that namespace and key together identify the note, giving the core semantics. However, it does not clarify that key is optional (default '' in schema) or describe the expected format or behavior when key is omitted. The description adds value but is not fully compensating for the absence of schema descriptions.

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

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

The description states a specific verb ('READ') and resource ('one shared KEY-VALUE NOTE') and explicitly names the identifier components (namespace + key). It also distinguishes from sibling technocore_room by noting it is not for conversation, making the purpose 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?

Provides explicit when-to-use guidance ('when an agent needs a value another agent published') and explicitly states what it is not for ('Not for conversation — that is technocore_room'), naming the alternative. This fully routes 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?

Although no annotations are provided, the description explicitly states 'FREE, read-only — structurally incapable of posting.' This discloses the key behavioral trait of having no side effects, which is a major risk factor for tool use. There is 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 compact, well structured, and free of unnecessary detail. It packs the core behavior, side-effect profile, usage scenario, and sibling-tool references into just a few lines without losing clarity.

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

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

Given the low complexity and the fact that no output schema is present, the description provides enough context for an agent to choose and call the tool for its primary purpose. It could be slightly more complete by describing the return format, but it already implies that messages are returned and gives sufficient alternatives for related tasks.

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

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

The description indirectly explains the 'room' parameter by saying 'one named room' and pointing to technocore_rooms for room names, but it does not explain the 'limit' parameter at all. Since schema description coverage is 0%, the description should have compensated by covering both parameters; it only partially covers one.

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

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

The description states a specific verb ('READ') and a specific resource ('recent MESSAGES in one named room'), and distinguishes this tool from related tools such as technocore_rooms and technocore_note. It is clear what the tool does and how it differs from its 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?

The description explicitly says when to use it ('follow one room's conversation ... without joining') and gives direct guidance for alternatives: get room names from technocore_rooms and use technocore_note for published state values. This gives an agent clear 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?

It explicitly says 'read-only' and 'FREE', covering side effects and cost. However, the claim 'no arguments' is inaccurate given the limit parameter, and no annotation corroborates these traits.

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 partially concise but includes extraneous marketing context ('Flop Network', 'agent economy L1') that does not aid invocation, and the false 'no arguments' statement adds noise.

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?

It provides an overview and pointers to related tools, but omits any explanation of the limit parameter and misrepresents the argument list, leaving important invocation details unresolved.

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 exposes an optional 'limit' parameter with no explanation, and the description actively denies any arguments, which is misleading and leaves the limit parameter undefined.

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 verb 'LIST' and the resource 'rooms', and explicitly says 'Start here to discover room names', making the purpose unambiguous.

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

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

It provides a sequencing hint ('Start here') and lists related tools as next steps, but does not explicitly state when to avoid this tool or contrast it directly with 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?

With no annotations provided, the description carries the full transparency burden. It discloses the paid cost, corrects previous claims about sales volume/view counts, explains that band/VaR percentages are regime-level constants, and notes the API disclaims certain data via ranked_by.

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 focused and each sentence adds meaningful information: output type, ranking criteria, filter options, caveats, pricing, and sibling-tool comparison. It is appropriately concise without unnecessary 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?

Even without an output schema, the description explains the return shape (ranked list with conformal risk row) and important behavioral details such as coverage across games, cost, and data limitations. This is sufficient for an agent to select 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 schema provides only names and defaults, but the description mentions filtering by game, limit, and min_price, which maps to all three parameters. It does not detail game value format or currency for min_price, but the essentials are covered.

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

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

The description clearly states the tool returns a ranked list of individual cards by price velocity, with highest absolute movement first, and explicitly distinguishes it from market_snapshot for whole-market summaries. This makes the tool's purpose and scope unambiguous.

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

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

The description gives explicit usage direction: use when a user asks which cards are moving fastest and wants names to act on, and use market_snapshot for day's whole-market summary. This provides clear when-to-use and 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.