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

Beyond the idempotentHint and destructiveHint annotations, the description explains the 'alreadyClosed=true' ambiguity, notes that repeated calls are safe, and details API failure behavior with ok=false, httpStatus, and retryAfterSeconds. This is rich behavioral context beyond structured 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 sentence earns its place: main operation, auth and source of orderId, idempotency nuance, fill-checking alternative, and rate-limit handling. It is front-loaded with the core action and quickly moves to practical caveats.

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 operation, required scope, orderId source, idempotency ambiguity, fill-check alternative, and error/rate-limit behavior. An output schema exists, so return value details are not required, and the description provides everything else needed to 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%, so baseline is 3. The description adds useful meaning for orderId by specifying it must come from list_open_orders and that it is the caller's paper spot order id, reinforcing but not replacing 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 states a specific action and resource: 'Cancel the unfilled remainder of your paper spot order and release its reserved funds.' It distinguishes itself from siblings like place_spot_order and get_my_trades by clarifying it only cancels the unfilled remainder, not filled trades.

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 requires 'trade:spot scope' and tells the agent to get orderId from list_open_orders. It also clarifies when not to rely on this tool by stating 'Does not reverse filled trades' and directs to get_my_trades to check fills, plus gives 429 retry 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 mark destructiveHint as true, and the description reinforces that the tool closes or reduces positions. It adds extensive detail about execution cost, taker fees, and that it's a rehearsal cost, providing transparency beyond annotations.

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

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

The description is relatively long and includes detailed execution model information that may be extraneous for an AI agent. The core purpose is front-loaded, but the text 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 has 4 parameters (2 required), nested objects, and an output schema, the description provides sufficient context: paper trading, required scope, idempotency, and execution costs. It covers all essential aspects for correct usage.

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 all parameters with clear descriptions. The description adds context by explaining the fraction parameter and the requirement for idempotencyKey, slightly enhancing meaning beyond the schema.

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

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

The description clearly states 'Close or partially reduce a mock futures position' which is a specific verb+resource. It distinguishes itself from siblings like open_futures_position and set_futures_sl_tp by focusing on closing/reducing.

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

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

The description specifies that idempotencyKey is REQUIRED and notes paper trading only. However, it does not explicitly tell when to use this tool versus alternatives like open_futures_position or set_futures_sl_tp, 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?

Annotations already indicate read-only, open-world, non-destructive. Description adds significant detail about return fields, decisionEligible meaning, execution cost policy, and fee structure. 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?

Description is front-loaded with main purpose. While lengthy, each sentence adds value (return fields, dependencies, fees). Could be slightly more concise but effectively structured for a complex tool.

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

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

Given 6 optional parameters and an output schema, the description provides comprehensive context: what it does, what it returns, usage order, fee structure, and paper trading policies. Very complete.

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

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

Schema coverage is 100% with each parameter having a description. The tool description does not add extra meaning beyond the schema for the parameters, 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 finds active-open prediction markets from Kalshi and Polymarket, with specific return fields. It distinguishes from siblings like pm_quote and open_pm_position by noting this is discovery only.

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

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

Explicit guidance: use this for discovery, then call pm_quote before open_pm_position. Also mentions paper trading context, though no explicit when-not-to-use, the dependency chain is clear.

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

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

The description extensively discloses behavior beyond annotations: export limit, private availability, paper trading nature, virtual funds, execution cost details (taker fees, slippage, policy version). All align with readOnlyHint and destructiveHint. 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 longer than necessary, including detailed execution model explanations and disclaimers. While well-structured (purpose first, then filters, then caveats), some sentences are verbose and could be trimmed for brevity without losing essential 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 8 parameters and nested objects, the description covers key aspects: row limit, privacy, paper trading context, and filter usage. Output schema exists, so return format is handled. It lacks mention of pagination for high-volume exports but is otherwise complete for selection and 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% with descriptions, so baseline is 3. The description adds value by highlighting runId and decisionId filters for reproducible evaluation, giving them context beyond the schema. It does not cover all 8 parameters but the schema already handles them.

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

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

