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

Annotations indicate destructiveHint=true and readOnlyHint=false. The description adds context about releasing frozen funds, paper-only execution, and details about pricing policies and fees, which goes well beyond the annotations.

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

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

The description is front-loaded with the core purpose, but the extensive detail about paper execution costs and policies is verbose for a cancel action. Could be 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?

For a simple cancel with good annotations and output schema, the description adequately covers purpose, requirements, and paper-only nature. It lacks explicit return value details but output schema likely covers that.

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 clear parameter descriptions. The description does not add extra meaning beyond 'by id' and does not explain the optional agentTrace parameter. 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 action 'Cancel an open spot order by id' and the effect 'releases frozen funds'. It distinguishes this tool from siblings like 'place_spot_order' or 'list_open_orders'.

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 the required scope ('trade:spot') and that it's for paper trading only with virtual funds. It does not explicitly state when not to use or suggest alternatives, but the context is clear enough for appropriate use.

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 (destructive, idempotent), the description reveals crucial traits: paper-only, virtual funds, execution policy with fees, and no financial advice. 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 front-loaded with essential purpose and parameter guidance. The later execution policy details are relevant but could be condensed. Overall structured well.

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 output schema present, the description covers behavior, execution model, and scope completely. No gaps for agent decision-making.

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 value by clarifying fraction usage (omit for full close) and stressing idempotencyKey requirement. For agentTrace, it adds minimal extra context 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 the verb 'close or partially reduce' and the resource 'mock futures position'. It distinguishes from related tools like open_futures_position and set_futures_sl_tp by specifying its scope and partial reduction capability.

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 when to use the tool (closing/reducing positions) and prerequisites (trade:futures scope, paper trading only, idempotencyKey required). It lacks explicit alternatives but the sibling list provides 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 indicate read-only behavior; description adds details on returned fields, quality field explanation, and paper trading constraints, though some content (execution cost) is not directly needed for this tool's 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?

Description is lengthy (over 200 words) and includes detailed execution policy and paper trading context that, while informative, reduces conciseness. Front-loaded with purpose but contains some extraneous details.

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

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

Given the tool's complexity (6 params, nested objects, output schema), the description covers purpose, workflow, return fields, constraints, and context (paper trading, virtual funds), making it fully informative for correct invocation.

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

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

Schema coverage is 100%, so baseline is 3. Description does not add meaning beyond schema, except mentioning default sources matching the 'source' parameter, but no extra semantics for individual parameters.

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 finds active-open prediction markets from specific sources (Kalshi and Polymarket), distinguishes from siblings like pm_quote and open_pm_position by calling it 'discovery only' and providing a workflow.

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 tells the agent to call pm_quote next with a returned outcomeExternalMarketId, and states pm_quote is the final eligibility source, providing clear guidance on when to use this tool vs 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 indicate readOnlyHint=true and destructiveHint=false. The description goes beyond by explaining that the tool exports paper trading data with virtual funds, includes execution cost details, and clarifies that results are not exchange-fill guarantees. This provides valuable context that annotations alone do not 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 overly long, with detailed execution cost explanations that could be in a separate note. The first sentence is clear, but the following sentences add unnecessary verbosity for a tool description. It should be more concise to aid quick scanning by an AI agent.

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 (8 parameters, nested objects, output schema exists), the description adequately covers key aspects: export scope, limitations, privacy, and the simulated nature. The executional nuances are informative but slightly excessive. Overall, the agent can understand what the tool does and its 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?

The input schema has 100% description coverage for all 8 parameters, including nested 'agentTrace'. The description only mentions 'runId' and 'decisionId' filters, adding no semantic value beyond what the schema already provides. Baseline 3 is appropriate given high 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 specifies that the tool exports up to 1,000 private ledger rows as JSON for the calling API key. It uniquely distinguishes itself from siblings like 'get_agent_ledger' (likely a view) and 'export_run_evidence' (different data) by focusing on private ledger export with filters.

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 states when to use the tool, such as for exporting private ledger data with optional filters (runId, decisionId) for reproducible evaluation. It also emphasizes that data is private and paper-only. However, it does not explicitly compare with sibling tools like 'get_agent_ledger' or 'export_run_evidence', or mention 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?

Discloses extensive behavioral details beyond annotations: the bundle includes sanitized rows, execution assumptions, retention policy, etc. Also describes execution cost models and that data is private. No contradiction with readOnlyHint or destructiveHint.

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 detailed execution cost explanations that may be tangential. While front-loaded with purpose, it could be more concise without losing critical 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 output schema exists, the description adequately explains the exported bundle's contents and context (paper trading, privacy). Covers complexity well, though slightly dense.

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 descriptions cover 100% of parameters. The description adds minimal extra meaning (e.g., 'optional private trace metadata'), but does not significantly enhance 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 the tool exports a private reproducibility bundle for a specific runId, distinguishing it from sibling tools like export_agent_ledger by specifying the bundle contents and privacy 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?

Provides context such as 'Paper trading only' and 'Not financial advice', indicating when to use. However, it lacks explicit comparisons or when-not-to-use guidance against other export 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 already declare readOnlyHint and destructiveHint. Description adds transparency about paper trading, virtual funds, execution policy, fee structure, and that the quote is a rehearsal cost. This goes beyond annotations, though it could mention 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 front-loaded with the core purpose but becomes lengthy with detailed execution policy that may be extraneous for a quote tool. Could be more concise while retaining key constraints.

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 presence of an output schema and the tool's complexity, the description is comprehensive: it lists returned fields, explains the paper trading context, execution costs, and what the quote represents. No gaps are apparent.

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 has 100% coverage with parameter descriptions. The description repeats leverage and margin constraints but does not add new semantics beyond the schema. Baseline 3 is appropriate.

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

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

