CoinRithm Agent Trading

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

Annotations already indicate destructiveHint=true and readOnlyHint=false. The description adds useful behavioral context: 'releases frozen funds', paper trading specifics, and execution policy. No contradiction with annotations. The added detail on execution costs is beyond annotations but relevant.

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

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

The description is overly verbose with extensive paper trading policy details that could be condensed or moved to documentation. The core cancellation action is front-loaded, but the bulk of text is less relevant for tool invocation.

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 existence of an output schema, the description adequately covers purpose, required scope, paper trading limitation, and key behavioral trait (fund release). It does not explain return values, but output schema handles that. Overall sufficient.

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

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

Schema coverage is 100% with parameter descriptions. The description does not add new meaning beyond the schema's 'Open order id.' The parameter 'agentTrace' is documented in schema but not mentioned in description. No added value.

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 'Cancel an open spot order by id' and mentions releasing frozen funds. It effectively communicates the action and resource. However, it does not explicitly distinguish from sibling tools like place_spot_order or list_open_orders, though cancellation is distinct.

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

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

The description mentions the required scope 'trade:spot' and 'Paper trading only', providing some usage context. It does not specify when not to use this tool or suggest alternatives, 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?

Discloses paper trading, virtual funds, execution policies, fees, and that it's not financial advice. Adds context beyond annotations (destructiveHint, idempotentHint). 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?

Informative but verbose. Could be trimmed while preserving key behavioral and guideline points.

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

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

Comprehensive given complexity: covers execution model, fees, paper trading constraints, and trust boundaries. Output schema exists and is not repeated.

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 100% so baseline 3. Description adds value by explaining fraction meaning and idempotencyKey purpose.

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?

Clear verb+resource: 'close or partially reduce a mock futures position'. Distinguishes from siblings like open_futures_position and set_futures_sl_tp.

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?

Describes when to use (to close/reduce), how fraction works, mandatory idempotencyKey, and paper trading context. Could be more explicit about when not to use.

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

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

Annotations show readOnlyHint=true; description adds detail on return fields, paper trading rules, fees, execution model, and that results are not fill guarantees, enriching 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?

Front-loaded with purpose, then structured return fields, usage order, and trading details; slightly long but each sentence adds value.

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

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

Covers discovery usage, prerequisites, return fields, paper trading mechanics, fees, and execution policy; output schema exists, but description adds essential behavioral context.

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

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

Schema coverage is 100%, so baseline 3; description does not add extra parameter-level meaning beyond schema, but overall context supports usage.

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

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

States 'Find active-open, quote-ready-first prediction markets on the mock-PM sources (Kalshi + Polymarket)' with specific verb and resource, and distinguishes from siblings like pm_quote and open_pm_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?

Explicitly states 'This is discovery only — call pm_quote... before open_pm_position' and that it's paper trading only, not financial advice, providing clear when-to-use and exclusions.

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

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

Annotations declare readOnlyHint, openWorldHint, destructiveHint; the description adds significant behavioral context: export size limit (1,000 rows), privacy per API key, paper trading with virtual funds, execution cost details, and rehearsal cost vs. exchange fill guarantee. This far exceeds what annotations provide, with 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 relatively long but each sentence adds essential context (limit, privacy, paper trading, execution model). It is front-loaded with the core purpose and limit, then elaborates on filters and behavioral nuances. No redundant or filler content.

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

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

Given the tool's complexity (8 parameters, nested object, output schema present), the description is fully adequate. It covers read-only behavior, constraints, privacy, paper trading nature, execution cost details, and output format. With an output schema available, return values are not needed. The description is comprehensive for an agent to decide when and how to use this tool.

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

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

Schema description coverage is 100% so baseline is 3. The description adds value by suggesting using filters for runId or decisionId for reproducible evaluation, which provides usage context beyond the schema's parameter descriptions. It does not repeat schema details but enhances 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 clearly states the verb 'Export', the resource 'private ledger rows', and a specific limit 'up to 1,000'. It distinguishes from siblings like export_run_evidence by specifying 'for the calling API key' and focuses on ledger rows rather than evidence. The purpose is concrete and unambiguous.

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

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

The description advises using filters for reproducible evaluation with runId or decisionId. It also notes that data is private, paper trading only, and not financial advice. However, it does not explicitly contrast with sibling tools like get_agent_ledger or export_run_evidence, leaving some context for alternative usage implicit.

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

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

Beyond the readOnlyHint annotation, the description details the execution assumptions, fee structures, and the rehearsal nature of the data (e.g., 'not an exchange fill guarantee'). This provides rich behavioral context that annotations alone do not convey.

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

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

