CoinRithm Agent Trading

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

The description goes beyond annotations by detailing the paper trading execution policy (e.g., 'Paper fills run under the versioned paper_execution_v1 policy') and costs involved. Annotations indicate destructiveHint=true and readOnlyHint=false, which align. 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 becomes verbose with detailed execution policy (e.g., 'spot/futures pay a taker fee...'). Could be trimmed without losing essential information for the 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 simplicity (2 params, 1 required) and presence of output schema, the description provides sufficient context: purpose, prerequisites, and paper trading behavior. It does not explain the return value, but the output schema handles that.

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

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

Schema coverage is 100% and the description does not add meaning beyond the schema. The description only mentions 'by id' but does not elaborate on the 'orderId' or 'agentTrace' parameters. 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 'Cancel an open spot order by id (releases frozen funds)', specifying the verb (cancel), resource (open spot order), and scope (releases frozen funds). It distinguishes from siblings like 'place_spot_order' or 'list_open_orders' by explicitly naming the cancel action.

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

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

It mentions the required scope ('Requires the trade:spot scope') and notes that it's 'Paper trading only — virtual funds (50,000 mUSD)'. This provides clear context but does not explicitly state when not to use it or mention alternatives like 'cancel_futures_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?

Annotations already mark as destructive and idempotent. Description adds significant context: paper trading only, virtual funds, execution cost policy, and that it's not a guarantee of exchange fill. Completely consistent 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?

Front-loaded with main action and fraction details. Contains necessary caveats and execution policy info, but is slightly verbose. Every sentence adds value, though could be more streamlined.

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 mutation behavior, idempotency, auth scope, simulation details, and execution cost. With output schema present, no need to describe return values. Complete for an agent to use correctly.

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

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

Schema has 100% coverage and describes parameters well. Description adds value by clarifying fraction can be omitted for full close and emphasizing idempotencyKey requirement, but does not add much beyond schema for other 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?

Describes the tool as closing or partially reducing a mock futures position. Clearly specifies the action (close/reduce) and the resource (futures position). Distinguishes from sibling tools like open_futures_position and set_futures_sl_tp by focusing on closing 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?

Explicitly states fraction usage for partial vs full close, that idempotencyKey is required, and requires trade:futures scope. Does not explicitly compare to alternatives, but the context of closing positions vs other actions is clear from sibling names.

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

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

Annotations provide readOnlyHint, openWorldHint, and destructiveHint. The description adds significant context: explains the quality field (decisionEligible, blocked), paper execution fees, slippage, and that executionModel is a rehearsal cost, not a guarantee. 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 comprehensive but slightly long. It front-loads the purpose and provides necessary behavioral details. Every sentence adds value, though it could be structured into paragraphs for easier reading.

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 complexity (6 params, nested objects, output schema), the description covers workflow, output fields, paper trading rules, and execution model. Output schema exists, so return values need not be detailed further, but the description provides sufficient 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 parameters are well-documented in the schema. The description does not add new parameter-specific information beyond the schema, so 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 the tool finds active-open prediction markets, lists returned fields, and distinguishes from siblings like pm_quote and open_pm_position by declaring it's for 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?

Explicitly states when to use (discovery only), when to call pm_quote before opening, and provides context on paper trading, virtual funds, and execution policy. Clearly differentiates from related tools.

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

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

Annotations already declare readOnlyHint and non-destructive. The description adds substantial behavioral context: paper trading, virtual funds, execution model details, and the fact that this is 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 front-loaded with the main action, but becomes verbose with technical execution details that may not be necessary for tool selection. It could be more concise without losing 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 complexity (8 params, nested objects) and presence of output schema, the description covers the core purpose, privacy, and paper trading behavior. It is sufficient for an agent to use the tool correctly, though the execution model details might be extraneous.

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 mentions applying filters for runId and decisionId, but adds minimal meaning beyond what the schema already provides. No additional parameter details.

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 clear verb and resource ('Export private ledger rows as JSON') and includes specifics like up to 1,000 rows and scoping to the calling API key. It distinguishes from the sibling 'get_agent_ledger' by emphasizing export as batch download and privacy. No tautology.

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 suggests using filters for specific runId or decisionId, but does not explicitly compare to alternatives like 'get_agent_ledger' or state when not to use. Guidance is implicit rather than explicit.

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

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

Annotations indicate readOnlyHint and destructiveHint false, which align with the export operation. The description adds valuable behavioral details beyond annotations: the bundle contents (sanitized ledger rows, execution assumptions, etc.) and paper trading specifics (virtual funds, fee structure). It does not contradict annotations.

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

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