The title and description clearly state the tool exports private agent ledger rows as JSON, with a limit of 1,000 rows. It specifies the data scope (calling API key's private ledger) and distinguishes it from siblings like get_agent_ledger (which likely returns the ledger for viewing).

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 filters (runId, decisionId) for reproducible evaluation and clarifies data privacy. However, it does not compare with sibling tools such as get_agent_ledger or export_run_evidence to guide selection. The guidance is clear but not exhaustive.

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 reveals behavioral traits: the bundle includes sanitized ledger rows, execution assumptions, and fee details. It clarifies that data is private and paper trading only, and adds context on execution costs and policy, which annotations do not cover.

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

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

The description is front-loaded with the core action, then elaborates on contents and constraints. It is slightly verbose with financial details (fees, policy) but each sentence adds value. Could be more concise without losing essential context.

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 (nested object, output schema present), the description covers the tool's purpose, contents, limitations (paper trading, private), and execution model. It is comprehensive enough for an agent to decide usage without additional explanation.

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

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

Schema description coverage is 100%, so the baseline is 3. The description mentions 'for a specific agentTrace.runId' but does not add new meaning beyond the schema's parameter descriptions. No examples or syntax details are provided.

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: 'Export one private reproducibility bundle for a specific agentTrace.runId.' It specifies the resource (runId) and distinguishes from siblings like export_agent_ledger by focusing on reproducibility bundle and paper trading restrictions.

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

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

The description provides context on when to use (paper trading, private data) but does not explicitly contrast with export_agent_ledger or other export tools. It implies usage via constraints like 'Paper trading only' and 'No public Arena user can see this data.'

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 aligns fully and adds significant context: explains paper execution policy, cost model (taker fees, slippage), and that the result is a 'rehearsal cost, not an exchange fill guarantee.' This goes well beyond annotations, providing deep behavioral insight without contradiction.

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

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

The description is efficient (6 sentences) and front-loaded with purpose. It covers essential points but includes a dense paragraph on execution policy that could be streamlined. Overall, it is appropriately sized for the tool's complexity, with minimal redundancy.

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

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

Given the tool's complexity (5 params, nested objects, output schema present), the description covers purpose, usage constraints, behavior, and execution policy. It does not explain the output schema or provide explicit relationship to sibling quote tools, but it is sufficiently complete for an AI 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?

Input schema has 5 parameters with 100% description coverage. The description adds only marginal value beyond the schema, such as reiterating leverage range and margin minimum, but does not provide new meaning or usage details for individual parameters beyond what is already 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 'Read-only futures quote: entry price, notional, size, liquidation price, and eligibility.' It uses a specific verb ('quote') and resource ('futures'), and distinguishes from siblings like spot_quote and pm_quote by emphasizing its read-only nature and timing ('always quote before opening').

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

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

The description provides clear context: 'always quote before opening' and constraints on leverage (1-20) and margin (>=10). It also states 'Paper trading only — virtual funds (50,000 mUSD).' However, it does not explicitly exclude alternatives or compare to sibling quote tools, such as when to use spot_quote or pm_quote instead.

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

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

Annotations already indicate readOnlyHint=true and destructiveHint=false. The description adds substantial behavioral details: explains it returns only calling key's rows, describes paper execution policy, fee structure, and states it's not an exchange guarantee. 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 the core purpose and then adds necessary details about fees and policies. It is somewhat lengthy but efficient for the complexity, earning its sentences without redundancy.

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

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

Given the tool has an output schema and 10 parameters, the description covers key aspects: data types, key scope, paper trading context. It lacks some operational details like pagination defaults (covered in params) but is sufficient for an audit 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 all 10 parameters documented. The description provides high-level context (e.g., agentTrace metadata) but does not add specific parameter 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 'List this API key's private execution ledger' and enumerates specific data types (reads, quotes, writes, etc.). It distinguishes from siblings by highlighting key-scoped access and paper trading only, differentiating from tools like get_my_trades or export_agent_ledger.

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 audit a reproducible paper-trading run' and 'Paper trading only', providing clear context. It does not explicitly state when not to use or list alternatives, but the paper trading and key-scoped nature implies appropriate 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?

Annotations already declare readOnlyHint=true and destructiveHint=false. The description supplements this by detailing paper trading constraints, execution policy, and cost structure, adding significant behavioral context 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 essential purpose, but the lengthy explanation of paper execution costs (several sentences) could be condensed. It is informative but somewhat verbose for a tool description.

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

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

Given the presence of an output schema, the description does not need to detail return values. It adequately covers scope (public, paper), data fields, and execution model, leaving no major 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 covers 100% of the single parameter with a basic description. The tool description adds value by connecting the handle to the leaderboard and providing an example, clarifying where to obtain valid values.

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's purpose: retrieving a single agent's public Arena profile by handle. It lists specific data returned (rank, PnL, trade counts, win rate) and distinguishes it from the sibling get_arena_leaderboard by referencing the 'handle' field from that tool.

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

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

The description states 'Public data only — no account or key identity' and 'Paper trading only — virtual funds', clarifying appropriate contexts. It does not explicitly name alternatives but implies when not to use it (real trading, private data).

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

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

Annotations already declare readOnlyHint=true, and the description adds rich behavioral context beyond that: the ranking methodology, the arena-ranking-v1 contract, paper trading details, execution costs, and the nature of the data. It does not contradict annotations and substantially increases transparency about what the tool returns and its limitations.

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

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

The description is long but well-structured: it starts with the core purpose, explains the ranking method, then covers paper trading and execution costs. Every section adds necessary context for correct use and interpretation. It is front-loaded and flows logically, though slightly verbose for the tool's simplicity compared to the detail provided.

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 is exceptionally complete for a read-only leaderboard tool. It explains the ranking contract, row contents, window behavior, paper trading caveats, and execution model, and suggests usage patterns. Combined with the output schema (not shown but declared) and the detailed parameter descriptions, an agent has everything needed to call and interpret the tool correctly. The only gap is the window enum discrepancy, which is a schema issue rather than a completeness issue.

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

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

The description adds meaningful semantics for the window parameter (e.g., '7d/30d re-rank by in-window realized PnL; counts/winRate/sparkline become window-scoped'). However, it also lists values ('today', '24h', '3m') not present in the schema enum, which could mislead an agent. Schema coverage is 100%, so baseline is 3; the added meaning is offset by the inconsistency, keeping the score at 3.

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

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

The description clearly states the tool gets the public Agent Arena leaderboard, specifying it covers spot, futures, and prediction markets. It distinguishes itself from siblings by noting it is public data (agent names + performance only) and naming companion tools get_performance and get_arena_agent for follow-up.

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 when to use: 'Use it to see the field and where you stand' and recommends pairing with specific siblings. Also provides context on paper trading and the data scope, giving clear guidance on when this tool is appropriate versus 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 only declare read-only/non-destructive/open-world; the description goes well beyond that with genuinely non-obvious traits: candles are oldest-to-newest, t is in unix SECONDS, o/h/l/c are in fiat while v is always USD, bars are sampled composite prices rather than venue trade candles, and v is a rolling 24h quote-volume observation that must not be summed. These are the semantics an agent would otherwise get wrong.

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-loading is strong — purpose, then range semantics, then units and the v caveat. However the closing paragraph about paper fills, taker fees, Polymarket-shaped fees and entryProbability describes execution, not candle retrieval, and reads as boilerplate carried over from quote/trade tools; it does not earn its place here.

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

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

Given an output schema exists, return values need no explanation, and the description covers everything else an agent needs: the prerequisite resolution step, unit conventions, ordering, data provenance, and the critical misuse warning about summing v. Nothing needed to call this correctly is missing.

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

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

Schema coverage is 100%, so the baseline is 3, but the description adds real value beyond the schema by decoding the range enum into concrete lookback/resolution pairs (1H=60x1-minute, 1D=288x5-minute, 1W=672x15-minute, 1M=720x1-hour, 3M=540x4-hour) and confirming fiat's default and unit behavior. Only the agentTrace sub-object is left to 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?

Names a specific verb+resource (OHLCV candles) and immediately scopes the use case to indicator/momentum strategies (RSI, moving averages, breakouts). It also names the sibling dependency (resolve_symbol) so the agent can distinguish this from other market-data tools without opening a schema.

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

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

Explicit prerequisite: 'resolve_symbol first to get the coinId' — the single most likely failure mode for this call. Usage context is clear from the strategy framing, but it never excludes alternatives (e.g., get_market_context or the pm_data_* family) or states when candles are the wrong choice.

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

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

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 already declare readOnlyHint=true, openWorldHint=true, destructiveHint=false. The description adds significant behavioral context: explains the paper trading simulation, execution costs, taker fees, rehearsal cost, and that it's not financial advice. This goes well beyond annotations to disclose data quality and limitations.

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

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

The description is front-loaded with the core purpose and then provides necessary detail about granularity and execution model. While somewhat lengthy, every sentence adds value. It is well-structured but could be slightly 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 has 3 parameters, an output schema (indicated), and is a read-only data retrieval, the description fully covers what the tool does, its parameters, output format (date and usdValue for daily, cumulative for realized), and important context (paper trading, execution costs). No gaps.

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

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

Schema coverage is 100%, so baseline is 3. The description adds meaning by explaining the behavior of 'granularity' (daily returns one point per day, realized returns intraday points per event with cumulative total) and 'days' look-back window range and default. This enriches the parameter understanding, justifying 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 identifies the resource ('Wallet equity time series for the paper account') and verb ('Get'). It distinguishes from siblings by specifying it's for performance review over time and narrating results, distinct from get_portfolio or get_positions which are current state.

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: for reviewing performance over time and narrating results. It distinguishes between daily (standard) and realized (active intraday agents) granularities. It also states 'Paper trading only' and mentions the look-back window. While no explicit 'when not to use' or alternatives are listed, the context and granularity descriptions provide clear usage 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 behavioral context beyond the annotations (readOnlyHint=true): paper trading only, virtual funds, not financial advice, and detailed execution cost policies for different order types. This helps the agent understand the simulation nature, though annotations already indicate non-destructive read.

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 data list, then covers prerequisites, paper trading, and execution costs. It is somewhat long but each part adds value, especially for behavioral transparency. Could be trimmed slightly without losing key info.

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 the input requirements, output components, prerequisites, paper trading context, and fee disclosure comprehensively. No obvious gaps for a context-gathering 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 the schema already describes both parameters (coinId and agentTrace). The description adds the prerequisite to use resolve_symbol for coinId and explains output content (e.g., prediction markets), but doesn't add new parameter-specific meaning beyond the schema's 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 provides 'Compact factual context for ONE coin to form a thesis' and lists specific data points (price, changes, market cap, etc.), distinguishing it from siblings like get_candles or resolve_symbol. It explicitly instructs to call resolve_symbol first, reinforcing its unique role.

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

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

It explicitly says to call resolve_symbol first and notes that it provides facts only, for thesis formation. It does not explicitly list when not to use it, but the context of paper trading and the list of siblings imply its specific use case. Could be improved by mentioning alternatives like get_candles for historical data.

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 extensively details behavioral traits beyond annotations: paper trading with virtual funds, execution cost modeling, fee structures, and the polling mechanism via 'asOf'. Annotations (readOnlyHint, openWorldHint, destructiveHint) are consistent and supplemented with rich context.

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

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

The description is well-structured, front-loading the core purpose and usage. While verbose, each sentence provides essential context for an AI agent (paper trading details, execution model). Minor redundancy in execution fee breakdown.

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 params, output schema, many siblings), the description covers all necessary aspects: purpose, usage, behavior, parameter semantics, and special considerations (paper trading, polling). It is self-contained and complementary to the schema and annotations.

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 4 parameters fully. The description adds value by explaining the cursor pattern for 'updatedSince' and the context of 'agentTrace' (trace metadata). 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 defines the tool as a unified realized-PnL log of closed trades across venues, acting as the agent's memory. It distinguishes from siblings like 'get_positions' (open positions) and 'get_performance' (aggregated 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 states to use it for reviewing performance before deciding the next move and explains the polling pattern with 'updatedSince'. While it doesn't list explicit when-not-to-use scenarios, the context is clear and covers the primary use case.

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 context beyond annotations, detailing that it uses virtual funds, applies a specific execution policy (paper_execution_v1), and describes execution costs. This enriches the agent's understanding of the tool's behavior.

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

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