The description is front-loaded with the core action, but includes a lengthy paragraph on paper trading fees and policies that could be condensed. While relevant, it reduces conciseness for an agent that needs quick understanding.

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 suitably explains the bundle contents (ledger rows, assumptions, etc.) and the paper trading context. It does not cover error cases or authentication, but for a read-only tool with annotations, it is sufficiently complete.

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

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

Schema description coverage is 100%, so baseline is 3. The description ties the top-level runId to 'agentTrace.runId' which could cause slight ambiguity but does not add significant new meaning beyond the schema descriptions.

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

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

The description clearly states 'Export one private reproducibility bundle for a specific agentTrace.runId' and enumerates the bundle contents. It distinguishes itself from the sibling 'export_agent_ledger' by focusing on a single run's evidence, not the entire 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 mentions 'No public Arena user can see this data' and 'Paper trading only', providing context for when the tool should be used. However, it does not explicitly compare to the sibling 'export_agent_ledger' or state when not to use it, missing an opportunity to guide agent selection.

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

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

Annotations already declare readOnlyHint=true and destructiveHint=false. The description adds significant context: paper trading, virtual funds, execution policy, fees, and that the quote is a rehearsal not a 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 but becomes verbose with execution policy details. Every sentence adds value, but it could be more concise. Overall well-structured for the complexity.

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

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

Given the tool's complexity (5 params, nested objects, output schema), the description covers purpose, constraints, behavioral traits, and execution context thoroughly. Output schema exists so return values are covered. Complete for informed 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 baseline 3. The description repeats the leverage range and margin minimum but adds no new semantics beyond the schema. It does not elaborate on coinId, side, or agentTrace beyond what the schema provides.

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

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

The description clearly states it is a read-only futures quote and lists the specific fields returned (entry price, notional, size, liquidation price, eligibility). It distinguishes from siblings like open_futures_position which would mutate 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 explicitly says to 'always quote before opening' and provides constraints (leverage 1-20, marginMusd >= 10). It mentions paper trading context but lacks explicit exclusions or comparison to other quote tools.

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

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

The description discloses behavioral traits beyond the annotations: it specifies that only the calling key's rows are returned, limits to paper trading with virtual funds, details the execution cost model (fees, slippage), and mentions that fills are under versioned policies. This provides extensive context that the readOnlyHint and openWorldHint annotations alone do not convey.

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

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

The description is front-loaded with the main purpose but becomes lengthy with a detailed explanation of paper trading costs and disclaimers. While informative, it could be more concise to serve an AI agent efficiently.

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

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

Given the tool's complexity (10 parameters, nested objects, output schema), the description covers what the ledger includes, its paper-trading context, and behavioral constraints. However, it does not mention pagination defaults or result ordering, which are partially covered by the schema. Still, it is largely complete.

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

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

Schema coverage is 100%, so the schema already documents all parameters. The description does not add parameter-level details beyond the schema; it focuses on the overall ledger contents. Thus it adds minimal value for parameter semantics, meeting the baseline of 3.

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

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

The description clearly states the tool lists the API key's private execution ledger with specific data types (reads, quotes, writes, etc.) and notes it only returns rows for the calling key. This distinguishes it from siblings like export_agent_ledger by explicitly scoping to the caller's 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 recommends using this tool to audit a reproducible paper-trading run, providing a clear use case. It does not, however, explicitly state when not to use it or directly compare to alternatives, but the context implies the distinction.

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

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

Annotations already declare readOnlyHint, openWorldHint, destructiveHint=false. The description adds extensive detail: public data, paper trading only, not financial advice, explanation of execution costs (paper_execution_v1 policy, fees, slippage), and that results contain an executionModel. This goes well beyond the annotations.

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

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

The description is relatively long but front-loads the core purpose and then provides detailed behavioral information. Every sentence adds useful information (disclaimers, execution details). It could be slightly more concise, but it is well-structured.

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

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

Given the tool has one parameter and is read-only, the description adequately covers what the tool returns (rank, PnL, trade counts, win rate) and the execution model. An output schema exists, which likely details the return structure, so the description complements it well.

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 a description for the handle parameter. The description adds value by specifying that the handle comes from get_arena_leaderboard and providing an example, thus giving context beyond the schema.

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

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

The description clearly states it fetches a single agent's public Arena profile by handle, specifying the returned data: rank, PnL, trade counts, win rate. It distinguishes from the sibling tool get_arena_leaderboard by focusing on one agent and using the handle field from that leaderboard.

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

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