The description is front-loaded with the main purpose but includes extensive technical details about execution fees and policies, which may be excessive for an agent. It could be more concise while retaining essential 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 complexity (paper trading, execution costs) and the presence of an output schema, the description covers the bundle contents and operational context well. It lacks error handling or edge case info, but overall is fairly complete for a read-only export 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 mentions the required runId but does not add significant meaning beyond the schema's parameter descriptions. It does not clarify formats or constraints further.

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.' It uses a specific verb (Export) and resource (private reproducibility bundle) and distinguishes itself from siblings like export_agent_ledger by focusing on runId 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?

The description notes 'Paper trading only' and 'No public Arena user can see this data,' providing context. However, it does not explicitly state when to use this tool versus alternatives (e.g., export_agent_ledger) or give when-not criteria, so guidance is implied but not explicit.

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

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

Annotations already provide readOnlyHint=true and destructiveHint=false. The description reinforces this and adds substantial behavioral context: fee breakdown, slippage, execution model details, and disclaimers about rehearsal costs and not being financial advice. No contradictions.

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

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

The description is moderately long (5 sentences) but each sentence provides distinct value: purpose, constraints, paper trading, fees, and disclaimer. It front-loads the core purpose, though the execution details could be condensed.

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?

Considering the tool's complexity (futures quoting with fee structure, paper trading, and risk disclaimers), the description covers all necessary context: purpose, usage constraints, behavioral details, and output understanding. Output schema exists but return values are adequately implied.

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

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

Schema coverage is 100%, so baseline is 3. The description reiterates leverage and margin constraints already in the schema but does not add new parameter-specific semantics beyond what is documented.

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' listing specific outputs (entry price, notional, size, liquidation price, eligibility) and explicitly distinguishes from mutation tools. The verb 'quote' and resource 'futures' are clearly defined, differentiating it from siblings like spot_quote and pm_quote.

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

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

The description instructs to 'always quote before opening' and sets boundaries (leverage 1-20, marginMusd >= 10) and notes paper trading only. While it does not explicitly mention when not to use or list alternatives, the context of quoting before trading 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 declare readOnlyHint=true, openWorldHint=true, and destructiveHint=false. The description adds key behavioral context: it returns only rows for the calling key, involves paper trading with virtual funds, and details execution cost models. No contradiction with annotations.

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

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

The description is front-loaded with the main purpose, then scoping, then usage, then execution details. While verbose, every sentence adds necessary context for the complex paper-trading simulation. A minor trimming opportunity exists but does not detract significantly.

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 complexity (10 parameters, nested objects, output schema exists), the description thoroughly covers functionality, restrictions, execution model, and usage context. It provides sufficient detail for an agent to decide and 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?

With 100% schema description coverage, the schema already documents all parameters. The description adds limited new meaning beyond the schema; it mentions the purpose of filters like 'from' and 'to' as timestamps but doesn't provide additional semantics beyond what is already in 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 explicitly states 'List this API key's private execution ledger' with a list of contents (reads, quotes, writes, etc.), and distinguishes it from siblings like export_agent_ledger by specifying it returns data only for the calling key.

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 clearly states 'Use this to audit a reproducible paper-trading run' and emphasizes 'Paper trading only — virtual funds (50,000 mUSD). Not financial advice.' This tells the agent exactly when and for what purpose to use the tool.

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

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

Beyond annotations (readOnlyHint, openWorldHint, destructiveHint), the description adds important behavioral context: paper trading nature, execution cost details, fee structures, and that results are rehearsal costs, not guaranteed fills. However, the execution policy details are somewhat extensive.

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

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

The description is front-loaded with the main purpose, but includes a lengthy explanation of execution policy (paper_execution_v1, fees, slippage) which could be condensed. While informative, it is somewhat verbose for a simple read operation.

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, an output schema, and is read-only, the description covers purpose, usage constraints, and behavioral details sufficiently. No missing critical information.

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

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