The description is concise but packed with necessary details. It is front-loaded with the core purpose and then elaborates on constraints and execution model. The 'Not financial advice' sentence is slightly redundant but minor.

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 (realized PnL, trade counts, win metrics, execution policy), the description covers all relevant aspects: output fields, limitations (closed trades, paper only), and execution model. The presence of an output schema makes this complete.

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

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

Schema coverage is 100% with one optional parameter (agentTrace) well-described in the schema. The description does not add additional meaning beyond what the schema provides; it only reiterates the return structure. Baseline 3 is appropriate given high coverage.

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

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

The description clearly states 'The calling key's own realized performance: total + per-venue realized PnL...', providing a specific verb (get) and resource (own realized performance). It distinguishes from siblings by focusing on the agent's own realized PnL and trade statistics, which sets it apart from tools like get_portfolio or get_my_trades.

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

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

The description implies usage for the agent's own performance and specifies conditions: 'Paper trading only' and 'Closed trades only'. However, it does not explicitly compare with alternative tools or state when not to use it, leaving some room for 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?

Annotations already declare readOnlyHint=true and destructiveHint=false. The description goes far beyond these by detailing the paper execution model, fee structure, slippage, and the fact that fills are rehearsals, not guarantees. This extensive disclosure of behavioral traits provides high transparency without contradicting 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 (multiple sentences) and includes extensive detail about execution models and fees. While the first sentence front-loads the main purpose, the subsequent detail could be streamlined or moved to an output schema. The wordiness reduces conciseness, though the structure is logical.

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

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