The description implies usage context by stating 'One agent's public Arena profile' and 'Public data only — no account or key identity.' It also clarifies it's paper trading only, but doesn't explicitly state when to use this tool versus alternatives like get_arena_leaderboard or get_performance. The context is clear but lacks explicit exclusions.

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

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

Annotations already indicate readOnlyHint and destructiveHint, but the description goes far beyond by disclosing paper trading, virtual funds, execution costs, fees, and the fact that results are not financial advice. No contradictions with annotations.

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

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

The description is very long and includes many details. While informative, it could be more concise. However, it is well-structured with front-loaded core purpose and follows with supplementary details.

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

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

Given the complexity of the tool (ranking, windows, paper trading details), the description covers all necessary aspects: minimum trades, sparkline, badges, execution model, etc. Output schema exists, so return values are not required in the description.

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 valuable context to the window parameter (re-ranking behavior for 7d/30d) and mentions default pageSize, providing 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 that the tool retrieves the public Agent Arena leaderboard ranked by realized PnL with per-venue breakdowns and win rate. It distinguishes from siblings like get_performance and get_arena_agent, 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?

Explicitly says when to use the tool ('see the field and where you stand') and provides alternatives to pair with ('get_performance and get_arena_agent'). It also explains the window parameter's effect on ranking, giving 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?

Beyond readOnlyHint and destructiveHint annotations, the description details paper trading behavior, candle ordering, units, and execution cost folding, providing comprehensive behavioral 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 front-loaded with core purpose and range details, but includes extensive paper execution details that, while relevant, could be condensed or separated.

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, full schema coverage, and presence of output schema, the description provides sufficient context for correct invocation, including output format and paper trading constraints.

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

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

The description adds meaning to the range parameter with exact mappings and explains coinId's prerequisite, which goes beyond the schema's enum 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 explicitly states it provides OHLCV candles for indicator/momentum strategies, differentiates from other tools by specifying paper trading only and prerequisite resolve_symbol.

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

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

The description advises to use resolve_symbol first and clarifies paper trading context, but does not explicitly list when not to use or compare with sibling data tools.

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

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

Adds rich detail beyond annotations: explains execution model, fees, slippage, and that it's a rehearsal cost. No contradictions with readOnlyHint or destructiveHint.

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

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

Front-loaded with purpose and granularity definitions. Some details (execution policy) are lengthy but relevant. 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?

Covers all aspects: purpose, parameters, return values (date/usdValue), limitations (paper only), and execution cost behavior. Output schema exists but description adds clarity.

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?

Description elaborates on granularity and days meaning, adding value over the schema. The agentTrace parameter is mentioned but minimally expanded beyond schema.

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

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

The description clearly states it returns wallet equity time series for the paper account, with specific granularities. It is unambiguous and distinct from siblings.

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

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

Provides explicit use cases for daily vs realized granularity and notes paper-only context. Lacks explicit exclusion of alternatives but guides when to use each mode.

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

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

Annotations indicate readOnlyHint=true and destructiveHint=false. The description adds significant behavioral context: paper trading only, virtual funds, execution cost details, and 'Facts only — no generated thesis.' This goes beyond annotations to clarify limitations and safety.

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

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

The description is somewhat verbose, especially with execution model details that may be tangential for a read-only data tool. While structured (purpose first, then details), it could be shortened 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 presence of an output schema (mentioned in context signals), the description need not explain return format. It covers prerequisites, input handling, output contents, limitations, and behavioral notes thoroughly. The tool is well-situated within its use case.

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 meaning by explaining the coinId parameter's purpose ('Use resolve_symbol to find it') and detailing the output contents (price, changes, markets, etc.). For agentTrace, it clarifies it is 'optional private trace metadata stored in the caller's ledger.' This significantly aids 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 clearly states the tool provides 'Compact factual context for ONE coin to form a thesis' and lists specific data points (price, changes, sentiment, markets). The verb 'get' and resource 'market context' are specific. It is distinct from siblings like get_candles and get_performance, which focus on narrower data.

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

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

It explicitly states 'Call resolve_symbol first to get the coinId' as a prerequisite. The description notes it is for paper trading and not financial advice, setting usage expectations. However, it does not contrast with alternative tools or give explicit when-not-to-use guidance.

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

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

Annotations already indicate read-only and non-destructive. The description adds substantial context: paper trading only, virtual funds, execution cost modeling, and fee structures. No contradiction with annotations.

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

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

The description is lengthy with detailed execution model information that could be considered extraneous for a log retrieval tool. While the main purpose is front-loaded, conciseness suffers from excessive detail.

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

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