The description clearly states the tool provides a read-only futures quote with specific fields (entry price, notional, etc.) and explicitly distinguishes from mutation tools by stating 'Never mutates state — always quote before opening.' This differentiates from sibling tools like open_futures_position.

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 usage context: use before opening a position, paper trading only, leverage and margin constraints. It does not explicitly contrast with sibling quote tools (spot_quote, pm_quote) but the paper trading focus and 'always quote before opening' give clear guidance.

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

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

Beyond annotations (readOnlyHint=true, destructiveHint=false), the description discloses that only rows for the calling key are returned, that it operates on paper trading with virtual funds, and details execution cost structures (taker fees, slippage, etc.). No contradictions with annotations exist.

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

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

The description is quite lengthy and packs many details, but the first sentence is dense with information. While every sentence adds value, the structure could be improved by front-loading the core purpose and separating operational details. Some redundancy exists (e.g., 'paper trading only' mentioned twice).

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 (10 parameters, nested agentTrace object, output schema), the description covers purpose, usage scope, behavioral nuances, and parameter context adequately. It explains what the ledger contains and execution costs, but does not detail output structure (since output schema exists). Minor gaps remain in usage guidance relative to siblings.

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

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

Schema description coverage is 100%, so the input schema already documents all parameters comprehensively. The description does not add significant new meaning beyond the schema, only briefly mentioning date-range and runId filters. Baseline of 3 is appropriate as the schema carries the burden.

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 lists the API key's private execution ledger with specific details (reads, quotes, writes, etc.), and the verb 'List' combined with the resource 'private agent ledger' clearly defines the action. The tool name and title are reinforced, and it distinguishes from siblings like export_agent_ledger by focusing on listing rather than exporting.

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 the tool to 'audit a reproducible paper-trading run' and notes 'Paper trading only — virtual funds (50,000 mUSD).' It also includes disclaimers about not being financial advice. However, it does not explicitly mention when not to use it versus alternatives like export_agent_ledger, leaving room for clearer sibling differentiation.

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. The description adds that data is public, paper-only with virtual funds, and explains execution costs. This provides useful context beyond annotations, though the execution cost detail is extensive.

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 lengthy (over 5 sentences) and includes detailed execution policy mechanics that are not essential for an agent deciding to invoke the tool. While front-loaded with main output, it contains excessive technical depth.

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 output schema exists and the tool is simple (one param, read-only), the description covers purpose, data source, nature (paper trading), and execution cost context. It is complete and leaves no significant gaps.

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

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

The only parameter (handle) is described in both schema and description with similar detail. Schema coverage is 100%, so baseline 3. The description adds a usage example but no additional 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 states the verb 'get' and the resource 'Arena profile', specifies the input (handle), and lists the output fields. It differentiates from sibling tools by focusing on a single agent's profile, contrasting with get_arena_leaderboard which lists all agents.

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 indicates to use this tool when you have a specific handle from the leaderboard, referencing get_arena_leaderboard. It does not explicitly state when not to use, but the context is clear. Could be improved by directly naming 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?

The description fully aligns with annotations (readOnlyHint, openWorldHint, destructiveHint) and adds significant detail: it explains that data is public, paper trading, not financial advice, and elaborates on execution costs (fees, slippage) that affect realized PnL. 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?

The description is verbose (7 sentences, ~200 words) and includes detailed execution cost mechanics that may be tangential to the leaderboard function. While informative, it could be more concise without losing essential guidance.

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 (3 parameters, no required, output schema exists), the description covers ranking criteria, window behavior, data scope, and disclaimers. It is thorough but slightly overloaded with execution details that could be 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%, so baseline is 3. While the description adds context for the 'window' parameter (explaining window-scoped re-ranking), it does not add substantial new meaning for 'page' and 'pageSize' beyond what the schema provides. Adequate but not exceptional.

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 leaderboard of opted-in agents ranked by realized PnL across venues, with per-venue breakdown and win rate. It distinguishes itself from siblings like get_performance and get_arena_agent, making its 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?

The description explicitly advises when to use the tool ('see the field and where you stand') and recommends pairing with get_performance and get_arena_agent. It also notes that data is public and paper trading only, providing appropriate context for use.

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 mark the tool as read-only and non-destructive. The description adds behavioral details like candle ordering and timestamp format, but also includes extensive, irrelevant execution policy details (paper fills, fees) that may confuse the agent. 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 excessively long and includes unrelated execution policy information (paper fills, fees) that does not belong in a read-only candle retrieval tool. It could be cut by half without losing essential guidance. The front-loading is adequate but wasted by the extensive tail.

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 presence of an output schema, the description does not need to explain return values. It covers parameter intent and data format, but the inclusion of irrelevant execution details detracts from completeness. The core data retrieval behavior is adequately described.

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 schema already describes parameters. The description adds value by explaining the range resolution mapping and emphasizing the need to resolve_symbol for coinId. It does not reproduce schema fields but complements them concisely.

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 OHLCV candles for indicator/momentum strategies, specifying the data format and prerequisite to resolve_symbol. It effectively distinguishes itself from sibling tools, none of which offer candle 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 explicitly instructs to use resolve_symbol first to obtain the coinId, and explains the range parameter mapping (e.g., 1H=60x1-minute). While it does not explicitly list when not to use this tool, the context is clear enough for typical usage scenarios.

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 adds meaningful behavioral context beyond the annotations: data refreshes on a ~60s tick, the scan is free and public, no API key is required, and symbols can collide so coinId must be passed instead. These details help the agent understand external constraints and side effects even though annotations already mark the tool as read-only.

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 information-dense. Each sentence earns its place: definition and sort order, usage workflow with alternative tools, and critical data passing caveat plus refresh timing. It is front-loaded and there is no filler.

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

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