Despite its length, the description is complete: it explains what the tool returns, the paper-only nature, and the behavioral quirks of fills. An output schema exists (not shown), which reduces the need to document return values, but the description already does so. The only minor gap is a lack of guidance on usage versus 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 coverage is 100%, and all three parameters (fiat, locale, agentTrace) are described in the schema. The description does not add new semantic meaning to the parameters; it focuses on the output and behavior. With full schema coverage, a baseline of 3 is appropriate.

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

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

The description clearly states it returns a 'lean, PII-free paper account summary' and enumerates the specific components (walletId, equity, PnL, orders, progression). This is a specific verb ('Get') and resource, and implicitly distinguishes from sibling 'get' tools like get_wallet or get_performance by focusing on the paper trading summary.

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

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

The description mentions 'Paper trading only' and 'Not financial advice,' providing some context on when to use. However, it does not explicitly state when not to use this tool or suggest alternatives. For a tool that is one of many 'get' tools, more explicit guidance on choosing between get_portfolio and get_wallet or get_performance would improve the score.

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

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

The description adds significant behavioral context beyond the annotations (readOnlyHint, openWorldHint, destructiveHint). It details mock data, virtual funds, execution costs, fees, slippage, and the rehearsal cost nature. This provides a comprehensive understanding of the tool's behavior and limitations.

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

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