Given the tool's complexity (4 optional params, output schema exists, annotations present), the description covers purpose, usage, behavior, and parameter semantics adequately. The presence of an output schema mitigates the need for return value documentation.

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

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

Schema covers all parameters with descriptions (100%). The description adds value by explaining the updatedSince cursor pattern and the private nature of agentTrace, enhancing understanding beyond schema.

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

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

The description clearly states the tool retrieves a unified realized-PnL log of CLOSED trades across venues, most-recent first, serving as the agent's memory. It explicitly distinguishes from siblings by specifying 'closed trades' and 'venues', differentiating from get_performance or get_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 advises to 'use it to review performance before deciding the next move' and explains the polling pattern with updatedSince. However, it does not explicitly exclude alternative tools or state when not to use it, leaving some room for improvement.

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 valuable behavioral context: paper trading only, virtual funds, closed trades only, win rate null until decided trades, and details on execution costs (taker fees, slippage). 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 fairly long but front-loads key output details, then adds constraints and caveats. Every sentence adds value, but it could be slightly more concise. Good structure overall.

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 output schema exists, so return values are likely documented. The description covers the scope (paper, closed trades), key metrics, and important caveats (execution cost model, not financial advice). It is sufficiently complete for a performance 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 has one optional parameter (agentTrace) with 100% coverage in schema descriptions. The tool description does not add additional meaning beyond the schema, so a baseline score of 3 is appropriate.

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

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

The description clearly states the tool returns the calling key's own realized performance, including total and per-venue realized PnL, trade counts, win/loss/neutral counts, and win rate. It specifies 'Closed trades only' and 'Paper trading only', distinguishing it from sibling tools like get_portfolio (positions) or get_my_trades (all 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 indicates it is for the authenticated user's own performance on paper trading, but does not explicitly state when to use or when not to use compared to alternatives. However, it implicitly differentiates from similar tools by focusing on realized performance of closed trades.

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

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

The description provides extensive behavioral detail beyond annotations: it states the data is PII-free, explains paper execution policy (versioned paper_execution_v1), cost folding into PnL, fee structures for spot/futures/PM, and that fills are rehearsals. This is comprehensive and consistent with readOnlyHint and destructiveHint 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 thorough but verbose, including lengthy execution model details that could be partially moved to separate documentation. While well-structured, it could be more concise for quick agent scanning.

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 optional params, nested object, output schema present, annotations provide readOnly/non-destructive info), the description covers return fields, limitations (paper only), execution context, and cost implications, making it fully informative for an AI 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?

Schema coverage is 100% with detailed descriptions for each parameter (fiat, locale, agentTrace). The description adds no additional parameter-level meaning beyond what the schema already provides, so the baseline score of 3 is appropriate.

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

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

The description clearly states the tool retrieves a 'lean, PII-free paper account summary' and enumerates specific return fields (walletId, equity, PnL, orders, progression). This distinguishes it from sibling tools like get_wallet or get_positions by specifying exact content and domain (paper trading).

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

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

The description explicitly limits usage to 'Paper trading only' and disclaims 'Not financial advice,' providing clear context. It also explains execution cost mechanics but does not contrast with sibling tools or specify when to avoid it.

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

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

Beyond annotations (readOnlyHint=true, openWorldHint=true), the description details mock data behavior, execution costs, and the asOf polling mechanism for tracking changes. Discloses paper trading nature and that positions are virtual.

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 detailed but front-loaded with core purpose. Each sentence adds necessary context for paper trading, venues, and polling. Slightly verbose but well-organized.

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 venue behaviors, polling, paper trading limitations, and execution costs. With an output schema present, it doesn't need to detail return structure. Adequate for the complexity of position listing across two mock venues.

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 has 100% coverage; description adds value by explaining venue-specific output differences and the asOf/updatedSince polling pattern. AgentTrace is not further clarified but is well-documented 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?

The description clearly states it lists open and historical positions per venue, specifying the return differences for 'futures' (unrealized PnL, liquidation distance) and 'pm' (unrealized mark). It distinguishes from sibling tools by focusing on positions rather than trades or portfolio.

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

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

Provides explicit guidance on polling with asOf cursor and paper trading context. While it doesn't list when not to use, the purpose is clear enough to differentiate from siblings like get_my_trades or get_portfolio.

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 significant behavioral context: the paper trading environment, virtual funds, execution costs, and fee structures. This goes beyond the annotations, providing transparency about the simulated nature and associated costs.

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

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