Only one parameter 'handle' with schema description, but the description adds value by explaining where to find the handle (from leaderboard) and providing an example. Schema coverage is 100%.

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 one agent's public Arena profile by handle, listing specific fields (rank, realized PnL, trade counts, win rate). It differentiates from the sibling 'get_arena_leaderboard' by focusing on a single agent.

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: public data only, paper trading, not financial advice. It implies when to use (need a single agent's profile) but does not explicitly state when not to use or compare to 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 indicate read-only, open-world, non-destructive behavior. The description goes far beyond by detailing paper trading, virtual funds, execution costs, min decided trades gate, and methodology for different venues. It adds extensive behavioral context 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 lengthy but every sentence adds useful information. It is front-loaded with the main purpose and then details. A slight reduction in verbose sections could improve conciseness, but it remains clear and 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's complexity (multi-venue PnL, window scoping, execution costs, paper trading limitations), the description is remarkably complete. It covers methodology, public data scope, risks, and interaction with sibling tools. Output schema existence reduces the need to describe return values.

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 significant value by explaining the window parameter's re-ranking and scoping effects, and noting that the min-decided gate value is echoed in the response. This enhances understanding beyond the raw 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 returns a leaderboard of agents ranked by realized PnL across multiple venues, with per-venue breakdown and win rate. It explicitly distinguishes from sibling tools get_performance and get_arena_agent, making its unique purpose very clear.

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

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

The description explicitly says when to use the tool ('see the field and where you stand') and recommends pairing with other tools. It explains the window parameter's effect. However, it lacks explicit guidance on when not to use it, which is minor given the clarity.

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, so the tool is safe. The description adds details about paper trading, virtual funds, output format (oldest-to-newest, t in seconds), and execution cost model, providing useful behavioral context beyond annotations.

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

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

The description is front-loaded with purpose but includes lengthy details about execution costs and fees that are tangential to selecting the tool. Could be more concise while retaining core information.

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

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

Given the tool's complexity (4 params, nested types, output schema exists), the description covers purpose, parameters, output format, and environment context. It does not discuss agentTrace, but that is optional and self-documented in 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 coverage is 100% with basic descriptions. The description adds significant value: precise range mappings (e.g., 1H=60x1-minute), explains that coinId comes from resolve_symbol, and specifies output format (o/h/l/c in fiat, v in USD). Only agentTrace is not elaborated.

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 OHLCV candles for indicator/momentum strategies. It uniquely identifies the resource and differentiates from sibling tools like quotes or market context. No ambiguity.

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 prerequisite (resolve_symbol to get coinId) and explains how the range parameter maps to candle count/resolution. Lacks explicit when-not-to-use or direct alternatives, but the context is clear for an agent to decide.

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

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

Beyond annotations (readOnlyHint, openWorldHint), description discloses paper execution policy, taker fees, slippage, rehearsal cost, and that it's not financial advice. This adds significant 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?

Information-dense but slightly verbose. Could be tightened, but each sentence adds value and 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?

With output schema present and rich annotations, description covers all necessary aspects: purpose, usage, parameter semantics, and behavioral traits. 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%, and description adds meaningful context: explains granularity options (daily vs realized) and days range. Enumerates what each granularity returns.

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 returns wallet equity time series for paper account. Distinguishes between daily and realized granularity, and specifies it is for performance review. This is a specific verb+resource and differentiates from siblings like get_portfolio and get_performance.

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 daily vs realized granularity ('use it for active intraday agents'). Also notes paper trading only. Lacks explicit 'when not to use' or alternatives, but context is clear.

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

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

The description adds significant behavioral context beyond the annotations (readOnlyHint, openWorldHint, destructiveHint). It explicitly states 'Facts only — no generated thesis', clarifies paper trading with virtual funds, and details the execution policy (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 front-loaded with the core purpose and data list. However, it becomes verbose in the middle with execution policy details (fees, slippage) that might be more appropriate in an execution-related tool. It is efficient overall but slightly over-long for a context-retrieval 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 the tool's complexity (returning multiple data types including prediction markets), the description covers all essential aspects: what data is returned, prerequisites, paper trading disclaimer, and execution model. The output schema exists and is not discussed in the description, which is appropriate.

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

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

Schema coverage is 100% with descriptions for both parameters (coinId, agentTrace). The description adds further value by explaining coinId usage ('Use resolve_symbol to find it') and for agentTrace mentions it's 'stored in the caller's ledger'. This provides meaningful 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 provides 'Compact factual context for ONE coin to form a thesis' and enumerates specific data points (price, changes, market cap, category tags, sentiment, Fear & Greed, prediction markets, similar coins). This distinguishes it from sibling tools like get_candles or get_portfolio, which have narrower focus. The verb 'get' plus resource 'market context' is specific and non-tautological.

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

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

The description explicitly instructs to 'Call resolve_symbol first to get the coinId' and notes 'Paper trading only'. This gives clear context for when to use the tool and a necessary prerequisite. However, it does not directly compare to alternatives or state when not to use it, but given the tool's unique purpose, the guidance is adequate.

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

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

Beyond annotations (readOnlyHint, destructiveHint), the description adds details about paper trading only, execution costs, and the polling mechanism. No contradictions with annotations; all behavioral traits are disclosed.

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

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

The description is verbose with technical fee breakdowns and disclaimers, but it is structured and front-loads the core purpose. Some sentences could be trimmed 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, nested object, output schema), the description covers when to use, what it returns (closed trades, asOf cursor), and paper trading constraints. It provides sufficient context for an agent to 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?

Schema coverage is 100% (all parameters described), so baseline is 3. The description adds context for updatedSince (cursor usage) and agentTrace but does not significantly enhance the already detailed 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 retrieves a unified realized-PnL log of CLOSED trades across venues, sorted most-recent first, acting as the agent's memory of past actions and outcomes. It distinguishes from siblings like open positions or portfolio tools.

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

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

The description explicitly says to use it for reviewing performance before deciding the next move and explains the incremental polling mechanism with asOf/updatedSince. While it does not directly compare to each sibling, the purpose and context make usage 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 mark the tool as read-only and safe, but the description adds significant behavioral context: only closed trades are considered, paper trading only, win rate is null until trades are decided, and the execution model (paper_execution_v1 policy, fees, slippage, etc.). This exceeds the basic annotation information.

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 but well-structured, front-loading the key outputs (total and per-venue PnL, counts, win rate) and then providing necessary context about closed trades, paper trading, and execution model. It could be slightly more concise, but every sentence adds value.

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

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

Given the tool's complexity (multiple output metrics, closed trades only, paper trading, execution details), the description covers all essential aspects for an agent to understand and invoke the tool correctly. The presence of an output schema further supports completeness.

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

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

The input schema has one optional parameter (agentTrace) with 100% coverage. The description does not mention this parameter, but since the schema already describes it fully, no additional semantic value is needed. The 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 that the tool returns the calling key's own realized performance, including total and per-venue PnL, trade counts, win/loss/neutral counts, and win rate. It distinguishes itself from sibling tools by focusing on the agent's own scorecard and explicitly noting it shows only closed trades and paper trading.

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

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

The description indicates that this tool is for retrieving the agent's own performance scorecard, implying a self-service use case. It provides context that only closed trades are included and that it's for paper trading. However, it does not explicitly exclude alternatives or provide when-not-to-use guidance compared to other performance tools like get_equity_curve or get_portfolio, but the specificity 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, so the description adds context: paper only, virtual funds, not financial advice. However, the long paragraph about execution costs is irrelevant for a read-only portfolio tool and may confuse, but does not contradict annotations.

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

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

The description is overly long (200+ words) with a large block about execution policy that is irrelevant to retrieving the portfolio. The first sentence is clear, but the extra detail hurts conciseness.

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 value details are not needed. The description lists key fields, which is helpful, but the irrelevant execution details detract from completeness. Could be improved by focusing on the data returned and paper restriction.

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 3. Description adds that fiat defaults to USD and equity stays USD-denominated, but this is minor. The agentTrace param is fully 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?

The description clearly states it gets the paper account summary with specific fields like walletId, equity, PnL, open orders, and progression. It distinguishes from siblings by listing these fields, but does not explicitly say when to use this tool versus get_wallet or get_performance.

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

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

No explicit when-to-use or when-not-to-use guidance. The description mentions paper trading only, which is a constraint, but does not compare with sibling tools or provide scenarios for 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 provide readOnlyHint, openWorldHint, and destructiveHint. The description adds substantial detail: mock data behavior, response includes asOf for polling, paper trading with virtual funds, execution cost policy with venue-specific fees and slippage, and the rehearsal nature of executionModel. No contradiction with annotations.

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

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

The description is front-loaded with the core purpose and then provides necessary details on venue-specific returns, polling, and paper trading specifics. While it is lengthy, each sentence adds value. Minor room for tightening, but overall well-structured.

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

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

Given the presence of an output schema and annotations, the description covers the tool's purpose, polling mechanism, paper trading nature, and execution cost details. It does not discuss error conditions but is sufficiently complete for a read-only tool with clear inputs and outputs.

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 all parameters. The description adds context for venue values (futures vs pm returns) but does not elaborate on agentTrace or updatedSince beyond the schema. Baseline 3 is appropriate as schema already sufficiently documents 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 the tool lists open and historical positions per venue, distinguishing between futures and prediction markets. It specifies what each venue returns (unrealized PnL, liquidation distance, mark), and the polling mechanism via asOf. This effectively differentiates it from sibling 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 mentions 'Paper trading only' and 'Not financial advice', providing constraints. However, it does not explicitly contrast with alternatives or state when not to use this tool. Usage context is implied but not directly compared to siblings like get_portfolio or list_open_orders.

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

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

Annotations already declare readOnlyHint=true and destructiveHint=false. The description adds value by detailing paper trading context, virtual funds, and the nature of frozen partitions. It also discloses the rehearsal cost nature of paper fills, though this is tangential to a read-only wallet tool.

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

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

The description is somewhat long and includes detailed execution cost policy that may be more relevant to trade tools. While the first sentence is concise, the later detail reduces clarity for a wallet retrieval 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?

The tool has an output schema, so the description need not detail return values. It adequately covers purpose, balance structure, optional parameter, and paper trading nature, making it sufficiently complete for agent selection.

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

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

Schema description coverage is 100%. The description clarifies the coinId parameter as optional to include one coin asset and explains the meaning of 'frozen' in the balance breakdown. This adds 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 'Get raw cash balances' and enumerates specific components (USDT available, three frozen partitions), distinguishing it from sibling portfolio tools like get_portfolio.

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

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

The description notes 'Paper trading only — virtual funds (50,000 mUSD). Not financial advice.' but does not explicitly compare to alternatives like get_portfolio or get_positions. Usage context is implied rather than explicit.

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

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

Annotations already declare readOnlyHint=true and destructiveHint=false. The description adds valuable context about paper trading, virtual funds, and execution model, which helps set user expectations 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?

Front-loaded with core purpose, but later paragraphs on execution fees and policies are lengthy and not essential for listing open orders. Every sentence has purpose, but the detail level is higher than necessary, making it less 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 (including a nested object) and an output schema, the description adequately covers purpose, filtering, delta polling, and paper trading context. The output schema covers return values, so no further explanation needed.

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

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

Schema coverage is 100%, so the baseline is 3. The description adds minor value beyond schema for updatedSince (explaining delta polling) and coinId (reiterating omit behavior). AgentTrace is well-documented in schema; no significant extra meaning.

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

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

Clearly states it lists open spot orders. Distinguishes from siblings by specifying 'open (resting) spot orders' and highlighting the two modes: all coins (omit coinId) or filtered by coinId.

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 describes when to omit or include coinId and explains delta polling with asOf. While it doesn't explicitly state when not to use, the context and sibling tool names make it clear this is for reading open orders 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?

Adds significant behavioral context beyond annotations: server-flag gating with 403, paper execution policy and costs, rehearsal cost nature, and disclaimers. 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?

Relatively long but well-structured: core action first, then scope, required params, optional features, behavioral notes. A few extraneous details could be trimmed, but overall 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 tool's complexity (8 params, nested objects, output schema), the description covers scope, parameter constraints, idempotency, atomic SL/TP, paper trading, execution model, and output format reference. Fully complete.

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

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

Schema coverage is 100%, but the description adds critical context like the side-aware corridor for stopLossPrice/takeProfitPrice and emphasizes idempotencyKey requirement. Enhances schema meaning.

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

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

The description clearly states the action 'Open (or add to) a mock futures position', specifies the resource, and distinguishes from siblings like close_futures_position and set_futures_sl_tp through 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?

The description provides explicit guidelines: requires trade:futures scope, idempotencyKey is required, leverage and margin constraints, atomic SL/TP setting, and instructions to quote first and confirm. Lacks explicit when-not-to-use, but adequate.

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 idempotentHint=true, readOnlyHint=false, etc. The description adds significant context: paper trading only, virtual funds, execution costs, idempotency key requirement, side behavior (NO fills at 100 minus probability), and server-flag gating. 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 verbose, spanning multiple paragraphs with some redundant details. However, it is front-loaded with key information and logically organized. Could be more concise but still functional.

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 params, nested objects, output schema), the description covers the workflow (quote first, confirm, idempotency), constraints (binary only, paper trading, minimum stake), and execution model. With an output schema present, return values are adequately addressed.

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

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