The description, combined with the input schema, output schema, and annotations, provides a complete operational picture. It explains the purpose, workflow, return fields, refresh behavior, auth requirements, and intra-tool handoff guidance, leaving no major gaps for the 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?

The input schema covers 100% of the two parameters with clear descriptions, so the baseline is 3. The description does not add extra meaning to limit or direction, but it does reinforce the top-movers framing which lightly aligns with direction.

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 scans the full crypto universe for the biggest 24h price moves, specifically top gainers or losers ordered by 24h change percent. It uses a specific verb and resource and distinguishes itself from narrower tools like get_candles and get_market_context.

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

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

Explicitly says to use this for discovering candidates beyond the watchlist, then deep-analyze each candidate with get_candles and get_market_context before trading. It also notes the coinId-passing convention and warns against re-resolving symbols, which gives clear operational 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 indicate read-only, non-destructive. Description adds essential context: paper trading only, virtual funds, execution cost details, and versioned policy. Exceeds annotation coverage 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?

Front-loaded with core purpose and granularity explanation, but includes lengthy details about execution costs and fees that are not essential for tool selection.

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

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

Covers key aspects: output type (time series points), granularity distinction, parameter ranges, and paper-only constraint. With output schema present, return values need not be detailed.

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 parameters are described in schema (100% coverage). Description adds value by explaining default granularity behavior, meaning of returned data, and purpose of agentTrace, going beyond 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 returns a wallet equity time series for the paper account, explicitly differentiating from siblings like get_portfolio and get_wallet by specifying 'paper account' and 'time series'.

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 guidance on granularity options (daily vs. realized) and trade-offs (e.g., 'use it for active intraday agents'), along with look-back window range. Lacks explicit when-not-to-use or alternatives among 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?

Beyond annotations (readOnlyHint, destructiveHint), the description adds detailed behavioral context: paper trading, virtual funds, execution cost disclosure, fee structures, and the fact that it returns facts only. 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 front-loaded with a clear summary of contents. It is well-structured, but the execution model details are somewhat lengthy and could be placed elsewhere. However, 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 the complexity (multiple data components), the description covers the output comprehensively. It does not mention error handling or edge cases, but for a read-only tool with good annotations, this 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?

Schema coverage is 100%, so baseline is 3. The description adds meaning by explaining coinId format and how to obtain it ('Use resolve_symbol to find it'). The agentTrace parameter is already well described in 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 it provides 'compact factual context for ONE coin' and enumerates all returned data (price, changes, market cap, category tags, sentiment, Fear & Greed, prediction markets, similar coins). This clearly differentiates it from sibling tools like get_candles or get_portfolio.

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 instructs to 'Call resolve_symbol first to get the coinId' and notes 'Paper trading only'. It implies usage for factual context gathering without analysis. While it does not explicitly state when not to use it, the context is clear and the prerequisite is provided.

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

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

Annotations show readOnlyHint=true and destructiveHint=false. The description adds substantial behavioral details: it confirms read-only access to closed trades, explains the response includes asOf for polling, notes it is paper trading only with virtual funds, and provides details on execution costs and caveats (e.g., 'a rehearsal cost, not an exchange fill guarantee'). 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?

The description is moderately verbose but well-structured. It starts with core purpose, then usage, polling, paper trading context, and execution costs. Each sentence adds value, though the execution cost details could be considered slightly tangential. Overall, it is appropriately sized for the tool's complexity.

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 4 parameters, an output schema, and moderate complexity, the description is complete. It covers purpose, usage, polling mechanism, paper trading context, and execution model. No need to explain return values as output schema exists.

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 parameters are well-documented. The description adds value by explaining the updatedSince cursor usage: 'Pass the previous response's asOf back here.' For other parameters like limit, venue, and agentTrace, the description does not add beyond the schema, but the single insight about updatedSince justifies a score above baseline (3).

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

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

The description clearly states it is a 'Unified realized-PnL log of CLOSED trades across venues' and serves as 'the agent's memory of what it did and what won/lost.' This distinguishes it from sibling tools like get_performance or get_agent_ledger, which focus on broader metrics or ledger entries.

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 it to review performance before deciding the next move' and explains how to use the updatedSince parameter for polling. However, it does not mention specific alternatives or when not to use this tool, though the context implies it is for closed trades.

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 readOnlyHint=true and destructiveHint=false. The description adds significant behavioral context: paper trading with virtual funds, closed trades only, execution details (taker fees, slippage, etc.), and that result includes execution model info. 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 front-loaded with the main purpose and key constraints. It includes detailed execution policy information that adds value but may be more verbose than necessary. Overall well-structured.

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 optional parameter and the presence of an output schema (not provided), the description thoroughly explains the tool's behavior, return data (total + per-venue PnL, trade counts, win rate), and constraints (closed trades, paper trading). It is complete for an agent to use correctly.

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

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

Schema coverage is 100% for the single optional parameter 'agentTrace'. The description does not mention the parameter, but the schema fully documents it. With high coverage, baseline is 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 explicitly states the tool returns the calling key's own realized performance, including total and per-venue realized PnL, trade count, win/loss/neutral counts, and win rate. It distinguishes from sibling tools like 'get_my_trades' and 'get_positions' by focusing on realized performance of closed trades and paper trading.

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 clarifies that the tool is for closed trades only ('scorecard for this agent') and paper trading only ('virtual funds'). It provides context for when to use it but does not explicitly state when not to use or list 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?