The description is front-loaded with the core purpose but includes lengthy details about paper execution policies, fees, and slippage that are beyond the scope of a simple balance retrieval. While structured, it is verbose and could be more concise.

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

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

Given the tool's simplicity (retrieving wallet balances) and the richness of annotations and output schema, the description provides complete context: what balances are returned (available USDT, three frozen partitions), the paper trading environment, and optional coin inclusion. It adequately covers the tool's purpose and behavior.

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 adds 'Optionally include one coin asset,' which echoes the schema's description of the coinId parameter. It does not provide additional meaning 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 begins with 'Get raw cash balances: USDT available plus the three frozen partitions...' which clearly states the tool's purpose and specific resource. It also mentions optional coin asset inclusion, distinguishing it from sibling tools like 'get_portfolio' that likely provide a broader 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?

The description states 'Paper trading only — virtual funds (50,000 mUSD).' which gives clear context but does not explicitly mention when to use this tool over alternatives like 'get_portfolio' or when not to use it. The exclusion is implied but not articulated.

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 context beyond that, such as paper trading only, virtual funds, and details about execution policies and fees. This provides valuable behavioral transparency, though some technical details (e.g., paper_execution_v1 policy) may be excessive.

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

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

The description is front-loaded with the main purpose but becomes lengthy with detailed execution policies and disclaimers. While these details may be important, they reduce conciseness. Not every sentence earns its place; the section on execution costs could be abbreviated.

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 main functionality and parameter usage, and since an output schema exists, it does not need to detail return values. However, given the complexity of the tool (4 parameters, nested objects, delta polling), the description could more explicitly state the output structure or confirm that asOf is part of the response. The extra execution details do not compensate for completeness 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?

With 100% schema description coverage, the schema already documents all parameters. The description adds semantic value by explaining the coinId filter behavior, the updatedSince cursor usage with asOf, and the purpose of agentTrace as 'optional private trace metadata stored in the caller's ledger.' This enhances understanding beyond the schema.

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

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

The description clearly states it lists open resting spot orders, with the ability to filter by coinId or get all. This distinguishes it from sibling tools like cancel_spot_order, place_spot_order, etc., which perform different operations. The verb 'list' and resource 'open orders' are specific and unambiguous.

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

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

The description provides clear guidance on when to omit or include coinId for filtering, and explains delta polling with asOf/updatedSince. However, it does not explicitly state when not to use this tool compared to alternatives like get_my_trades or get_positions, leaving some ambiguity for the agent.

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

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

Annotations are minimal (readOnlyHint=false, openWorldHint=true, etc.). The description adds extensive behavioral details: idempotencyKey uniqueness, leverage range, margin minimum, SL/TP corridor constraints, paper execution policy, execution cost disclosure, and status as mock trading. 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 thorough but slightly verbose, repeating 'paper trading' twice. However, it is well-structured with front-loaded requirements and subsequent optional details, earning 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 8 parameters, 5 required, nested objects, and an output schema, the description covers prerequisites, constraints, behavior, disclaimers, and execution model comprehensively. No major aspect is neglected.

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 description adds significant extra meaning: idempotencyKey is required and unique, leverage 1-20, margin >=10, SL/TP corridor description, and best practice advice. This enhances understanding beyond the schema.

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

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

The description clearly states the tool opens or adds to a mock futures position, with a specific verb and resource. It distinguishes from siblings like close_futures_position and set_futures_sl_tp by focusing solely on 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 explicit context: requires trade:futures scope, quote first and confirm with user, paper trading only. It recommends setting stopLoss/takeProfit but does not directly contrast with alternative tools for closing or modifying positions, which is a minor gap.

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 substantial behavioral context beyond annotations: explains paper trading, server-flag gating, idempotency replay, execution cost disclosure, and fill mechanics for NO side. This greatly aids agent decision-making.

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 detailed but lengthy, with a few paragraphs of execution model detail that could be trimmed or moved to a reference. However, the structure is logical: purpose, requirements, key parameters, and then extra 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 (9 parameters, nested objects, output schema), the description covers all essential aspects: operation, constraints, execution behavior, confirmation requirement, and parameter semantics. The presence of an output schema complements the description well.

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 valuable semantics for 'side', 'stakeMusd', 'idempotencyKey', and 'forecastProbability'. It explains the NO fill formula and the purpose of the forecast field for calibration.

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

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

The description clearly specifies the action 'Open a mock prediction-market position' with a specific resource and scope. It distinguishes from siblings like spot or futures tools by focusing on binary prediction markets.

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?

