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

The description adds significant behavioral context beyond annotations: it discloses the 'destructive bulk operation' nature (annotations already have destructiveHint=true, but this reinforces it), specifies a cost ('Costs 10 weight') not covered by annotations, and emphasizes user confirmation. This enriches understanding of the tool's impact and constraints.

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

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

The description is front-loaded with the core purpose in the first sentence, followed by critical warnings and cost details in subsequent sentences. Every sentence adds essential value (destructive nature, user confirmation, weight cost) with zero waste, making it highly efficient 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 (destructive bulk operation), the description is complete: it covers purpose, guidelines, behavioral traits (destructiveness, cost), and user confirmation needs. Annotations provide safety hints, and the schema covers parameters fully, so no output schema is needed for this action-oriented tool. All critical aspects are 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?

With 100% schema description coverage, the schema fully documents both parameters (comment and idempotency_key). The description does not add any parameter-specific information beyond what the schema provides, such as examples or usage tips. Baseline 3 is appropriate as the schema carries the burden.

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

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

The description clearly states the specific action ('Close ALL open positions') and resource ('on the account'), distinguishing it from sibling tools like close_by, close_position, and close_symbol that target specific positions or symbols rather than all positions. The verb 'Close' and scope 'ALL' are precise.

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 ('Close ALL open positions') and provides clear exclusions: it warns to 'confirm with user first' due to its destructive nature, and it distinguishes from alternatives by implying bulk operation vs. targeted closes in siblings. This gives strong guidance on usage 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?

The description adds valuable behavioral context beyond annotations: it specifies account type restrictions (hedging vs netting), mentions the error response (400 on netting accounts), and references a prerequisite check (get_auth_status). While annotations already indicate destructiveHint=true and readOnlyHint=false, the description provides operational constraints that aren't captured in structured fields.

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

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

The description is extremely concise and front-loaded with the most critical information. Every sentence earns its place: the first explains the core action, the second provides critical usage restrictions, and the third gives error behavior. There's zero wasted text or 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 destructive nature (destructiveHint=true), lack of output schema, and complexity of closing positions, the description is quite complete. It covers purpose, restrictions, prerequisites, and error conditions. The main gap is not describing the return value format, but with good annotations and clear operational guidance, it's mostly sufficient for agent 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?