The description is front-loaded with the main purpose and well-structured. It is somewhat lengthy but each sentence adds necessary detail. A slight reduction could improve conciseness, but overall it is efficient.

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

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

Given the tool's complexity (3 parameters, nested objects, output schema exists), the description covers all necessary context: what positions are returned, how to poll for changes, paper trading nature, and execution model. It is complete without relying solely on the output schema.

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

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

With 100% schema coverage, the schema already documents parameters well. The description adds value by explaining the purpose of 'updatedSince' for polling, venue-specific position contents (unrealized PnL, liquidation distance, mark), and the optional nature of agentTrace. This goes beyond the schema's 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 lists open and historical positions for a venue, distinguishing between futures and pm with specific mock data details. It is a specific verb+resource action that 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?

The description explains when to use the tool (to list positions), provides context for polling with the 'asOf' and 'updatedSince' parameters, and clarifies it's for paper trading only. However, it does not explicitly state when not to use it or mention alternative tools among the 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?

Annotations already indicate readOnlyHint=true, and the description adds extensive behavioral details: the wallet is paper-only, virtual funds, execution cost model, and that fills are rehearsals. No contradictions with annotations; the description enhances transparency beyond structured fields.

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

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

The description is lengthy (about 10 sentences) and includes excessive detail on execution costs, which may be tangential. While well-structured front-loading core purpose, it is not concise and could be trimmed for 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 two optional parameters, high schema coverage, and presence of output schema, the description provides sufficient context: purpose, wallet structure, paper trading environment. It is complete for correct tool usage, though slightly over-informative.

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 coinId and agentTrace. The description does not add new meaning beyond the schema; it reiterates the optional coin filter but without extra depth. 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 verb 'Get' and the resource 'raw cash balances' with specific details about USDT and frozen partitions. It also distinguishes from sibling tools like get_portfolio by focusing solely on cash and frozen funds, not positions or trades.

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 notes that this is for paper trading only with virtual funds, providing clear context. However, it does not mention when not to use this tool or provide explicit alternatives among siblings, though the purpose is specific enough to guide correct 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 indicate readOnlyHint=true and destructiveHint=false, and the description adds significant context: paper trading only, virtual funds, execution cost disclosure under paper_execution_v1 policy. It also explains delta polling with asOf. 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 front-loaded with the core purpose in the first sentence. It then explains parameters and polling before detailing paper trading policies. While a bit verbose on execution costs, each sentence adds useful context for an 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 (4 parameters, output schema present), the description covers all necessary aspects: purpose, parameter usage, polling, paper trading context, and execution model. It is self-contained and supports correct agent 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 parameters are already documented. The description adds value by explaining the default behavior for coinId (omit for all) and the polling mechanism for updatedSince. This goes beyond the schema's basic 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 lists open spot orders, specifies the verb 'list', and provides distinction by mentioning omission of coinId for all orders. It differentiates from siblings like cancel_spot_order or place_spot_order by focusing on read-only listing.

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 guidance on when to use the tool (to list open orders) and how to use parameters like coinId for filtering and updatedSince for delta polling. However, it does not explicitly contrast with related tools like get_my_trades or spot_quote, leaving some inference to the agent.

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

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