Includes prerequisites (scope, idempotencyKey, stake minimum), states the need to quote first and confirm with user, and notes paper trading. Could be more explicit about when not to use (e.g., for non-binary markets or real funds).

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 claims idempotencyKey ensures no double-execution, contradicting annotation idempotentHint=false. Other details like execution costs and paper policy are transparent, but the contradiction is critical.

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 long but front-loaded with purpose. Could be more concise, but information is well-structured with clear separation of concepts.

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 paper trading nature, execution costs, scope, and confirmation. Output schema exists, so missing output details are acceptable. Adequate for a complex multi-parameter tool.

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

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

Schema coverage is 100%, and description adds context beyond schema: clarifies coin UCID, price requirements per order type, idempotency key necessity, and side semantics.

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

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

Clearly states 'Place a paper spot order', distinguishes from siblings by specifying paper trading only, and explains key details like coin UCID and order types.

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 states required scope (trade:spot), instructs to confirm with user, explains idempotency key usage for retries, and sets boundaries (paper trading only, not financial advice).

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, destructiveHint=false, openWorldHint=true. The description reinforces this by stating 'Free public detail' and 'No API key required'. It adds behavioral context about the output contents, but 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 detailed but well-structured with enumerated items. It front-loads the core purpose and key features. Slightly verbose but every sentence adds value.

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

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

Given the tool's complexity (many output fields), the output schema exists, and annotations cover behavior. The description provides a comprehensive overview of returned data, including cross-venue matches and reference probability, which is not in schema. 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 description coverage is 100% for all 3 parameters. Description does not add extra meaning beyond the schema, but references 'venue + slug' contextually. Baseline 3 is appropriate.

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

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

The description clearly states it retrieves full detail for one prediction-market event by venue and slug. It lists specific data included (outcomes, price snapshots, etc.) and explicitly distinguishes from sibling tool pm_quote for tradability.

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: 'cross-venue research view' vs 'for tradability use pm_quote'. Also mentions no API key required, implying no auth needed. Does not explicitly list all alternatives or when not to use, but the guidance is sufficient.

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

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

Annotations already declare readOnlyHint=true and openWorldHint=true, so the description adds context about being 'Free public search' and 'No API key required.' It also explains output fields like referenceProbability, quality, crossPlatform, adding value beyond annotations.

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

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

The description is a single paragraph that is front-loaded with the main purpose but becomes lengthy with detailed field explanations. It could be more concise while retaining 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 7 parameters and an output schema, the description thoroughly explains output fields such as referenceProbability, quality, and crossPlatform. It provides enough context for a search tool without needing to replicate 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?

Schema description coverage is 100%, so baseline is 3. The description does not add meaning beyond the schema for parameters; it focuses on output fields. No parameter-specific guidance is given beyond what's 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?

Clearly states 'Free public search over prediction-market events across ALL 11 venues' with specific verb 'search' and resource 'prediction-market events'. Explicitly distinguishes from sibling 'discover_pm_markets' which is scoped to paper-tradeable venues.

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 states when to use this tool: 'Research/data only: to trade, use discover_pm_markets + pm_quote instead.' Also notes broader scope than discover_pm_markets, providing clear guidance on alternatives.

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

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

Annotations declare readOnlyHint=true, destructiveHint=false, and openWorldHint=true. The description adds significant behavioral context: freshness is source-aware with independent ingestion per venue, monetary totals cover only real-money venues, volume is on each venue's own basis, and values are self-computed aggregates requiring citation. This goes well beyond annotation defaults.

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 ('Free public cross-venue prediction-market statistics:') and lists key metrics concisely. Subsequent sentences add necessary caveats about freshness, venue coverage, and methodology without redundancy. Every sentence provides distinct value, and the overall length is appropriate for the information conveyed.

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

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

Given the tool's simplicity (1 optional parameter, output schema exists), the description fully covers what data is returned, the list of venues, freshness behavior, methodology citation, and authentication requirements. It appropriately directs to a separate endpoint for detailed health data. No gaps are present for an agent to understand usage and 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 description coverage is 100% for the single optional parameter 'fiat'. The schema already provides a clear description: 'Fiat currency code for monetary figures (default usd).' The tool description does not add any additional meaning or usage details for this parameter, so the baseline score of 3 is appropriate.

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

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

Clearly states it provides 'cross-venue prediction-market statistics' with specific metrics: total/open/closed market counts, total volume, 24h volume, liquidity aggregated across 11 venues, plus market highlights. Distinguishes from sibling tools like 'pm_data_event' (specific event data) and 'pm_data_whales' (whale activity) through the term 'overview' and aggregate scope.

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

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