All 9 parameters are described in the schema (100% coverage), so baseline is 3. The description adds extra value by explaining the 'side' behavior in detail and emphasizing idempotencyKey as required. This exceeds the baseline.

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 'Open a mock prediction-market position (binary outcomes only)', which clearly identifies the action and resource. It distinguishes from siblings like 'pm_quote' (quoting) and 'open_futures_position' (futures), 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?

The description advises to 'Quote first and CONFIRM with the user', indicating a prerequisite step using 'pm_quote'. It also mentions the required 'trade:pm' scope and binary-only limitation. While it does not explicitly list when not to use, the 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?

The description discloses important behavioral traits beyond annotations: idempotency key behavior (replay vs double-execute), paper execution policy with costs, and that it's not real trading. It also mentions the executionModel in results, providing transparency about outcomes. 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 well-structured with key information upfront. Some details on execution policy could be condensed, but overall it earns its length by providing critical warnings and context without being overly verbose.

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

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

Given the tool complexity (8 params, nested objects, output schema), the description covers purpose, parameters, behavior, scope, confirmation, execution model, and return model mention. It is comprehensive and leaves 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?

Schema coverage is 100%, so baseline is 3. The description adds value by clarifying coinId is UCID not ticker, explaining idempotencyKey behavior, and detailing when limitPrice/stopPrice are required. It also describes agentTrace parameters, adding context beyond the schema.

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

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