Discloses execution costs, fees, slippage, and that fills are rehearsals, not exchange guarantees. Annotations already indicate readOnly and non-destructive, but description adds significant behavioral 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?

Description is somewhat verbose and dense, especially the execution details. While informative, it could be more concise without losing key points. The structure starts clear but becomes lengthy.

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 the tool (paper account, multiple fields, execution model), the description is thorough, covering all essential aspects. Output schema exists, so return values need not be explained.

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

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

Schema coverage is 100% with detailed descriptions for each parameter. The description does not add additional meaning beyond the schema, so 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?

Clearly states it retrieves the lean, PII-free paper account summary with specific fields like walletId, equity, PnL, orders, progression. Distinguishes from siblings like get_wallet or get_positions as a comprehensive portfolio overview for the paper account.

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 'Paper trading only' and 'Not financial advice.', setting clear usage context. Does not explicitly mention alternatives, but the paper-only constraint and specific scope (portfolio summary) guide appropriate use.

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: mock data behavior, execution costs, versioned policy, and the asOf polling mechanism—all beyond what annotations provide. 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 informative but verbose, especially in the execution model details. While front-loaded with the main purpose, the latter part could be streamlined or moved to documentation. Still, it earns its place for completeness.

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 output schema exists, the description covers all needed context: mock vs real behavior, polling with updatedSince, paper trading limitations, and execution cost model. Fully sufficient for an agent to use correctly.

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

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

Schema coverage is 100% with descriptions for each parameter, but the description adds meaningful context: explains venue values, the purpose of updatedSince (pass asOf back), and agentTrace as optional trace metadata. This supplements the schema effectively.

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 lists open + historical positions for a venue, distinguishing between 'futures' (with unrealized PnL + liquidation distance) and 'pm' (with unrealized mark). It uses specific verb+resource and differentiates from sibling tools like close_futures_position or open_futures_position.

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 clear context on when to use (list positions per venue) and how to poll with updatedSince. Does not explicitly state when not to use, but the context and sibling tool list imply this is for reading only, which is sufficient for an 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, openWorldHint=true, and destructiveHint=false. The description goes far beyond by detailing the paper trading simulation, execution policies, fee structures, and the nature of virtual funds, providing extensive behavioral transparency that supplements the annotations perfectly.

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 informative but slightly verbose, especially in the latter half detailing execution costs. However, it is well-structured with the core purpose upfront, and every sentence adds context that aids an AI agent in understanding the tool's behavior.

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 optional parameters, read-only, with output schema), the description is fully complete. It explains the return structure (balances, frozen partitions) without needing to duplicate the output schema, and no critical information gaps remain.

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%, providing baseline clarity. The description adds value by explaining the coinId parameter's purpose ('Optionally include one coin asset'), which is not fully captured in the schema. The agentTrace parameter is adequately described in the schema, so the description does not need to repeat 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 states the tool gets raw cash balances, enumerates the three frozen partitions, and mentions optional inclusion of a coin asset. It is specific and distinguishes itself from sibling tools like get_portfolio and get_positions by focusing solely on wallet/cash balances.

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

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

The description provides clear context: it is for paper trading only and not financial advice. It implies usage for retrieving wallet balances but lacks explicit exclusions or comparisons to alternative tools, such as get_portfolio or get_equity_curve.

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

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

Annotations already declare readOnlyHint=true and destructiveHint=false, so the agent knows it's a safe read operation. The description adds valuable context about the paper trading environment (virtual funds, execution policies, fees) and delta polling behavior, exceeding 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 front-loaded with the main purpose but becomes verbose with detailed execution model and fee information that may not be essential for tool selection or invocation. It could be more concise while retaining key points.

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 (4 parameters, nested objects, output schema), the description covers the core functionality, filtering, delta polling, and environment context. The output schema exists, so return value details are not needed. The extra execution details add some noisy context, but overall completeness is good.

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 description adds meaning beyond the schema by explaining the optionality of coinId, the delta polling pattern for updatedSince, and the purpose of agentTrace, thus improving semantical clarity.

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 lists open spot orders, specifies the filtering option via coinId, and explains the delta polling mechanism. This distinguishes it from sibling tools like place_spot_order or cancel_spot_order.

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

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

The description provides clear usage context: omit coinId for all orders, pass one to filter, and use updatedSince for delta polling. It does not explicitly state when not to use the tool or compare with alternatives, but the context is sufficient for typical usage.

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?

Discloses beyond annotations: paper-only trading, virtual funds, execution cost details, and remarks that fills are rehearsals, not guarantees. Annotations already show write, idempotent, non-destructive; the description adds context on costs and policy version.

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 overly verbose, with a lengthy paragraph on execution cost details that could be externalized or condensed. While front-loaded with key actions, it wastes space on niche policy specifics that are not critical for tool selection.

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

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

Given the tool's complexity (8 parameters, nested objects, output schema), the description covers scoping, idempotency, limits, atomic sl/tp, paper nature, and execution model. It is near complete, though it omits specifics about output schema content (offset by existence of 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?