Extensive disclosure beyond annotations: scope, server-flag gating, idempotency, leverage/margin constraints, side-aware SL/TP corridors, paper trading nature, virtual funds, execution costs, and contract model. 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?

Description is lengthier than average but every sentence adds value and critical details. Structure is logical: action, scope, constraints, best practices, execution model. Slightly verbose 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 the tool's complexity (8 params, output schema present, paper trading simulation), the description fully covers purpose, constraints, execution model, and agent guidance. No gaps for agent 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 covers all parameters (100% coverage), but description adds valuable context like the side-aware corridor logic for stopLossPrice/takeProfitPrice and the requirement for idempotencyKey uniqueness.

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

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

Description clearly states it opens or adds to a mock futures position, specifying the verb and resource. It distinguishes itself from sibling tools like close_futures_position and futures_quote.

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

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

Provides clear context: when to use (open futures), requirement to quote and confirm, and idempotency key usage. While it doesn't list alternative tools, it gives actionable guidance for correct invocation.

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?

Description goes beyond annotations by detailing server-flag gating (403 if disabled), paper trading nature, execution costs (taker fees, slippage), and the use of idempotencyKey for replay. This provides rich behavioral context beyond the basic annotations (readOnlyHint=false, idempotentHint=true, destructiveHint=false).

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 reasonably concise given the complexity, with critical information front-loaded (binary outcomes, scope, idempotency, min stake). Each sentence adds value, though it could be slightly tightened 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 (9 parameters, 5 required, nested objects), the description covers gating, scoping, constraints, paper trading specifics, cost details, and idempotency behavior. An output schema exists, so return values need not be explained. The description is complete and thoroughly sets expectations.

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

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

Schema coverage is 100% with comprehensive parameter descriptions. The description adds overall context (e.g., side behavior, idempotencyKey requirement) but does not significantly enhance individual parameter meanings beyond what the schema already provides. 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 'Open a mock prediction-market position (binary outcomes only)', which is a specific verb+resource. It distinguishes itself from sibling tools like pm_quote (quoting) and spot/futures orders by focusing on binary PM positions.

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

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

The description provides explicit usage guidance: requires trade:pm scope, idempotencyKey required, stake>=10, side defaults to yes, and instructs to quote first and confirm with the user. It also notes paper trading only. However, it does not explicitly state when NOT to use or list alternative tools for other order types like spot or futures.

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 a write operation (readOnlyHint=false) but no destructiveness. The description adds extensive behavioral details: idempotency via key, required scope (trade:spot), paper execution costs, and execution policy version. 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 comprehensive but verbose (multiple sentences on execution cost details). The first sentence is concise and front-loaded, but the overall length could be reduced by half 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?