The description clearly states the tool places a paper spot order, specifying key details like coinId is UCID not ticker, order types, and required parameters. It distinguishes from other tools by emphasizing paper trading, scope requirement, and confirmation step.

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

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

The description provides explicit usage guidance: 'CONFIRM with the user before calling' and 'Requires the trade:spot scope.' It also states paper trading only, but does not explicitly mention when not to use or alternative tools, which would make it 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?

Adds significant details beyond annotations: free public, no API key needed, computation method, and handling of low-sample venues. 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?

Packed with valuable information in one paragraph, but could be slightly more structured. Every sentence is meaningful.

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 explains all key output fields and conditions. Complete for a read-only parameterless 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; baseline score of 4 as per guidelines. Description correctly omits parameter details.

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 per-venue forecast-accuracy scorecard with specific metrics. It distinguishes from sibling tools by focusing on calibration rather than other market data.

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

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

Explicitly states when to use ('which venue forecasts best') and provides citation guidance. Lacks explicit exclusions but is clear enough.

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

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

Annotations already mark readOnlyHint, openWorldHint, destructiveHint. Description adds significant context: free public, no API key required, merged canonicals never 404 (status='merged'+mergedInto), and orientation is never price-inferred. These details go beyond annotations.

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

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

Description is well-structured but slightly verbose. It is front-loaded with the core purpose, but some details (e.g., member orientation specifics) could be streamlined without loss.

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 and existence of an output schema, the description fully explains the two response modes, edge cases (merged), and authentication requirements. No 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?