With 100% schema description coverage, the baseline is 3. The description doesn't add parameter-specific information beyond what's in the schema descriptions (e.g., it doesn't explain the relationship between position and position_by beyond 'opposing'). However, it does imply that these parameters represent tickets for positions with the same symbol and opposite sides, which is somewhat helpful context.

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

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

The description clearly states the specific action ('close two opposing positions against each other') and resource ('positions'), and distinguishes it from siblings by specifying the unique hedging mechanism ('saves spread on smaller side'). It goes beyond just restating the name to explain the core functionality.

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: 'Hedging accounts only — check get_auth_status first' tells when to use (hedging accounts) and includes a prerequisite check. 'Returns 400 on netting accounts' explicitly states when NOT to use (netting accounts), and the sibling tool list includes clear alternatives like close_all, close_position, and close_symbol.

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 valuable behavioral context beyond annotations: it explains the volume parameter's optionality and its effect (full vs. partial close). Annotations already indicate this is a destructive, non-read-only operation, but the description clarifies the specific closing behavior. No contradictions with annotations exist.

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

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

The description is perfectly concise with two sentences that each earn their place: the first states the core purpose, the second explains the key parameter behavior. It's front-loaded with essential information and wastes no words.

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

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

For a destructive operation with no output schema, the description provides adequate context about the closing behavior. It could be more complete by mentioning potential outcomes (e.g., success/failure responses) or error conditions, but given the good annotations and clear purpose, it's mostly sufficient.

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

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

With 100% schema description coverage, the schema already documents all parameters thoroughly. The description adds minimal value by clarifying volume's optionality and effect, but doesn't provide additional syntax, format, or semantic details beyond what's 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 clearly states the specific action ('close an open position'), identifies the resource ('by ticket'), and distinguishes from siblings by specifying partial vs. full close behavior. It differentiates from close_all, close_by, and close_symbol by focusing on ticket-based closure.

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 about when to use this tool (closing by ticket) and distinguishes between full and partial closes. However, it doesn't explicitly state when to use alternatives like close_all or close_by, nor does it mention prerequisites like needing an open position with the given ticket.

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 annotations: it explicitly warns 'Destructive — confirm with user first' (reinforcing destructiveHint=true but adding user confirmation requirement), discloses a cost ('Costs 10 weight') not indicated in annotations, and clarifies the scope ('all positions for a specific symbol'). These details help the agent understand operational impact and constraints.

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

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

The description is extremely concise and front-loaded: the first sentence states the core purpose, followed by critical warnings and cost information. Every sentence earns its place with essential information, and there's no wasted verbiage or 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?

For a destructive tool with no output schema, the description provides strong context: clear purpose, destructive warning with user confirmation guidance, cost disclosure, and implicit parameter understanding through schema coverage. It lacks details on return values or error conditions, but given the annotations and schema richness, it's nearly complete for safe agent 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?

With 100% schema description coverage, the input schema already fully documents all three parameters (symbol, comment, idempotency_key). The description doesn't add any parameter-specific semantics beyond what's in the schema, so it meets the baseline of 3 for adequate but not enhanced parameter explanation.

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 specific action ('Close all positions') and target resource ('for a specific symbol'), distinguishing it from siblings like close_all (all symbols), close_by (different filtering), and close_position (single position). It uses precise language that leaves no ambiguity about what the tool does.

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

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

The description provides explicit guidance on when to use this tool ('Close all positions for a specific symbol') and includes a critical usage warning ('Destructive — confirm with user first'). However, it doesn't explicitly mention when NOT to use it or name specific alternatives like close_position for individual positions or close_all for all symbols, though the purpose implies differentiation.

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

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

Annotations already indicate read-only and non-destructive behavior, which the description doesn't contradict. The description adds value by listing the specific financial metrics returned, providing context beyond annotations. However, it lacks details on rate limits, authentication needs, or response format, which would enhance transparency.

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

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

The description is a single, efficient sentence that lists all relevant metrics without unnecessary words. It is front-loaded with the action 'Get' and immediately specifies the resources, making it highly concise and well-structured for quick comprehension.

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 (0 parameters, read-only annotations), the description is adequate but has gaps. It explains what data is retrieved, but without an output schema, it doesn't detail the return format or structure. For a financial tool, more context on data units or interpretation could improve completeness.

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

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

With 0 parameters and 100% schema coverage, the schema fully documents the lack of inputs. The description appropriately focuses on output semantics by listing the metrics retrieved, adding meaningful context without redundant parameter information. A baseline of 4 is justified as no parameters exist to document.

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

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

The description clearly states the verb 'Get' and specifies the exact financial metrics retrieved (balance, equity, margin, free margin, unrealized P&L, leverage), making the purpose explicit. However, it doesn't distinguish this from potential sibling tools like 'get_history' or 'get_positions' that might also retrieve account-related data, preventing a perfect score.

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 no guidance on when to use this tool versus alternatives. It doesn't mention prerequisites, timing considerations, or compare it to sibling tools like 'get_auth_status' for authentication checks or 'get_history' for historical data, leaving the agent without usage 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?

The annotations already declare readOnlyHint=true and destructiveHint=false, indicating this is a safe read operation. The description adds valuable context beyond this: it specifies the return data structure (login, margin mode, permissions, tier) and the recommended usage pattern (once per session). However, it does not mention potential rate limits, error conditions, or authentication requirements, which would provide richer behavioral context.

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

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

The description is extremely concise and well-structured: a single sentence that front-loads the purpose ('Check API key status'), details the return values, and ends with usage guidance. Every word earns its place, with no redundancy or wasted 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 low complexity (0 parameters, no output schema) and the presence of annotations covering safety, the description is mostly complete. It explains what the tool does, what it returns, and when to use it. However, it lacks details on error handling or session-specific constraints (e.g., what happens if called mid-session), which would enhance completeness for an authentication-related tool.

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

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

The input schema has 0 parameters with 100% description coverage, so the schema fully documents the lack of inputs. The description does not add any parameter-specific information, which is appropriate. However, it could have explicitly stated 'no parameters required' to reinforce this, but the baseline for 0 parameters is 4, as the description compensates by explaining the tool's purpose and usage clearly.

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 specific action ('Check API key status') and enumerates the exact information returned ('login, margin mode (hedging/netting), permissions, and tier'). It distinguishes this tool from all sibling tools, which focus on trading operations, account data, or market information rather than authentication status.

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: 'Call this once at session start.' This clearly indicates when to use it (at the beginning of a session) and implies when not to use it (repeatedly during the session). It also distinguishes this tool from alternatives by its unique purpose of checking authentication status, unlike sibling tools for trading or data retrieval.

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, establishing this as a safe read operation. The description adds valuable behavioral context beyond annotations: the 90-day limit for custom ranges and the cost information ('Costs 2 weight') which indicates resource consumption. This provides practical constraints that aren't captured in the basic 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 extremely concise and well-structured in just three sentences. The first states the purpose, the second provides critical usage constraints, and the third adds cost information. Every sentence earns its place with essential information, and the most important constraints appear immediately after the basic purpose statement.

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

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

For a read-only tool with good annotations and comprehensive schema coverage, the description provides excellent additional context about parameter constraints and resource costs. The main gap is the lack of output schema, so the description doesn't explain what format the history data returns. However, given the tool's relative simplicity and the strong parameter guidance, it's mostly complete for its purpose.

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

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

With 100% schema description coverage, the schema already documents all three parameters thoroughly. The description adds some semantic context about the mutual exclusivity of parameter groups ('EITHER...OR...not both') and the 90-day limit, but doesn't provide additional meaning beyond what's in the schema descriptions. This meets the baseline for high schema coverage.

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

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

The description clearly states the verb ('Get') and resource ('trade deal history'), making the purpose immediately understandable. It doesn't explicitly differentiate from sibling tools like 'get_account' or 'get_positions', but the specific focus on 'trade deal history' provides reasonable distinction. The description is more specific than a tautology but doesn't fully articulate how this differs from other data retrieval 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 provides excellent usage guidance with explicit constraints: 'Use EITHER a preset period OR a from/to date range, not both' and 'Custom ranges limited to 90 days.' This gives clear direction on parameter combinations and limitations. While it doesn't mention when to choose this tool over siblings like 'get_account', the parameter guidance is comprehensive for this specific tool's usage.

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

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

Annotations already declare readOnlyHint=true and destructiveHint=false, so the agent knows this is a safe read operation. The description adds context about what data is returned (ticket, symbol, type, volume, trigger price), which is useful beyond the annotations. However, it doesn't describe behavioral aspects like rate limits, authentication needs, or pagination.

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

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

The description is a single, efficient sentence that front-loads the key information ('List pending limit/stop orders') and adds necessary detail about the returned attributes. There's no wasted text, and every word contributes to understanding the tool's function.

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 (0 parameters, read-only operation), the description is complete enough for an agent to understand what it does and what data to expect. It doesn't have an output schema, but the description specifies the return attributes. For a straightforward list tool, this provides adequate 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?

The input schema has 0 parameters with 100% coverage, so no parameter documentation is needed. The description appropriately doesn't discuss parameters, focusing instead on the tool's purpose and output. This meets the baseline for tools with no 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 verb ('List') and resource ('pending limit/stop orders'), specifying the exact scope of what's being retrieved. It distinguishes itself from sibling tools like get_positions or get_history by focusing specifically on pending orders with specific attributes (ticket, symbol, type, volume, trigger price).

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 implicitly indicates when to use this tool (when you need pending limit/stop orders with specific attributes), but doesn't explicitly state when not to use it or name alternatives. For example, it doesn't clarify whether get_positions or get_history might be better for different types of order data, though the specificity helps guide usage.

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

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

Annotations already declare readOnlyHint=true and destructiveHint=false, so the agent knows this is a safe read operation. The description adds useful context about the data fields returned (P&L, entry/current price, etc.) but doesn't disclose behavioral traits like pagination, rate limits, or authentication requirements 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 efficiently structured in two sentences: the first lists the core functionality and data fields, and the second explains the optional filtering. Every sentence earns its place with no redundant information.

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

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

For a read-only tool with good annotations and a simple parameter schema, the description is mostly complete. It explains what data is returned and the filtering option. However, without an output schema, it could benefit from more detail on the return format (e.g., structure of the list), slightly reducing 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 description coverage is 100%, so the input schema already fully documents the single optional parameter (symbol). The description adds marginal value by mentioning the filtering option but doesn't provide additional syntax or format details beyond what the schema states.

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 with a specific verb ('List') and resource ('open positions'), and enumerates the data fields returned (ticket, symbol, side, volume, etc.). It distinguishes itself from siblings like get_history (historical data) and get_orders (pending orders) by focusing on current open positions.

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

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

The description provides clear context for when to use the tool ('List open positions') and includes an optional filtering capability ('Optionally filter by symbol'). However, it doesn't explicitly state when not to use it or name specific alternatives (e.g., get_history for closed positions), which prevents a perfect score.

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

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

Annotations already declare readOnlyHint=true and destructiveHint=false, indicating a safe read operation. The description adds valuable context beyond annotations by specifying the data source ('Continuum feed'), the live nature of prices, and the tool's purpose for pre-trade checks or monitoring, enhancing behavioral understanding 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 front-loaded with the core purpose in the first sentence, followed by usage guidelines in the second. Both sentences earn their place by adding distinct value—no wasted words, making it highly efficient 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 low complexity (1 parameter, 100% schema coverage, annotations provided, no output schema), the description is mostly complete. It covers purpose, usage, and data source, but could slightly improve by hinting at return format or limitations, though annotations handle safety aspects 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 description coverage is 100%, with the schema fully documenting the 'symbols' parameter as an array of strings with min/max items. The description adds minimal semantics by implying symbol examples like 'EURUSD' and 'XAUUSD', but doesn't provide additional details beyond the schema, meeting the baseline for high coverage.

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

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

The description clearly states the specific action ('Get the current live bid/ask price'), identifies the resource ('for one or more symbols'), and distinguishes it from siblings by specifying it returns prices from the Continuum feed for price checking or monitoring, unlike trading or account management tools in the sibling list.

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 ('to check prices before trading or to monitor price levels'), providing clear context for its application. It distinguishes from siblings by focusing on real-time price data rather than order execution or account queries.

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, indicating a safe read operation. The description adds valuable context beyond this: it specifies that the tool returns live bid/ask data and should be used for pre-trade validation, which helps the agent understand its practical application and timing. 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, followed by a detailed list of returned data and a clear usage guideline. Every sentence adds value: the first defines the tool, the second enumerates specifics, and the third provides critical context. No wasted words.

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

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

Given the tool's moderate complexity (single parameter, read-only operation) and lack of output schema, the description is quite complete: it details what data is returned and when to use it. However, it doesn't specify error conditions or response format, leaving some gaps for the agent to infer.

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

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

The input schema has 100% description coverage, with the 'symbol' parameter clearly documented. The description does not add any additional meaning or examples beyond what the schema provides (e.g., it doesn't elaborate on symbol naming conventions). Baseline 3 is appropriate as the schema handles the parameter documentation adequately.

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

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

The description clearly states the specific action ('Get detailed spec') and resource ('one symbol'), listing the exact data returned (digits, contract size, volume min/max/step, etc.). It distinguishes from sibling tools like get_symbols (plural) by focusing on a single symbol's details rather than listing all symbols.

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: 'Call before trading to validate volume.' It also implies an alternative: use get_symbols for listing symbols rather than getting detailed specs for one. This provides clear context and distinguishes it from other trading-related siblings.

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

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

The description adds valuable behavioral context beyond what annotations provide. While annotations indicate read-only and non-destructive operations, the description warns about 'large response' and 'costs 2 weight,' which are important performance and resource considerations that aren't captured in the structured annotations.

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

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

The description is perfectly concise with two sentences that each serve distinct purposes: the first states what the tool does, and the second provides usage guidance and warnings. There's no wasted language, and the information is front-loaded effectively.

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

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

Given that this is a read-only tool with no parameters and no output schema, the description provides excellent context about what the tool returns (400+ symbols with bid/ask), performance considerations (large response, weight cost), and when to use alternatives. The only minor gap is not explicitly describing the response format, but this is reasonable given the annotations already indicate it's a read operation.

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 0 parameters and 100% schema description coverage, the schema already fully documents the input requirements. The description appropriately doesn't add parameter information, maintaining focus on the tool's purpose and usage. This earns a baseline 4 for parameter semantics in a zero-parameter tool.

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 with specific verbs ('List all 400+ tradeable symbols') and resources ('symbols with bid/ask'), distinguishing it from the sibling 'get_symbol' which retrieves a single instrument. This provides immediate clarity about what the tool does.

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

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

The description explicitly provides usage guidance by stating when to use this tool ('List all 400+ tradeable symbols') and when to use an alternative ('Prefer get_symbol for a single instrument'). This helps the agent choose between this bulk retrieval tool and its more targeted sibling.

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 valuable behavioral context beyond what annotations provide: it explains that passing 0 removes SL or TP, clarifies that at least one parameter (sl or tp) is required despite the schema only requiring 'ticket', and specifies this works on 'open' positions. Annotations already indicate this is a non-destructive, idempotent mutation, so the description appropriately focuses on operational details.

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 perfectly concise with two sentences that each earn their place: the first states the core purpose, the second provides critical constraints. No wasted words, and the most important information (updating SL/TP) is front-loaded.

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

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

For a mutation tool with good annotations (non-destructive, idempotent) but no output schema, the description provides strong operational context. It could be slightly more complete by mentioning what happens when both sl and tp are provided simultaneously or clarifying error conditions, but it covers the essential usage scenario well.

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

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

With 100% schema description coverage, the baseline is 3. The description adds meaningful semantic context: it explains the special meaning of '0' values (to remove SL/TP), clarifies the relationship between sl and tp parameters (at least one required), and reinforces that this applies to open positions, providing valuable interpretation beyond the schema's technical 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 specific action ('Update SL and/or TP'), the target resource ('on an open position'), and distinguishes it from siblings like close_position or reverse_position by focusing on modifying existing positions rather than closing or reversing them.

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

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

The description provides clear context for when to use this tool (to update stop loss or take profit on open positions) and includes an important constraint ('At least one of sl or tp is required'), but it doesn't explicitly mention when NOT to use it or name specific alternatives among the sibling tools.

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

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

Annotations already indicate this is a destructive, non-readOnly, non-idempotent operation. The description adds valuable behavioral context beyond annotations: it explains the two-step composite nature, failure handling (207 error where position remains closed), and the cost ('Costs 2 weight'). This provides practical implementation details that annotations don't cover.

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

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

The description is extremely efficient: three sentences that each provide essential information. It's front-loaded with the core purpose, followed by implementation details and cost. There's zero wasted text or 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?

For a destructive trading operation with no output schema, the description provides good context about the composite nature and failure handling. However, it doesn't specify what happens on success (e.g., returns new position ticket) or detail the 'weight' cost system. Given the annotations cover safety aspects, this is reasonably complete but has minor gaps.

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

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

With 100% schema description coverage, the input schema already documents all three parameters thoroughly. The description doesn't add any parameter-specific information beyond what's in the schema. The baseline score of 3 is appropriate since the schema carries the full parameter documentation burden.

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

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

The description clearly states the specific action: 'Close a position and immediately open the opposite side with same volume.' It distinguishes this from sibling tools like 'close_position' by specifying it's a two-step composite operation that reverses rather than just closes. The verb+resource combination is precise and unambiguous.

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

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

The description provides clear context for when to use this tool: to reverse a position rather than just close it. It mentions the two-step composite nature and failure handling (207 error). However, it doesn't explicitly state when NOT to use it or name specific alternatives among the sibling tools, though the distinction from simple close operations is implied.

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 valuable behavioral context beyond annotations: it specifies this is a market order (not limit/stop), mentions the need for user confirmation before execution, and references volume constraints that must be checked via get_symbol. While annotations cover idempotency and non-destructive nature, the description adds practical execution details that help the agent understand the tool's behavior.

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

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

The description is perfectly concise with two sentences that each serve distinct purposes: the first states the core functionality, the second provides critical usage guidance. There's zero wasted language, and the information is front-loaded appropriately for an agent's decision-making process.

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

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

For a trading execution tool with no output schema, the description provides good context about prerequisites (get_symbol), user confirmation, and execution type. It could be more complete by mentioning potential errors, response format, or market conditions, but given the annotations cover safety aspects and the schema is comprehensive, it's mostly adequate.

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

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

With 100% schema description coverage, the schema already documents all 7 parameters thoroughly. The description adds minimal parameter semantics beyond the schema - it mentions volume constraints but doesn't provide additional meaning for specific parameters. The baseline of 3 is appropriate when the schema does the heavy lifting.

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 specific action ('Open a new position') and specifies it's a market order, distinguishing it from sibling tools like modify_position or close_position. It explicitly mentions the resource being created (a position) and the execution method.

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 when to use this tool: 'Call get_symbol first to check volume_min/max/step' establishes a prerequisite, and 'Confirm with user before executing' provides clear usage context. It distinguishes from alternatives by specifying this is for opening new positions versus modifying or closing existing ones.

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