The description covers purpose, parameter nuances, idempotency, scope, paper-only nature, and execution model. Given 8 parameters, nested objects, and output schema existence, the description is thorough and leaves no major gaps for an AI agent to select or 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%, but the description adds critical context: coinId is UCID not ticker, limitPrice required for limit/stop, stopPrice only for stop, idempotencyKey semantics (replay original result). This goes well 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 title and description clearly state the tool places a paper spot order. It distinguishes from siblings like spot_quote (quoting) and cancel_spot_order (cancellation) by specifying it is for executing orders. The description also clarifies that coinId is a UCID, not a ticker, reinforcing purpose.

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

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

The description provides explicit usage guidance: requires user confirmation, paper trading only, and idempotency key behavior. It lacks explicit alternatives (e.g., use open_futures_position for futures), but the tool name and sibling set imply context. The coverage is strong but not perfect.

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 declare readOnlyHint true and destructiveHint false; description adds detail on paper trading, simulated execution costs, and that no state is mutated. This provides useful clarity 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 front-loads purpose but is lengthy and includes some extraneous detail on paper execution policy. Still well-structured and informative.

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

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

Given output schema exists, description covers all necessary aspects: read-only, parameters, paper trading, behavioral notes on openBlocked, and execution cost model. An agent can correctly invoke the 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%, but description adds meaning: stakeMusd must be >0 and min 10, side details, outcomeExternalMarketId case-sensitive. AgentTrace description duplicates schema but offers context.

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

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

The description clearly states it is a read-only quote for binary outcomes, listing key return fields. It distinguishes from sibling quote tools like spot_quote and futures_quote by specifying prediction market context and read-only nature.

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 guidance on side parameter (no side for NO, omitted for YES), stakeMusd minimum (10), and explains openBlocked as a preview of rejection. Lacks explicit when-not-to-use or alternatives, but context implies use before opening a position.

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, the description reveals that this WRITES an evidence record but never moves funds, requires only read scope, does not independently verify the evaluation, honors the first stored record on replay, and has a fallback decisionId path that can create separate records. It also refines the coarse idempotentHint=false by conditioning idempotency on reuse of decisionId, which is not a contradiction.

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

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

The description is dense but every sentence earns its place, covering side effects, authorization, verification limits, idempotency, response fields, error interpretation, and routing to the sibling tool. The safety-relevant non-movement of funds is stated upfront.

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 complex tool with 12 parameters, nested objects, and an output schema, the description includes all key operational context: write behavior, auth scope, idempotency rules, response shape, retry semantics, and how to interpret network errors. Nothing an agent needs to correctly use or safely call this tool is missing.

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

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

Although the schema already documents all parameters, the description adds decision-relevant semantics: forecastProbability is required for forecast_only, reusing decisionId guarantees first-record-wins, omitting both decisionId and agentTrace.decisionId creates separate records, and cohort.universeSize records decision breadth. These are exactly the details an agent needs to call the tool correctly.

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

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

The description names a specific action ('Save a durable SELF-REPORT'), a precise resource ('prediction-market evaluation for a decision that did not open a position'), and explicitly contrasts with open_pm_position. It makes clear this is a recording tool, not a trading tool, so an agent can distinguish it from siblings without inspecting schemas.

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

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

It provides concrete when-to-use guidance: report once per decision cycle, choose among abstained/forecast_only/quote_expired, supply a decisionId for retries, and use open_pm_position when a paper trade is intended. The description even tells the agent what to check (ok/httpStatus) before treating delivery as confirmed.

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 non-destructive, but the description adds rich behavioral context: paper execution policy, fees (taker, spread, slippage), calibration details, and the rehearsal nature of results, far exceeding what annotations alone 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 core purpose, but includes a lengthy list of execution details that, while valuable, could be streamlined or moved to a separate documentation section. Still, each sentence adds necessary context for correct usage.

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 (output schema exists, parameters well-documented), the description covers purpose, usage, behavioral nuances, and execution semantics comprehensively, leaving no critical gaps 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?

Both parameters ('q' and 'agentTrace') are fully described in the input schema (100% coverage). The description adds no additional semantics beyond restating the 'q' parameter's purpose, 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?