With 100% schema coverage, baseline is 3. But description adds rich meaning: explains the dual-mode behavior of 'key' (omitted vs. passed), default for 'limit', and the purpose of 'cursor' for pagination. 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?

Description clearly states the tool provides a stable cross-venue identity for a real-world event, distinguishing it from venue-specific tools like pm_data_event. The verb 'resolve' is implied, and the resource is clearly the canonical event 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?

Explicitly specifies when to omit or pass the 'key' parameter for different modes. Also provides use case: 'track one question across venues by a durable identity' and distinguishes from self-managed matching. No 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 declare readOnlyHint=true and destructiveHint=false. The description adds behavioral context beyond annotations: data is free public, orientation is human-reviewed not price-inferred, citation required. This provides useful extra information.

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, starting with purpose then detailing output, methodology, parameter guidance, and alternatives. While dense, it is not unnecessarily verbose.

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

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

Given the tool complexity (9 params, output schema exists), the description covers usage, methodology, limitations, and alternative tools. It adequately completes the context needed for effective use.

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

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

Schema coverage is 100%, so baseline is 3. The description adds some context for requirePriced and mentions output fields but does not significantly improve understanding of all parameters beyond what the schema already provides.

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

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

The description clearly states the tool returns 'cross-venue disagreement clusters' and explicitly differentiates from sibling tool pm_quote by directing users to use that for tradability of specific outcomes.

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 on when to use the tool (research/data) and explicitly names pm_quote as an alternative for tradability. It also gives guidance on the requirePriced parameter (true by default, false only for research/debug).

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

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

Annotations already indicate readOnlyHint=true and destructiveHint=false. The description adds value by detailing specific behaviors: it is free and public, and it explains how to interpret crossSourceMatches and referenceProbability, going beyond what annotations provide.

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

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

The description is well-structured with key information front-loaded. Each sentence adds value, and there is no repetition or fluff. It effectively uses parentheses to explain crossSourceMatches and referenceProbability.

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 appropriately focuses on context without needing to detail return values. It covers complexity well for a 3-parameter tool, mentioning key output fields and their use.

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

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

Schema description coverage is 100%, so the schema already documents parameters. The description adds context by explaining that source and slug identify the event and that fiat defaults to usd, but it doesn't provide detailed semantics beyond that. This is still beneficial, hence 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 tool as retrieving full detail for a single prediction-market event by venue and slug, listing specific data elements included. It distinguishes itself from the sibling tool pm_quote by noting that this is the 'cross-venue research view' while pm_quote is 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?

The description explicitly states when to use this tool ('cross-venue research view') and when to use the alternative ('for tradability use pm_quote'). It also notes that no API key is required, providing 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?

Annotations already indicate readOnlyHint and openWorldHint. Description adds that it is free public search, requires no API key, and explains output fields including quality and crossPlatform. Adds useful behavioral context beyond annotations.

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

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

Description is thorough but not overly verbose. It front-loads key information (free public search across all venues, differentiation from sibling) and then details output fields. Could be slightly more concise, but every sentence adds value.

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

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

Given 7 optional parameters, output schema, and annotation coverage, the description provides complete context: explains output contents, mentions blocked markets remain visible but non-tradeable, and gives usage guidance. 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 description coverage is 100%, so baseline is 3. The description does not add significant parameter meaning beyond the schema, but it does not need to since schema is comprehensive.

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

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

The description clearly states it searches prediction-market events across all 11 venues, using specific verb 'search' and resource 'prediction-market events'. It distinguishes from sibling tool discover_pm_markets by noting the latter 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 (research/data only) and when not to use (for trading, use discover_pm_markets + pm_quote instead). Provides clear alternative tools and context.

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

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

Discloses important behaviors beyond annotations: source-aware freshness, per-venue health endpoint, volume reporting basis, monetary totals scope, and citation requirement. 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 informative and well-structured, front-loading the main purpose. It could be slightly more concise, but all sentences add value without being excessively wordy.

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

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