Schema covers all parameters with descriptions (100%). The description adds extra context for idempotencyKey (must be unique) and sl/tp (side-aware corridor), but does not significantly enhance understanding beyond the schema's own 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 verb 'Open (or add to)' and the resource 'mock futures position.' It distinguishes from siblings like close_futures_position and set_futures_sl_tp by noting atomic sl/tp at open, and from spot/PM tools by specifying futures and paper trading.

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 constraints: required scope, idempotency key uniqueness, leverage and margin limits, sl/tp corridors, and the instruction to quote and confirm. However, it does not directly contrast with alternatives like open_pm_position or place_spot_order.

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 extensive behavioral details beyond annotations: requires scope, server-flag gated, idempotent, paper-only with virtual funds, execution costs, and a rehearsal cost model. Annotations mark readOnlyHint=false and idempotentHint=true, which are consistent. 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 long but well-structured with logical flow: purpose, constraints, parameter details, execution model. While verbose, the complexity of the tool warrants the detail. Slightly overlong but not wasteful.

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

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

Given 9 parameters with 100% schema coverage, presence of an output schema, and annotations, the description covers scope, constraints, user instructions (quote first, confirm), and execution behavior. It is complete for a paper-trading position opener.

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. The description adds meaningful context for key parameters like 'side' (NO fills at 100 minus probability), 'stakeMusd' (>=10), 'idempotencyKey' (REQUIRED), and 'forecastProbability' (own estimate, not market echo). This goes beyond the 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 opens a mock prediction-market position with binary outcomes. It specifies 'paper trading only' and differentiates from sibling tools like open_futures_position and place_spot_order, which are for other instruments.

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 to 'Quote first and CONFIRM with the user' and specifies requirements like the 'trade:pm' scope and idempotencyKey. However, it does not explicitly state when to use this tool versus alternatives (e.g., for futures use open_futures_position), leaving the agent to infer from 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 indicate mutation and no idempotency, but description adds crucial context: idempotencyKey replay, paper execution costs, no financial advice. 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?

Well-structured with key points front-loaded. Slightly long due to execution policy details, but every sentence adds value. Could be trimmed slightly.

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 complexity (8 params, nested objects, output schema), description covers parameters, behavior, scope, cost, risk, and execution model comprehensively.

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%, but description adds meaning: coinId is UCID not ticker, required prices per order type, idempotencyKey is required and unique. Adds value beyond 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 places a paper spot order, with specific verb 'place' and resource 'spot order'. It distinguishes from siblings like 'spot_quote' (quote only) and 'cancel_spot_order' by focusing on order placement.

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 'Paper trading only' and 'CONFIRM with the user before calling', and mentions required scope. Does not explicitly list alternatives or when not to use, but context is clear.

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

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

Beyond the readOnlyHint and openWorldHint annotations, the description adds rich context: the computation window (~24h before resolution), the data cutoff (resolved markets with >=24h history), the minSample threshold causing venues to appear in `pending`, and the output fields. It also clarifies that the data is free and public, all without contradicting 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 description is dense but every clause earns its place: it packs the metric definition, output fields, methodology, threshold, usage, and auth status into two sentences without redundancy. The main purpose is front-loaded in the first phrase.

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 zero parameters and a provided output schema, the description covers everything an agent needs: what the numbers mean (lower ECE is better), how venues are selected, what the pending field indicates, how to cite the data, and that no authentication is needed. No critical gaps remain.

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, so per the rubric the baseline is 4. The description does not need to explain parameters and instead documents the response fields, which is appropriate given the schema is trivially 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 opens with a specific resource: 'per-venue forecast-accuracy scorecard' and details the headline metric (calibrationError), sample size, mean confidence, and reliability curve. This clearly distinguishes it from sibling data tools like pm_data_overview or pm_data_events, which focus on different aspects.

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 explicitly states when to use the tool: 'Use this to answer which venue forecasts best with evidence, not vibes.' It also notes 'No API key required' and instructs to 'cite CoinRithm's methodology field when quoting a number.' However, it does not name alternative tools for when not to use it, so it stops short of a 5.

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

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

Beyond the annotations, it discloses that the tool is free and public, requires no API key, never price-infers orientation, maintains an append-only judgment lineage, and prevents 404s for merged canonicals. These are meaningful behavioral traits not present in 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?

Though somewhat long, the description is densely informative and well-structured: definition, mode explanation, edge-case behavior, usage context, and auth note. Every sentence contributes useful, non-redundant information.

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

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

Given the read-only nature, full schema coverage, and presence of an output schema, the description covers all important context: invocation modes, pagination cursor, merged behavior, provenance details, and authentication. There are no obvious missing pieces.

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 covers all three parameters in detail, so the baseline is 3. The description adds value by explaining that `key` accepts a UUID or slug and that omitting it triggers list mode, plus that `limit` and `cursor` only apply in list mode. This goes beyond the schema but does not fully re-describe every 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 states a specific purpose: a stable cross-venue identity for one real-world question, independent of venue slugs. It clearly distinguishes two invocation modes (list directory vs full record by key) and differentiates from generic event tools by emphasizing durable canonical identity.

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 explicitly says when to use the tool: 'Use this to track one question across venues by a durable identity instead of re-matching venue slugs yourself.' It also clarifies the omit-key vs pass-key modes. However, it does not name alternative sibling tools or explicitly say when not to use 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?