Provides context that the tool is 'Free public' and 'No API key required', and notes that per-venue health details are available at a separate endpoint. Does not explicitly state when to use this tool over siblings, but the listing of specific aggregated data implies it is for a high-level summary. Lacks explicit alternatives or exclusion scenarios.

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

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

Beyond annotations (readOnlyHint=true, destructiveHint=false), the description adds rich behavioral context: data is 'newest first (top 50)', 'Polymarket rows are wallet-attributed; Kalshi rows are anonymized', and includes a disclaimer ('A large print is information, not a recommendation'). No contradiction with annotations.

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

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

The description is two sentences with no wasted words. It front-loads the purpose and then details the fields, venue attribution, and disclaimers. Every sentence adds value.

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

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

Given no parameters and an existing output schema, the description covers all necessary aspects: what data is returned, order (newest first), limit (top 50), venue attribution, and usage rights (no API key). It is fully complete for this zero-parameter tool.

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

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

No parameters exist, and schema coverage is 100%. The description adds no parameter details, but baseline for 0 parameters is 4. It provides context about the data returned but not about parameters.

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

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

The description clearly states it provides 'the latest large prediction-market trades' with specific data fields (side, outcome, USD value, price, market question, event). The verb 'Get' and resource 'whale trades' are explicit. However, it does not differentiate from sibling tools like pm_data_event or pm_data_overview, which could cause confusion.

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 'Free public tape' and 'No API key required', implying easy access with no authentication. However, it does not provide guidance on when to use this tool versus similar pm_data tools (e.g., pm_data_event, pm_data_overview) or exclude scenarios where a different tool might be more appropriate.

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

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

Annotations already declare readOnlyHint=true and destructiveHint=false. The description adds extensive behavioral details: no mutation, stake > 0, min to open is 10, side behavior, paper fills with execution costs, execution model, and conditions for openBlocked. No contradiction with annotations.

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

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

The description is long but information-dense. The first sentence clearly states the tool's purpose. However, it includes many details that could be streamlined. It earns its place but is not as concise as possible.

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?

Output schema exists, so return values are documented. The description covers key behavioral aspects: paper trading, execution costs, conditions for openBlocked, and eligibility. It provides sufficient context for an agent to understand the tool's full scope.

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%, baseline is 3. The description adds extra meaning: explains side ('NO pays out if it resolves false; fills at 100 minus the outcome probability'), stakeMusd condition, and agentTrace as 'optional private trace metadata stored in the caller's ledger.' This adds value beyond the schema.

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

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

The description clearly states it's a 'Read-only PM quote for a binary outcome' and lists specific output fields (entry probability, share estimate, max payout, etc.). It distinguishes from sibling tools like futures_quote and spot_quote by specifying 'PM' (prediction 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?

The description provides explicit context: it's read-only, paper trading only, not financial advice. It notes conditions for openBlocked to prevent open_pm_position. It explains side parameter usage ('omitted = yes') and minimum stake. However, it does not directly compare to alternatives like futures_quote or spot_quote for when to choose this tool.

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

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

The description thoroughly discloses behavioral traits: it is a self-report, not independently verified, never moves funds, creates a durable hashed artifact. Annotations indicate idempotentHint=true and destructiveHint=false, which the description aligns with. Extra details about paper trading and execution costs add 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 verbose, containing detailed execution cost information that is only tangentially related to the tool's primary purpose. While it front-loads the core purpose, the extraneous details reduce conciseness. More focused wording would improve 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 parameters, nested objects, output schema) and the availability of an output schema, the description covers the essential aspects: purpose, kinds, usage guidelines, and behavioral transparency. However, some execution details could be omitted without sacrificing completeness.

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

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

Schema coverage is 100%, so baseline is 3. The description adds value by explaining the business logic of the 'kind' enum and constraints (e.g., forecastProbability required for forecast_only). It also clarifies the use of 'cohort.universeSize' and the importance of 'decisionId' for idempotency. This surpasses what the schema alone provides.

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

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

The description clearly states the verb 'report' and the resource 'non-opened PM opportunity'. It explains the three specific kinds (abstained, forecast_only, quote_expired) and the rationale for reporting unevaluated opportunities. It distinguishes from trading tools by emphasizing it is evidence, not a trade.

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

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

The description explicitly states when to use the tool: for opportunities evaluated but not opened. It provides guidelines such as 'report ONCE per decision cycle' and 'reuse decisionId for idempotency'. However, it does not explicitly list alternative tools for trades, though the context of sibling tools makes this clear.

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

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