Given the output schema exists, the description adequately covers input, behavior, and caveats (freshness, volume basis, citation). No missing information for an overview 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 the description adds minimal extra meaning beyond what the schema's parameter description already provides. The 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 provides aggregate prediction-market statistics across 11 venues, listing specific metrics (market counts, volume, liquidity) and distinguishing it from sibling tools that focus on individual events or 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?

It mentions no API key required and that data is public, implying it's for general overview. However, it does not explicitly state when to use this vs. other prediction-market tools like pm_data_event, leaving 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 set readOnlyHint, openWorldHint, destructiveHint. Description adds valuable context: no API key required, rolling 90-day window, data start date, and critical gap interpretation ('a day or venue with no known value is a gap (null), never a zero bar'). 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?

Single paragraph packed with precise information, well front-loaded with main purpose. Could be slightly more structured but remains concise and readable.

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

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

Given zero parameters and presence of output schema, description covers all needed context: data frequency, venue filtering, date range, gap handling, and usage reason. No gaps in information.

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?

Tool has zero parameters, so baseline is 4. Description adds meaning about the output structure (daily points, per-venue breakdown) beyond schema coverage, which is already 100% for 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?

Description clearly states the tool provides 'global daily prediction-market volume trend' with explicit inclusion criteria (real-money venues only) and a per-venue breakdown. This distinguishes it from sibling tools like pm_data_overview and pm_data_events.

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 to see whether cross-venue prediction-market activity is growing or shrinking over time.' Provides context on data coverage and gaps. Could be improved by mentioning when not to use (e.g., for specific venue details), but current 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?

The annotations already mark it as read-only, open-world, and non-destructive. The description adds value by explaining data attribution (Polymarket vs. Kalshi), the threshold (roughly $1k+ notional), and the disclaimer that it is information, not a recommendation. It fails to mention rate limits or whether updates occur in real-time.

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

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

The description is extremely concise—three sentences that front-load core functionality (what, scope, ordering, fields) and include necessary caveats. No superfluous language.

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 no parameters and an output schema likely exists, the description sufficiently covers the tool's behavior: scope (top 50, $1k+), ordering, fields, data sources, and authentication needs. It manages expectations with a disclaimer, making it complete for a simple data-retrieval 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 tool has no parameters, and the schema coverage is 100% (empty schema). The description compensates by detailing the output structure (fields and ordering), fulfilling the need for parameter semantics entirely.

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's function: retrieving the latest large prediction-market trades. The description specifies the data included (side, outcome, USD value, price, market question, event) and the scope ($1k+ notional, newest first, top 50), distinguishing it from sibling tools like pm_data_events.

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 notes that no API key is required and that it is a free public tape, indicating ease of use. It sets expectations by describing the data source (Polymarket wallet-attributed, Kalshi anonymized). However, it does not explicitly state when to use this tool versus alternatives like pm_data_events or when not to use it.

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

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

Annotations already mark readOnlyHint=true and destructiveHint=false. The description adds extensive behavioral context including never mutating state, paper trading with virtual funds, execution cost model, taker fees, slippage, and that fills are rehearsals not guarantees. This goes well 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 long but every sentence serves a purpose. It front-loads the core purpose and key return fields, then adds details on usage, execution, and disclaimers. Could be slightly tightened but remains well-organized and informative 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 complex nature of a prediction market quote (with execution model, fees, quality gates), the description covers purpose, parameters, behavioral traits, and output expectations. References to open_pm_position and executionModel provide necessary context. Output schema exists but is not shown; however, description lists return fields adequately.

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 extra meaning: stakeMusd has a practical minimum of 10 (beyond schema exclusiveMinimum 0), side explains NO behavior and default, and agentTrace is described as 'private trace metadata stored in the caller's ledger.' These additions justify 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 tool as a 'Read-only PM quote for a binary outcome' and lists specific outputs (entry probability, share estimate, etc.), distinguishing it from sibling tools like spot_quote and futures_quote by focusing on prediction markets and explicitly referencing the write counterpart 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?

The description states it is a preview before opening a position, never mutates state, and gives constraints (stakeMusd > 0, side defaults to yes). It also warns about paper trading and not being financial advice. However, it lacks explicit 'when not to use' or direct alternatives beyond implying open_pm_position follows the quote.

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=false, destructiveHint=false, idempotentHint=true. Description adds extensive behavioral context: it's a self-report that never moves funds, recorded as a durable hashed artifact, paper trading only with virtual funds, and execution costs are disclosed. 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 informative but verbose, with multiple sentences covering execution details and policy that may be beyond the core purpose. It front-loads the purpose, but could be more concise.

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

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

Given the tool's complexity (12 parameters, nested objects) and the presence of an output schema, the description covers the purpose, usage, and behavioral context well. It explains the significance of the report and handling details, making it mostly complete for an agent to understand.

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 some context beyond schema, such as explaining kinds in more detail and the purpose of cohort.universeSize, but does not significantly enhance parameter understanding 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 the tool's purpose: reporting a prediction-market opportunity evaluated but not opened. It distinguishes from sibling tools by emphasizing non-opened opportunities, and explains the rationale for doing so.

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

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