Beyond annotations (readOnly, openWorld), the description discloses orientation methodology ('human/aggregator-reviewed — NEVER price-inferred'), the quality floor for requirePriced (same as CoinRithm's /today page), attribution requirements ('cite CoinRithm when quoting a gap'), and data semantics (graph-clustered, pairwise summaries). This is substantial behavioral context not available from annotations alone.

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 packs meaningful detail into each clause. It is somewhat dense, with the middle sentence listing output fields being long, but overall it is appropriately sized for a data-discovery tool of this complexity.

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 presence of an output schema, the description need not detail return values. It explains the data model, orientation guarantee, parameter default, attribution, and alternative tool, providing complete context 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?

Schema coverage is 100% with descriptive parameter fields, so the baseline is 3. The description adds extra context for requirePriced (quality floor, research/debug use) but does not systematically elaborate on other parameters beyond the schema. It provides marginal value over the 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 returns cross-venue disagreement clusters: prediction-market events matched as the same real-world question across 2+ venues, with one row per cluster. It explicitly differentiates itself from pm_quote for tradability, positioning this as a research/data tool. The resource and scope are unambiguous, though the verb is implicit.

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 guidance: 'Research/data only: for tradability of one specific outcome use pm_quote.' Also instructs when to set requirePriced false ('only for research/debug') and notes 'No API key required.' This constitutes clear when/when-not and alternative-tool 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?

The description reveals that the default summary bounds outputs for agent context windows while preserving counts and core evidence, a behavior not visible in annotations. It also clarifies referenceProbability quoting conventions and that the tool is free and public, adding value beyond readOnlyHint and openWorldHint.

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 the calibration examples but every clause carries operational value—listing return fields, explaining crossSourceMatches, and providing quoting guidance. It is front-loaded with the core purpose and uses clear sectioning through dashes, though it could be tightened.

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 purpose, output fields, behavioral constraints (summary/full), the relationship to pm_quote, and the absence of auth requirements. With an output schema present and four parameters documented, the description provides sufficient context for an agent to decide when and how to invoke.

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 four parameters are already fully described in the schema (100% coverage), so the description adds limited new parameter meaning. It does reinforce that source+slug identify the event and that detail defaults to summary, but this is consistent with 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 opens with 'Free public detail for one prediction-market event by venue + slug' and lists specific data returned, clearly distinguishing it from list-style siblings like pm_data_events. It also separates itself from pm_quote by labeling itself the 'cross-venue research view.'

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 explicitly states this is the 'cross-venue research view' and directs users to pm_quote for tradability. It also explains when to use detail=full versus the default summary, and notes no API key is required. It does not exhaustively enumerate all sibling alternatives, but the guidance is practical and sufficient.

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 read-only and non-destructive behavior. The description adds meaningful context: 'Free public search' and 'No API key required' disclose access requirements, and the explanation of quality/blocking (blocked markets stay visible but cannot drive paper opens or alerts) reveals behavioral consequences beyond the annotations. This enriches the agent's understanding of what the tool can and cannot do.

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 lengthy but well-structured: it opens with the primary purpose, then covers return fields, special metadata, and usage guidance. While some sentences are dense, each portion earns its place given the tool's complexity. It is front-loaded and avoids unnecessary filler, though it could be trimmed slightly 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 tool's complexity (12 venues, multiple return fields, cross-venue metadata) and the presence of a full output schema, the description is thorough. It explains return fields, reference probabilities, quality/blocking semantics, cross-platform links, and usage boundaries. The context is complete for an agent to decide when and how to invoke this 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 input schema covers 100% of parameters with descriptions, so the baseline is 3. The description does not add additional parameter-level detail beyond the schema; it focuses on output fields and usage. It lists venue names, but these are already in the schema's source parameter description. Thus, the description adds no extra semantic value for the parameters.

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 a specific verb and resource: a free public search over prediction-market events across all 12 venues. It explicitly distinguishes itself from sibling discover_pm_markets by noting the broader venue scope, and also recommends pm_data_event for all outcomes. 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: broader than discover_pm_markets, use pm_data_event for all outcomes and full evidence, and for trading use discover_pm_markets + pm_quote instead. It clearly delineates the appropriate context versus alternatives, and even states 'Research/data only.'

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 read-only annotation, the description discloses source-aware freshness, per-venue volume basis, restriction to real-money venues for monetary totals, self-computed nature requiring citation, and the absence of authentication. These are significant behavioral caveats that meaningfully inform usage.

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 long but well-structured: purpose first, then alternative, freshness, caveats, and authentication. Each sentence adds necessary information, though it could be slightly trimmed without losing 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?

For a read-only statistics tool with an output schema, the description is comprehensive. It covers the metrics returned, venues included, freshness behavior, health resource, monetary caveats, and attribution requirements—leaving no major gaps.

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

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

The input schema already provides complete coverage for the single fiat parameter (description + default). The tool description adds context about monetary totals but no additional parameter-level detail, so the schema carries the full burden.

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 cross-venue prediction-market statistics, enumerates specific metrics (market counts, volume, liquidity), and lists all 12 venues. It distinguishes itself from siblings by explicitly directing users to pm_data_event for full event evidence.

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 an explicit alternative ('Use pm_data_event for full event evidence'), clearly implying when this overview tool is appropriate. It also notes that no API key is required, and points to a separate health endpoint for freshness details.

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), the description adds concrete behavioral context: it is free, requires no API key, and covers every venue with explicit bases. It also discloses the risk of misinterpreting data, which is valuable context for invocation.

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 three sentences and every sentence adds value: the first lists the content, the second provides usage guidance, and the third notes access. It is well-structured and 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?

Given that an output schema exists and the annotations declare read-only, non-destructive behavior, the description sufficiently covers what the tool does, when to use it, and key caveats. It does not need to explain return values because the output schema is present.

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

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

The input schema contains one optional 'fiat' parameter with its own description, and schema coverage is 100%. The tool description does not mention parameters, but the schema already fully defines them, 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 that the tool provides 'methodology and comparable coverage' for prediction-market venues, enumerating specific data elements such as source kind, supported metrics, market counts, volume bases, currency basis, comparability, and as-of timestamps. This distinguishes it from sibling tools like pm_data_health or pm_data_overview.

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 explicitly instructs to 'Use this before comparing venue totals' and warns against mislabeling completed-day figures as rolling 24h or play-money as USD. It does not name alternative tools or state when not to use it, but the usage context is clear.

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

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