Annotations include readOnlyHint=true and no contradiction. The description adds extra behavioral context beyond annotations: paper trading only, virtual funds, execution costs, and not financial advice. However, some execution details may be tangential to symbol resolution.

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 purpose but becomes verbose with execution cost details that are not directly relevant to symbol resolution. Could be more concise while retaining key information.

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

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

Given the output schema exists, the description need not explain return values but does mention coinId plus alternatives. It also covers why this tool is necessary (symbols not unique) and the paper trading environment, making it 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?

Schema coverage is 100%, so baseline is 3. The description does not add significant meaning beyond the schema's parameter descriptions; it gives examples but schema already describes 'q' and 'agentTrace' adequately.

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 coinIds (UCIDs). It provides examples ('BTC', 'ethereum') and mentions the output includes disambiguating alternatives with CoinGecko tags. It also distinguishes from siblings by stating to use this first for wallet/quote/order tools.

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

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

Explicitly says 'Use this FIRST to get the coinId that the wallet / quote / order tools need — don't guess UCIDs (symbols are not unique).' This gives clear context and alternatives avoidance.

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?

Adds extensive behavioral details beyond annotations: triggers evaluated per-minute by worker, closes full position at mark with realized PnL, liquidation precedence, fill discovery via my_trades, execution cost policy. Annotations only provide idempotentHint, destructiveHint, readOnlyHint.

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

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

Description is somewhat verbose, including financial disclaimer and detailed execution model. Starts with clear main purpose but could be trimmed. Adequate but not maximally 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 complexity (4 params, nested objects, output schema), description is highly complete: covers side-awareness, execution model, fill discovery, scope, paper-only nature. Leaves little ambiguity for 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?

Description adds side-awareness conditions for stopLossPrice and takeProfitPrice beyond schema (long needs liq<SL<mark<TP, short inverted). Also clarifies behavior of null and omitted fields. Schema covers 100% but description enriches 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?

Description uses specific verb 'Set or clear' with explicit resource 'resting stop-loss / take-profit triggers on an OPEN mock futures position'. It clearly distinguishes from siblings like close_futures_position which closes positions, and open_futures_position which opens them.

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?

States when to use: on OPEN mock futures position. Notes scope requirement (trade:futures) and that it's paper-only. Provides context but no explicit exclusions or alternatives mentioned.

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

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

Annotations already declare readOnlyHint=true and destructiveHint=false. The description goes far beyond by detailing that it never mutates state, explains blockReasons, describes paper execution rules (fees, slippage), and states 'Not financial advice'. No contradiction with annotations.

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

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

The description is relatively long but well-structured, front-loading the core purpose and then adding usage warnings and behavioral details. Every sentence adds value, though some details (like execution cost breakdown) could be condensed 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 (4 params, output schema exists, annotations present), the description covers all necessary context: read-only behavior, input format, output contents (blockReasons), paper trading rules, and limitations. It is fully sufficient for an agent to use correctly.

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

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

Schema description coverage is 100%, but the description adds critical context beyond schema: coinId is a UCID (not ticker), quantity > 0, side meanings, and agentTrace purpose. This provides meaningful added value beyond the parameter 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 'Read-only spot MARKET quote' and lists specific outputs (live execution price, estimated cost, available balance, fill eligibility), distinguishing it from write tools like place_spot_order. The purpose is immediately clear and specific.

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

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

The description explicitly advises to 'quote before place_spot_order instead of buying/selling blind', warns that coinId is a UCID not a ticker (use resolve_symbol first), and clarifies paper trading only with virtual funds. This provides explicit when-to-use and 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 already declare readOnlyHint, but the description adds key details about return fields, agentName/agentModel null behavior, and extensive paper trading environment context (virtual funds, fees, slippage, execution policy). No contradiction.

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

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

The description is front-loaded with the main purpose but contains lengthy paper trading details that could be condensed or moved. It is functional but not optimally concise.

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

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

The description covers return values, usage timing, and environment (paper trading). With an output schema present, it is sufficiently complete for a simple, read-only identity tool.

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

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

Schema description coverage is 100%, so the parameter (agentTrace) is fully documented in the schema. The tool description adds no extra parameter information, baseline score of 3 is appropriate.

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

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

The description clearly states the tool returns identity details (userId, keyId, scopes, agentName, agentModel) and distinguishes it from sibling tools, which are all trading or market data related.

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 'Use this first to confirm what the key is allowed to do,' providing clear context for when to use it. Does not explicitly state when not to use, but the guidance is strong.

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