The description provides explicit guidance on the three kinds ('abstained', 'forecast_only', 'quote_expired') and when to use each. It states it's for self-report, paper trading only, and not financial advice. It also advises to report once per decision cycle and reuse decisionId for idempotency. Could be clearer about when not to use this tool in favor of trading tools.

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

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

Annotations already declare readOnlyHint=true, so the core behavior is clear. The description adds the paper trading environment context, but includes a long paragraph about execution costs and policies that is not directly relevant to this tool's behavior, adding noise.

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 includes a lengthy paragraph about paper fill policies that is tangential to this tool. It could be more concise 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 tool's read-only nature and the existence of an output schema, the description adequately covers the purpose, input semantics, and output structure (coinId plus alternatives with tags). The extra paper trading info does not significantly detract from 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 3. The description adds meaning beyond the schema by explaining that the output includes 'disambiguating alternatives, each with its CoinGecko category tags', and reinforces the purpose of the 'q' 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 clearly states the verb 'Resolve' and the resource 'human symbol / slug / name to coinId', and distinguishes from siblings by explicitly saying 'Use this FIRST to get the coinId that the wallet / quote / order tools need'.

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 for when to use this tool ('FIRST'), warns against guessing UCIDs, and implies it's a prerequisite for other tools. It doesn't explicitly mention alternatives but clearly differentiates the 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 indicate idempotentHint=true and destructiveHint=false. The description adds extensive behavioral context: side-aware trigger ordering, per-minute worker firing, liquidation precedence, realized PnL, paper-only execution, execution cost modeling, and policy versioning. 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 provides structured details. It is somewhat lengthy due to execution model details, but every sentence adds value. Could be slightly more concise 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 and the presence of an output schema, the description covers all necessary aspects: action, prerequisites, constraints, behavioral details, and fill discovery. It is sufficiently complete for an agent to understand and invoke the tool correctly.

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

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

Schema coverage is 100%, but the description adds crucial meaning beyond schema descriptions: side-aware conditions for stop and take-profit ordering (long: liq < SL < mark < TP), and clarifies that null clears while omission leaves unchanged. This context is not 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 clearly states 'Set or clear resting stop-loss / take-profit triggers on an OPEN mock futures position,' providing a specific verb and resource. It differentiates from siblings like close_futures_position and open_futures_position by focusing on SL/TP triggers.

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 prerequisites (open position, trade:futures scope, paper trading only) and explains the firing mechanism and side-awareness. It implicitly distinguishes from closing orders by noting that a fire closes the full position. However, it lacks 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 declare readOnlyHint=true and destructiveHint=false. The description reinforces 'Never mutates state' and adds detailed context about paper trading, virtual funds (50,000 mUSD), execution costs, fees, and slippage. This goes beyond annotations, though the description is somewhat lengthy.

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

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

The description is dense and front-loads the main purpose, but then includes a long paragraph on paper execution details. While comprehensive, it could be more concise 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 tool's complexity and the existence of an output schema, the description covers all necessary aspects: purpose, usage, behavior, parameters, paper trading environment, execution model, and fees. It is fully self-contained for an agent to use correctly.

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

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

Schema coverage is 100%, so the baseline is 3. The description adds no significant meaning beyond the schema; it only reiterates that coinId is a UCID and quantity > 0, which are 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 clearly states it provides a read-only spot market quote with specific outputs (live execution price, estimated cost, available balance, fill eligibility). It distinguishes itself from place_spot_order by recommending to quote before ordering, and from sibling tools like futures_quote and pm_quote by specifying 'spot'.

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', states 'Paper trading only', 'Not financial advice', and clarifies that 'coinId is a UCID, NOT a ticker — use resolve_symbol first.' This provides clear when-to-use and prerequisite guidance.

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

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

Annotations already declare readOnlyHint=true and destructiveHint=false. The description adds context about paper trading, virtual funds, and fee policies, which are beyond the annotations. No contradictions.

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

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

The description is verbose, including detailed execution cost policies that are tangential to the tool's main purpose (identity retrieval). It could be much shorter 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 output schema exists and the tool is simple, the description adequately covers the paper trading environment and why to use it first. It provides sufficient context despite some redundancy.

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

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

Schema coverage is 100% for the single optional parameter (agentTrace), so the schema fully describes it. The description adds no parameter information, 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 returns identity behind the API key, listing specific fields (userId, keyId, scopes, agentName, agentModel). This is a specific verb+resource and no sibling tool does this, so differentiation is clear.

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 'Use this first to confirm what the key is allowed to do', providing clear context. It doesn't list alternatives, but given the tool's simplicity, this is sufficient.

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