Annotations already declare readOnlyHint=true and destructiveHint=false, so the safety profile is covered. The description adds valuable context beyond annotations: 'No API key required', 'Free public', and the important caveat that catalog presence does not prove live freshness. This enriches the agent's understanding of access and data caveats.

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 redundancy. The first sentence front-loads the core function and fields; the second gives actionable guidance. Every word 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?

At zero parameters, with clear annotations and an output schema likely covering return fields, the description is complete. It covers why to use, when to use, and the key caveat about freshness, so an agent can correctly select and invoke it.

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

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

The tool has zero parameters, so the baseline of 4 applies per the scoring guide. No parameter documentation is needed; the description focuses on output and usage 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 clearly identifies the tool as a per-venue ingest health endpoint across all CoinRithm sources, listing concrete fields (freshness tier, observed lag, stale/degraded reason, coverage counts, health timestamps). It differentiates from sibling tools like pm_data_sources and pm_data_overview by focusing on health/freshness status rather than source listing or general overview.

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 instructs users to check this tool before using a quote or claiming cross-venue coverage, providing a clear use-case trigger. It does not name alternative tools directly, but the context implies it is a prerequisite sanity check, which is sufficient guidance.

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

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

Beyond the annotations (readOnly, openWorld), the description discloses key behaviors: data is captured forward from 2026-07-02, bounded to a rolling ~90-day window, gaps are nulls rather than zeros, and play-money venues are excluded. This is rich context that prevents misinterpretation of the data.

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

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

The description is dense but efficient, with each sentence adding critical information: computation method, venue exclusions, gap semantics, window bounds, and access requirements. No filler 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?

Given the output schema is present, the description doesn't need to detail return fields. It fully covers the tool's temporal coverage, data granularity, venue scope, and null behavior, making it sufficient for an agent to select and invoke correctly.

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

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

The tool accepts no parameters (empty input schema), so the description need not elaborate on parameters. The baseline for zero-parameter tools is 4, and the description appropriately focuses on output semantics rather than inputs.

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

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

The description clearly states the tool provides a global daily prediction-market volume trend, specifying the computation method (day-over-day delta of cumulative volume), venue inclusion (real-money only), and intended use (assess growth/shrinkage). This distinguishes it from sibling data tools that likely provide different metrics.

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 to see whether cross-venue prediction-market activity is growing or shrinking over time,' giving a clear intended use. It also notes 'No API key required,' which is access guidance. However, it does not mention alternatives or when-not-to-use scenarios, so it stops short of a 5.

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

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

Annotations already mark this read-only; the description adds that no API key is required, that Polymarket rows are wallet-attributed while Kalshi rows are anonymized, and that a print is informational, not a recommendation. These details go well beyond annotations and clarify data provenance and interpretation. 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?

Four sentences, each carrying distinct value: core function and fields, venue attribution, informational disclaimer, and access requirement. No filler, repetition, or unnecessary detail, and the most important 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 read-only listing tool with one parameter and an output schema, the description covers the data sources (venues), content (fields), ordering (newest first), attribution, and access requirements. It leaves no critical usage gaps.

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

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

The single 'limit' parameter is fully described in the schema (1-50, default 10) with 100% coverage. The description mentions 'newest first' and the $1k+ threshold but does not add any extra meaning to the parameter itself, so it stays at the baseline for high 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 states 'Free public tape of the latest large prediction-market trades' and enumerates the exact fields returned (side, USD value, price, market question, event). It uniquely identifies this as the whale-trade feed among siblings like pm_data_events and pm_data_overview, 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 clear context: a public, no-key tape of large trades sorted newest-first. However, it does not explicitly name alternative tools or state when not to use it, so it lacks exclusionary guidance but still gives enough context for basic selection.

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, and the description reinforces no state mutation. It adds significant behavioral context: explains the openBlocked mechanism (preview of potential open rejection with reason codes), side behavior (NO fills at 100 minus probability), paper trading constraints, execution costs, and lack of fill guarantee. 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?

The description is quite long (multiple paragraphs) but is well-structured: it front-loads the main quote components, then explains side behavior, paper trading details, and execution costs. Every sentence adds information, but some parts (like execution cost details) could be more concise. Still, it earns its length given the tool's complexity.

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 return fields (entry probability, share estimate, max payout, etc.) and explains openBlocked/reasons. It addresses safety (read-only), side mechanics, and paper trading constraints. An output schema exists (not shown) but is referenced. No obvious gaps for a quote tool, though it could mention any rate limits or pagination if applicable (likely not).

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%, but the description adds value beyond schema: it clarifies stakeMusd minimum (min to open is 10), explains side behavior in depth, and describes agentTrace as stored private metadata. This extra context aids understanding beyond the 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 it's a read-only PM quote for a binary outcome, listing specific fields returned. It contrasts with open_pm_position by explaining the openBlocked field, which previews potential rejection. The tool name and sibling tools (futures_quote, spot_quote) provide context, but the description itself makes 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?

The description explicitly states it is read-only and never mutates state. It provides conditions like stakeMusd must be > 0 (min 10) and explains side parameter behavior. It contrasts with open_pm_position via openBlocked, indicating when to use this quote before attempting to open. However, it does not explicitly differentiate from other quote tools (futures_quote, spot_quote), though the PM specification and sibling context make this clear.

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

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

The description claims 'needs only the read scope, never moves funds,' which contradicts the annotation readOnlyHint=false indicating the tool may modify state. No further behavioral details are provided to resolve this inconsistency.

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 lengthy with multiple paragraphs including tangential details like execution cost structure. While it front-loads the main purpose, it could be 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?