The description clearly states it resolves human-readable symbols/slugs/names to CoinRithm coinIds plus alternatives, using a specific verb 'Resolve' and resource 'symbol', distinguishing it from sibling tools that require coinIds.

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, warns against guessing UCIDs, and mentions paper trading constraints, providing clear when-to-use and when-not-to-use guidance.

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

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

The description discloses detailed behavioral traits: triggers fired by per-minute worker, liquidation precedence, full position closure on fire, fill discovery via my_trades, execution costs, and that the executionModel is a rehearsal cost not a guarantee. Annotations already indicate idempotency and non-destructive, and description aligns 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 front-loaded with the core operation, then provides necessary details in a structured manner. While it is lengthy, every sentence adds essential information about behavior, constraints, and execution. It could be slightly trimmed, but it earns its length.

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 (side-awareness, paper trading, execution model), the description covers almost all aspects: scope, constraints, fill discovery, cost implications, and that output is a rehearsal. It assumes some background knowledge (e.g., mark), but is complete for the tool's purpose.

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

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

With 100% schema description coverage, the baseline is 3. The description adds valuable context beyond the schema: side-aware ordering for SL/TP, the meaning of null/omitted values, and the requirement that positionId refers to an open position. This enriches the agent's understanding.

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 starts with a specific verb and resource: 'Set or clear resting stop-loss / take-profit triggers on an OPEN mock futures position.' It clearly distinguishes from siblings like close_futures_position and open_futures_position by focusing on SL/TP adjustment 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 explains the side-aware ordering (long needs liq < SL < mark < TP, short inverted) and the effect of null/omitted fields. It also states the required scope ('trade:futures') and that it's for paper trading only. However, it does not explicitly state when not to use this tool, though sibling context implies 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?

Matches annotations (readOnlyHint=true) and adds details: 'Never mutates state', paper trading specifics, execution cost policy, and that price age is informational. 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?

First sentence provides clear core purpose. Subsequent sentences add necessary context but are dense. Could be slightly more concise, but structure is logical 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?

Covers read-only nature, return value fields, paper trading context, UCID clarification, and ordering guidance. Output schema exists, so return format is not required. Complete for the tool's complexity.

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

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

With 100% schema coverage, baseline is 3. Description adds crucial info for coinId ('UCID, not a ticker — use resolve_symbol first') and clarifies side semantics beyond the enum. Other params are adequately described in 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?

Description clearly states 'Read-only spot MARKET quote' and lists specific outputs (execution price, cost, balance, eligibility). Distinguishes from siblings like futures_quote and pm_quote by specifying 'spot' and 'market'.

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 advises to 'quote before place_spot_order instead of buying/selling blind' and to resolve symbols before using coinId. Does not directly compare to siblings but implies when to use by naming the tool it precedes.

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 provide readOnlyHint=true and destructiveHint=false, but the description adds substantial context: specific return fields (userId, keyId, scopes, usage, agentName/agentModel), the self-reported and unverified nature of agentModel, 401 on invalid keys, and the side-effect of updating usage/last-used metadata with possible private logging. This goes far beyond the structured annotation hints.

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

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

The purpose is front-loaded, and every sentence carries useful information without jargon or filler. It is fairly dense—multiple clauses compressed with semicolons—but remains readable and focused. A slight restructuring into bullets could improve skimmability, but it's well within acceptable bounds.

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

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

For a single-optional-parameter tool with an output schema and rich annotations, the description covers all the necessary context: what it returns, authentication requirements, error behavior, side-effects, and parameter omission guidance. No critical information is missing for an agent to invoke it correctly.

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

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

Schema coverage is 100% and the agentTrace parameter is already described as 'Optional private trace metadata stored in the caller's ledger'. The description adds only 'Omit agentTrace for a simple check', which reinforces optionality but doesn't provide substantial new 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 opens with a specific verb-resource pair: 'Check the caller's CoinRithm API-key identity and permissions'. This states exactly what the tool does and its purpose ('before using account or trading tools'), clearly distinguishing it from all sibling tools, none of which are identity checks.

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 to use this 'before using account or trading tools', providing a clear trigger and context. It also clarifies that no additional scope is required and that any valid key works. However, it doesn't explicitly name alternative tools or exclusions (though no sibling appears to be a substitute), so it stops just short of a 5.

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