Given the tool's complexity (12 params, nested objects), full schema coverage, and existing output schema, the description adequately covers paper trading context, idempotency, and self-report nature, despite the contradiction.

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 is 3. The description adds context for the 'kind' enum and forecastProbability requirement but does not significantly enhance understanding of other parameters 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 the verb 'report' and the resource 'non-opened PM opportunity' with a rationale about reflecting the full opportunity universe. It distinguishes from opening positions and other reporting tools by focusing on opportunities not acted upon.

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 when to use the tool (evaluated but did not open), lists the three kinds (abstained, forecast_only, quote_expired), and provides guidance on idempotency (reuse decisionId) and context (paper trading, virtual funds). It does not explicitly compare to alternative tools but gives sufficient 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 indicate readOnlyHint=true and destructiveHint=false. The description adds significant behavioral context: paper trading with virtual funds (50,000 mUSD), not financial advice, and detailed execution cost mechanics (taker fees, slippage, etc.) that go well beyond the annotations.

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

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

The description is verbose, containing many details about execution costs (e.g., paper filling, fees, slippage) that are only tangentially relevant to the resolution task. While front-loaded with the primary purpose, it could be 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?

An output schema exists (not shown) so return value details are not needed. The description covers the essential usage and behavioral constraints thoroughly, though the execution cost details are somewhat extraneous for a lookup 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 coverage is 100%, with descriptions for both 'q' and 'agentTrace'. The description does not add new information about parameters beyond what is in 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 resolves human-readable symbols/slugs/names to CoinRithm coinIds (UCID) with disambiguating alternatives. This is a specific verb+resource that distinguishes it from sibling tools that require coinId for trading operations.

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

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

Explicitly instructs to use this tool first to obtain the coinId needed by wallet/quote/order tools, and warns not to guess UCIDs because symbols are not unique. 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.

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

The description adds significant context beyond annotations: it explains the side-aware behavior, that triggers fire on a per-minute worker, that the full position is closed at mark, and that it requires the trade:futures scope. It also discloses that this is for paper trading with virtual funds and not financial advice. 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 lengthy (approx. 160 words) and includes several extraneous details about execution costs, fees, and disclaimers. While the main purpose is front-loaded, the length reduces conciseness. The structure is logical but could be trimmed.

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 the tool (4 parameters, nested objects, output schema), the description covers usage, side-awareness, paper trading constraints, execution model, and references output schema (executionModel). It is complete enough for effective invocation.

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

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

Schema coverage is 100%, but the description adds important meaning: 'null clears it, an omitted field is unchanged' and explains side-aware conditions for stopLossPrice and takeProfitPrice. This provides clarity beyond the 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 verb 'set or clear' and the resource 'stop-loss / take-profit triggers on an OPEN mock futures position'. It distinguishes from siblings like close_futures_position and open_futures_position by specifying that it only modifies triggers on an already open position.

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

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

The description says when to use: on an open mock futures position, and clarifies that it is for paper trading only. It also mentions required scope (trade:futures) and provides side-aware conditions. While it doesn't explicitly list alternatives, the sibling tools are contextually distinct 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?

The description reinforces the readOnlyHint by stating 'Never mutates state' and adds context about paper trading, virtual funds (50,000 mUSD), execution cost model, and fee structure. This goes beyond the annotations, which only indicated readOnlyHint and openWorldHint. 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 long and contains many details (e.g., specific fee models, execution policy, calibration notes) that may be excessive for tool selection. While the first sentence effectively states the purpose, the subsequent dense text could be streamlined. It is adequately structured but not optimally 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?

Given the presence of an output schema, annotations, and 4 parameters, the description covers key usage context: read-only nature, paper trading, coinId resolution, and the need to quote before ordering. It lacks explicit differentiation from sibling quote tools but otherwise provides sufficient context for an agent to decide when to use this 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 coverage is 100%, so baseline is 3. The description adds crucial value by clarifying that coinId is a UCID (not a ticker) and directing to resolve_symbol. It also rephrases side and quantity, but schema already covers those. The agentTrace parameter is not elaborated beyond schema, but the overall additional guidance earns a 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 clearly states 'Read-only spot MARKET quote' and specifies it provides live execution price, estimated cost, available balance, and fill eligibility. It distinguishes itself from 'place_spot_order' by advising to quote before ordering. The tool name and sibling set include other quote types (futures_quote, pm_quote), but the description sufficiently identifies it as spot-focused.

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 advises to use this tool before placing an order ('quote before place_spot_order instead of buying/selling blind'). It also clarifies that coinId is a UCID requiring resolution via resolve_symbol first, and notes it is for paper trading only. However, it does not provide guidance on when to choose this over futures_quote or pm_quote, leaving some ambiguity.

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

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

Goes well beyond readOnlyHint annotation by detailing paper trading, virtual funds, execution costs, and null field conditions. 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 lengthy and includes detailed execution cost policy not essential for core understanding. It could be more concise while retaining key points.

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 output schema existing, the description thoroughly covers what is returned, usage context, and behavioral nuances. No gaps remain for a read-only identity 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 covers the single optional parameter (agentTrace) with 100% description coverage. The description adds no additional parameter meaning beyond what the schema 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 explicitly states the tool returns identity details (userId, keyId, scopes, agentName, agentModel). It clearly distinguishes itself from trading-related siblings by focusing on account info.

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 it first to confirm key permissions, providing a clear usage context. It does not explicitly list alternatives or when not to use, but the guidance is sufficient.

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