MTContext

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

With no annotations, the description fully covers behavioral traits: maximum 5000 bars, 30-second timeout with BACKTEST_TIMEOUT return, capability requirement (analytics, Enterprise+), and supported entry/exit conditions. These details help an agent understand constraints and failure modes, though the exact return format is only hinted.

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

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

The description is concise with four sentences, front-loading the core purpose, then adding constraints, return value, conditions, and requirement. Every sentence adds value, though a more structured format (e.g., listing parameters) would improve scannability.

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 (nested strategy object, 6 parameters, no output schema), the description covers high-level purpose, limits, and capability needs. However, it omits details on structuring the strategy object, optional parameters, and the exact statistics returned, which limits completeness for an agent.

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

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

Schema description coverage is 0%, so the description must compensate. However, it only mentions the maximum bars and lists supported condition values for the strategy object. It does not explain the required parameters (symbol, timeframe, strategy structure) or optional ones (initial_balance, risk_per_trade_pct), leaving significant gaps.

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 runs a micro-backtest of a rule-based strategy, specifying it uses historical bars from the EA. This verb+resource combination is distinct from sibling tools, which include data retrieval, trade management, and analysis functions, making the tool's 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 implies the tool is for testing simple rule-based strategies but does not explicitly state when to use it versus alternatives like detect_patterns or get_trade_stats. No guidance on when not to use or prerequisites are provided, leaving the agent to infer applicability from context.

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

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

With no annotations, the description carries full burden. It discloses use of live account equity and symbol contract specs, returns recommended lot size and related values, and an error case LOT_TOO_SMALL. It does not explicitly state it is read-only, but as a calculation tool, this is inferred.

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?

Three sentences with no wasted words: first sentence states purpose, second explains data sources and outputs, third adds error case and tier info. Front-loaded and efficient.

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

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

Given no output schema and no annotations, the description covers the tool's purpose, inputs, data sources, return values, and an error case. It is sufficient for an agent to understand and invoke the tool correctly, though it could mention that it does not modify account state.

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 0%, and the description does not detail each parameter. However, the description explains the overall calculation based on equity and risk, and parameter names like risk_percent and stop_loss_pips are self-explanatory. The context of symbol being needed for contract specs adds value.

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

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

The description clearly states the tool calculates lot size for a trade using account equity and risk parameters. It specifies the verb 'calculates' and resource 'lot size', and distinguishes from siblings like place_order or risk management 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 mentions the tier availability and that it requires a connected terminal, but does not explicitly state when to use it or when not to use alternatives. The purpose is clear, but no direct guidance on tool selection among siblings.

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

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

With no annotations provided, the description discloses the main effect (cancelling an alert) and the error condition (ALERT_NOT_FOUND) for invalid or already processed alerts. It also mentions the tier requirement. It could be improved by noting idempotency or success response.

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

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

The description is two sentences long, with the action stated first, followed by error and tier information. There is no redundancy or irrelevant content.

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

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

For a simple tool with one parameter and no output schema, the description covers the core action, input source, error cases, and tier requirement. It lacks explicit mention of the success response format, but is otherwise 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 0%, but the description adds important context by specifying that alert_id comes from create_alert or list_alerts, and implies it is a UUID. This goes beyond the schema's minimal type definition.

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

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

The description explicitly states the verb 'cancels' and the resource 'active alert', and it distinguishes itself from sibling tools like create_alert and list_alerts by specifying the source of the alert_id.

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

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

The description provides context on when to use by indicating that it only works for active alerts that have not fired or been cancelled, and it mentions the Pro+ tier requirement. However, it does not explicitly state alternatives or when not to use.

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

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

Discloses default mode, live execution, error response, and requirements. Since no annotations exist, the description adequately covers behavioral aspects.

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?

Three concise sentences with front-loaded purpose. Every sentence contributes essential information with no 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?

Provides core info: purpose, parameters, behavior, error, requirements. Lacks return value details but given simplicity, it's largely 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 0% schema coverage, description adds meaning to both parameters: ticket as identifier, dry_run as execution mode with default. Could be more precise about ticket being order ID.

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 action (cancel), target (pending order), and method (by ticket). Distinguishes from sibling tools like close_position or modify_order.

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

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

Explains default dry_run behavior and how to execute live. Specifies error case and prerequisites (capability, EA setting). Lacks explicit comparison with 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?

No annotations are provided, so the description must disclose behavior. It clearly indicates a read-only check with no side effects and describes the return structure, which is sufficient for this type of tool. However, it could explicitly state that no order is created or state changed.

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 with two sentences that directly state purpose, supported types, and output. Every sentence adds value without unnecessary detail.

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

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

For a check tool with 4 parameters, no output schema, and no annotations, the description covers purpose and return structure but lacks parameter explanations and usage context. It is adequate but has clear 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 0%, requiring the description to elaborate on parameters. The description only mentions order_type via 'market and pending' and gives no explanation for symbol, volume, or price. This fails to add meaning beyond the schema's basic types.

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 checks order feasibility without placing it, specifies support for market and pending orders, and lists return fields. This distinguishes it from sibling tools like place_order.

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

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

The description implies usage for pre-trade verification but does not explicitly state when to use versus alternatives (e.g., place_order) or any exclusions. No prerequisites or when-not-to-use guidance is provided.

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

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

Discloses key behaviors: single-command execution, returns results array with per-ticket details, dry_run=true default, and required capabilities. With no annotations, the description carries the full burden and does so well.

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?

Three concise sentences, front-loaded with main action. No redundancy, 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?

For a tool with 2 optional params and no output schema, the description covers purpose, behavior, parameter semantics, return format, and prerequisites. Complete and self-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?

Adds meaning to both parameters: symbol is optional filter, dry_run controls live execution. This compensates for the 0% 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?

Clearly states the tool 'closes all currently open positions' with optional symbol filtering. Distinct from siblings like 'close_position' which closes a single 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?

Explains the benefit of using a single command to avoid multiple round-trips and partial-disconnect risk. Implicitly guides when to use (multiple positions) and notes prerequisites (trade capability, inp_AllowTrading).

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?

With no annotations provided, the description carries full burden. It discloses the dry_run parameter and the need for specific capabilities. However, it does not specify error handling for invalid tickets, return values, or whether the position is fully closed (as opposed to partial close which has a sibling 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 two sentences, no wasted words. It front-loads the action and provides essential details efficiently.

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

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

For a simple mutation tool with 2 parameters and no output schema, the description covers the primary action, default behavior, and prerequisites. It is sufficiently complete for an agent to use 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 description coverage is 0%, so the description must compensate. It explains the `ticket` parameter implicitly and `dry_run` explicitly, including its default value and purpose for testing vs live execution. This adds meaning beyond the schema structure.

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 'Closes' and the resource 'open position by ticket'. It distinguishes itself from sibling tools like `close_all_positions` (closes all positions) and `modify_position` (modify vs. close).

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 (to close a specific open position), the dry_run behavior with default true, and prerequisites (trade capability and inp_AllowTrading=true). No explicit mention of alternatives, but the context 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?

No annotations provided, but description discloses evaluation frequency (~30s, not tick-precise), durability (queued), tier caps (Pro 10, Team 50, Enterprise 200), and tier requirement (Pro+). Lacks info on rate limits or cap 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?

Every sentence adds value; front-loaded with main verb and resource. Efficiently packs type list, mode behavior, durability, retrieval, tier caps, and tier requirement into a few lines.

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 creation, types, modes, evaluation, durability, retrieval, tier caps, and tier requirement. Missing error handling, rate limits, and duplicate behavior, but adequately complete for a creation 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 low (20%), but description adds substantial meaning for the 'condition' object, explaining each type's condition sub-fields. Also clarifies mode and cooldown_seconds usage.

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

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

Clearly states it creates a persistent server-side alert, lists types (price, indicator, position_event, margin_level) and modes (once, recurring), and distinguishes from siblings like cancel_alert, poll_alerts, list_alerts.

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?

Explains when to use each type and mode, and mentions retrieval via poll_alerts. However, does not explicitly state when not to use this tool versus alternatives like place_order or set_equity_guard.

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?

With no annotations, the description carries full burden. It discloses deterministic nature, fixed thresholds echoed in response, and that patterns are locations not trade signals. It adds meaningful behavioral context beyond the schema.

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?

Three sentences with no fluff. Each sentence adds value: purpose and patterns, behavioral detail on thresholds, and clarifying nature and availability. Front-loaded with the main action.

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?

Missing output schema means description should explain response structure beyond 'criteria' field. Does not clarify how 'bars' parameter relates to 'recent bars' or that 'patterns' filters detection. Incomplete for a 4-parameter tool with no output schema.

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

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

Schema coverage is 0%, so description must compensate, but it only mentions 'recent bars' and lists patterns. It does not explain the meaning of the 'bars' parameter, the role of 'patterns' as a filter, nor other parameters like symbol or timeframe.

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 runs deterministic rule-based candlestick pattern detection over recent bars, listing specific patterns. It distinguishes from other tools by focusing on pattern recognition rather than indicators or signals.

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

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

The description implies usage for pattern detection but does not explicitly state when to use or not use this tool, nor mention alternatives. It provides no exclusions or context for selection among siblings.

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

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

With no annotations, the description carries full burden. It discloses the error return and capability requirement, and details what the explanation covers. Lacks mention of side effects but tool is read-only by nature.

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?

Three sentences with no redundancy. First sentence defines purpose, second adds scope, third adds error and requirement. Front-loaded and efficient.

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

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

No output schema exists, but description explains return content well. Covers error behavior and scope. Could briefly mention output structure, but not essential given the explanation is clear.

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 0%, and the description does not describe either parameter (ticket, timeframe). The only reference is 'ticket' in the error message, insufficient to guide parameter usage.

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

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

The description clearly states it explains a trade, listing specific elements (conditions, risk/reward, SL/ATR, alignment with strategies). It distinguishes itself from sibling tools, none of which cover trade explanation.

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

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

Provides context for open and closed trades, mentions error case POSITION_NOT_FOUND, and specifies the required analytics capability. Does not explicitly state when not to use, but the guidance is clear and sufficient.

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

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

No annotations are provided, so the description should compensate, but it only lists returned fields. It does not disclose whether the data is real-time or cached, any authentication requirements, or side effects. This is a significant gap for a tool that returns sensitive financial data.

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

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

The description is a single, clear sentence with no wasted words. It is front-loaded and 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 zero parameters and no output schema, the description is mostly complete. It lists the returned fields. A minor gap is not mentioning data freshness or real-time nature, but overall 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?

The tool has no parameters and schema coverage is effectively 100%. The description does not need to add parameter meaning; baseline is 4.

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

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

The description clearly states the tool returns account balance, equity, margin, leverage, and currency. The verb 'Returns' and resource 'account info' are specific, and the tool is easily distinguished from siblings like get_positions or get_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?

No explicit guidance is provided about when to use this tool versus alternatives. The description implies it is for fetching account-level financial data, but lacks context on prerequisites or exclusions.

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

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

With no annotations provided, the description carries full responsibility for disclosing behavior. However, it only states that bars are returned, without mentioning read-only nature, rate limits, data freshness, or any side effects. This is insufficient for safe invocation.

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

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

The description is a single, front-loaded sentence with zero unnecessary words. Every element contributes directly to understanding the tool's core 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 absence of an output schema, the description should clarify return format (e.g., array of OHLCV objects, ordering, timezone). It also lacks any usage hints like date range or symbol format, making the tool underdescribed for reliable 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 0%, so the description must add meaning. It mentions 'symbol and timeframe' but omits the 'count' parameter entirely. It does not explain enum values (e.g., M1, H1) or the range of count, leaving critical details undocumented.

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

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

The description explicitly states the verb 'Returns' and the resource 'OHLCV bars' with required parameters 'symbol and timeframe', making the purpose unambiguous. It also naturally distinguishes from sibling tools like get_tick or get_market_snapshot, which return different data types.

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

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

No guidance is provided on when to use this tool versus alternatives such as get_tick_history or get_market_snapshot. The description lacks any context about prerequisites or scenarios, leaving the agent to infer usage from the name alone.

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?

With no annotations provided, the description fully discloses behavior: thresholds are fixed constants echoed in the 'criteria' field, it is descriptive coaching not psychological assessment, and it returns DATA_INSUFFICIENT for insufficient data. 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 concise, well-structured, and front-loaded with the core purpose. Each sentence adds necessary information without redundancy. 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 two parameters with full schema descriptions and no output schema, the description adequately explains the return condition (DATA_INSUFFICIENT) and references the 'criteria' field. However, it does not detail the exact output structure for the metrics, leaving some room for interpretation.

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

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

The input schema already has 100% coverage with descriptions for the two parameters (to_date, from_date) specifying ISO dates and defaults. The description adds that computations use a trailing 30-day baseline for overtrading, providing marginal added value. Baseline 3 is appropriate.

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

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

The description clearly states that the tool computes descriptive behavioral metrics from closed trade history, listing specific metrics like overtrading, revenge trading, volume escalation, and hold-time asymmetry. It distinguishes itself from a psychological assessment, 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 provides clear context: it requires at least 10 closed trades and the 'analytics' capability (Team+ tier). It does not explicitly compare to siblings like get_trade_stats, but the unique focus on behavioral patterns implies when to use it. A brief sibling comparison would improve 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?

No annotations are provided, so the description carries full burden. It discloses that the tool reads from persisted snapshots (no LLM call), includes a recent_change indicator, source statements, and classifier provenance marker. This provides transparency about the tool's behavior and output components.

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

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

The description is two sentences plus a requirement line, front-loaded with the core purpose. Every sentence adds value with no redundant information. It is well-structured and efficient.

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

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

Given the tool has only one parameter and no output schema, the description adequately covers input, behavior (read from snapshots, no LLM call), output components (score range, recent_change, source statements, classifier provenance), and requirement (analytics capability). It is complete for an agent to correctly invoke and interpret the tool.

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

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

Schema coverage is 0% (no descriptions in input schema). The description only mentions 'for a currency' but does not specify the exact format (e.g., 3-letter ISO code) or provide additional guidance beyond the schema's type and length constraints. This fails to compensate for the lack of schema documentation.

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

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

The description clearly states it returns the central bank hawk/dove stance for a currency, with a defined score range. It distinguishes itself from siblings by specifying it reads from persisted snapshots (no LLM call), which is unique among the many get_* 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 states the requirement for the 'analytics' capability (Team+ tier), which helps agents know when the tool is accessible. However, it does not explicitly mention when not to use it or suggest alternatives, leaving some implicit 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?

With no annotations, the description provides basic behavioral info: it returns a range and requires a specific capability. It does not explicitly state it is read-only or describe side effects, error behavior, or permissions beyond the tier requirement.

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 consists of two concise sentences: the first states the action, the second adds the output range and requirement. Every word adds value, with no 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?

Without an output schema, the description explains the return value range and the capability requirement, which is sufficient for this simple tool. It could optionally clarify the input price type (e.g., daily close), but it is generally complete.

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

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

Schema description coverage is 0%, but the description adds meaning by explaining 'two symbols' and 'N daily bars,' which maps to the parameters. It does not detail defaults or constraints, but the high-level meaning is present.

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

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

The description clearly states the tool returns the Pearson price correlation coefficient between two symbols over N daily bars, with a specific range. It distinguishes this tool from siblings like get_indicator or get_key_levels by its unique purpose.

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

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

The description mentions the requirement for the analytics capability (Team+ tier), providing a usage constraint. However, it does not specify when to use this tool versus alternatives, nor does it give explicit guidance on 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?

With no annotations, the description fully discloses behavioral traits: data sourced from CFTC Socrata public API (free, no key), 24-hour caching, supported symbols, error response format ('COT_UNAVAILABLE'), and required capability. This is highly transparent.

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?

Three concise sentences front-load the primary purpose, followed by essential details (source, caching, symbols, error, requirement). No superfluous 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 data retrieval tool with 3 parameters and no output schema, the description covers functionality, data origin, caching, error behavior, and capability requirements. It lacks parameter-specific guidance but otherwise 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?

Schema description coverage is 0%, so the description must compensate by explaining parameters. However, it only mentions supported symbols and does not explain 'weeks' or 'report_type' semantics. The description adds minimal value beyond the schema's defaults and enums.

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 CFTC COT report data for a currency or commodity. It specifies data source, caching, supported symbols, error handling, and required capability, distinguishing it from siblings in the domain.

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

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

The description provides context for when to use the tool (to get COT data) and notes the required capability (analytics, Team+ tier). While it doesn't explicitly state when not to use it or list alternatives, no direct sibling tool overlaps in functionality.

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?

With no annotations provided, the description carries full burden. It discloses that missing symbols are skipped and listed in skipped[], and currencies with fewer than 4 contributing pairs are flagged as low_confidence. It also notes the required tier. This provides useful behavioral context beyond a basic read operation.

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

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

The description is three sentences, front-loaded with the primary function. Every sentence adds value: purpose, behavior on missing data, and prerequisites. No 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 no output schema, the description provides sufficient context about the output: ranking, skipped list, and low confidence flags. It also explains the computation source. However, it could be more explicit about the return format (e.g., JSON structure).

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 0%, so the description should explain parameter semantics. The description mentions 'computed from bars' hinting at the 'bars' parameter, but does not explain the 'timeframe' parameter or provide details on their meaning and usage. The parameter defaults and constraints from schema are not supplemented.

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 ranks 8 major currencies by normalized % change from major crosses. It specifies the exact currency list, the source (Market Watch), and output ordering (strongest first). This is a specific verb+resource combination that leaves 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?

The description mentions the required analytics capability (Team+ tier) and explains behavior for missing symbols and low confidence. However, it does not provide guidance on when to use this tool over siblings like get_correlation or get_market_context, nor does it state 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?

With no annotations, the description carries the full burden. It discloses the preference for MT5 Calendar API, fallback to server-side, and the inclusion of a source field in the response. This covers key behavioral traits.

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

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

The description is three sentences, front-loading the core purpose, then behavior and requirements. No superfluous 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?

The description mentions the source field but does not describe the full structure of returned events (e.g., fields like event name, date, actual/forecast). Given the lack of output schema, additional details would 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?

Schema coverage is 0% and the description provides no information about the four parameters (impact, currencies, hours_back, hours_ahead). The agent must infer meaning solely from parameter names, risking misuse.

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 economic calendar events, with specific details about the source fallback. However, it does not explicitly distinguish from sibling tools like get_news or get_macro_indicators.

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

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

The description mentions the requirement for analytics capability (Team+ tier) and the fallback behavior, but does not provide explicit guidance on when to use this tool versus alternatives.

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

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

With no annotations, the description discloses key behaviors: weighting rule, insufficient_history error condition, and server-side calendar usage. It does not detail response format or pagination, but for a read-only index tool, this is adequate.

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?

Three concise sentences: purpose, error condition, requirement. No superfluous words. Every sentence adds 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?

The description covers purpose, error handling, and a capability requirement, but it lacks parameter documentation and return value details (no output schema). For a two-parameter tool, this is minimally adequate but not 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?

The schema has 0% description coverage, yet the description only implies the 'currency' parameter via context. The 'days' parameter (default 90, min 7, max 365) is not mentioned, leaving its role unclear. The description should explain both parameters to compensate.

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 'rolling actual-vs-forecast surprise index for a currency's economic events' with specific weighting by impact tier. This distinguishes it from siblings like get_economic_calendar or get_macro_indicators.

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

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

The description explicitly notes the requirement for the 'analytics' capability (Team+ tier) and mentions the server-side calendar dependency. However, it does not contrast with sibling tools, leaving the agent to infer 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?

With no annotations, the description carries the full burden. It discloses the required capability and lists returned fields. As a read-only operation, no destructive side effects are implied, but it does not explicitly state the read-only nature.

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

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

Two sentences efficiently convey purpose and requirement. Every sentence is necessary and front-loaded, with no 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 simple getter with no parameters or output schema, the description adequately covers the purpose, output fields, and capability requirement. Minor gaps remain regarding return format and explicit read-only behavior.

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

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

There are no parameters, so the schema provides no meaning. The description adds value by detailing the returned data fields, compensating for the lack of 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 that the tool returns the current equity guard configuration and status, listing specific fields. However, it does not explicitly differentiate this getter from sibling tools like 'set_equity_guard' or 'remove_equity_guard'.

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

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

The description mentions the required 'trade' capability, providing a prerequisite. However, it does not offer guidance on when to use this tool versus alternatives 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?

The description discloses key behavioral traits: it is a preflight check (read-only), uses server-side calendar, provides verdict and details, and has a fail-safe for unknown symbols. No contradictory 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 extremely concise: two sentences that front-load the purpose and quickly cover features and requirements. No redundant or irrelevant 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 6 parameters and no output schema, the description lacks detail on how parameters influence the verdict and the exact structure of the response (beyond mentioning blackout windows and resume_after). It is adequate but not complete for a tool of this complexity.

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

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

With 0% schema description coverage, the description does not explain the meaning, purpose, or behavior of any of the 6 parameters (e.g., horizon_hours, high_after_min). This leaves the agent without necessary guidance for correct parameter usage.

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

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

The description clearly states the tool returns a graded verdict (proceed/caution/block) for trading a symbol based on upcoming economic events, distinguishing it from siblings like backtest_strategy or get_risk_summary.

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

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

The description provides usage context: works without terminal, includes blackout windows, unknown symbols default to caution, and requires analytics capability. However, it does not explicitly state when not to use this tool versus alternatives.

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

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

With no annotations, the description carries the full burden. It discloses that the tool reports read-only slippage statistics, handles missing historical data with a specific error, and requires a capability. It does not mention rate limits or other edge cases, but covers key behaviors adequately.

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 consists of two concise sentences with no redundant information. It front-loads the main purpose and then adds essential details about metrics, data availability, and requirements.

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 no output schema, the description fully explains what the tool returns (average, median, worst slippage, overall and per symbol) and the error case (DATA_INSUFFICIENT). It also provides necessary context about fill auditing and capability requirements, making it complete for an information-reporting 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 67% with two parameters having descriptions. The description adds value by explaining that using 'symbol' yields per-symbol stats while omitting it gives overall stats, and that date ranges are constrained by the fill auditing start date. This compensates for the missing schema description on 'symbol'.

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 reports slippage statistics for live market orders, specifying metrics like average, median, and worst slippage in points, both overall and per symbol. This is distinct from all sibling tools, which cover orders, positions, indicators, etc.

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

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

The description explains that the tool is for live market orders via MT-MCP, that measurement starts from fill auditing enablement, and that earlier periods return DATA_INSUFFICIENT with the earliest date. It also states the required analytics capability. No explicit alternatives, but the context is clear enough for deciding when to use.

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

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

No annotations are provided, so the description must carry the behavioral burden. It states 'Pure server-side computation', implying read-only and deterministic behavior, but does not explicitly confirm safety, error handling, or rate limits. The description adds some context beyond the schema but is not fully transparent.

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

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

Two sentences with no wasted words. The first sentence states the purpose, and the second adds relevant context (computation method, tier). It is front-loaded and efficient.

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

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

With no output schema, the description should hint at return values. It does not describe the structure of Fibonacci levels (e.g., list of retracement and extension levels). The tool is simple but the output format is left entirely to the agent's inference, making it incomplete.

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 0%, so the description should compensate by explaining parameters. It mentions 'swing high and low price points' but does not link them to the schema parameters or explain the 'direction' enum or default. The parameter names are self-explanatory, but the description adds minimal value beyond the schema.

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

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

The description clearly states the tool computes Fibonacci retracement and extension levels from swing high and low price points. It uses a specific verb ('Computes') and identifies the resource ('Fibonacci retracement and extension levels'), distinguishing it from sibling tools that focus on other functions like backtesting or order management.

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

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

The description mentions 'no EA dispatch required' and 'Available at Free+ tier', which gives some context but does not explicitly state when to use this tool versus alternatives or when not to use it. It lacks exclusions or comparisons to related tools like get_key_levels.

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?

No annotations are provided, so the description carries full burden. It discloses that the tool uses a server-side calendar, reports events, gap exposure, and triple-swap flags. It also states the capability requirement. However, it does not explicitly state whether the tool is read-only or if it modifies any state, though the context suggests it is an assessment 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 three sentences with clear front-loading: purpose first, then output details, then capability requirement. 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?

No output schema exists, but the description gives a good idea of what the tool returns (events, gap exposure, triple-swap flags). It could be more specific about the output format, but is largely complete for a risk assessment tool given the complexity.

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

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

Schema coverage is 0%, so the description must add meaning. It mentions 'symbol' and 'specified duration' (implied expected_hold_hours), but does not detail constraints or defaults. The description adds some context but insufficient to fully compensate for lack of 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 assesses risk for holding a position in a symbol for a duration, with specific outputs like events, gap exposure, and triple-swap flags. It is a unique tool among siblings, but lacks explicit differentiation from related tools like get_event_risk or get_risk_summary.

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

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

The description mentions it works with no terminal and requires analytics capability, but does not provide when-to-use or when-not-to-use guidance. It implies usage for holding risk assessment but no alternatives or exclusions are given.

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?

No annotations provided, so the description carries full burden. It discloses that values are deterministic and unlabelled, and details the return structure for each indicator (e.g., MACD returns macd, signal, histogram). This provides substantial behavioral insight beyond the schema.

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 a clear introductory sentence and a bullet-pointed list of indicators. Every sentence adds value, though some redundancy could be trimmed. It is front-loaded with the main usage.

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

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

Given the complexity (6 parameters, many indicator options) and absence of an output schema, the description is highly complete. It covers all indicators and their return structures. Missing are error handling or edge cases, but it suffices for the primary use case.

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

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

Schema description coverage is 0%, but the description extensively documents each parameter, including conditional constraints for timeframe/timeframes, valid indicator values, and default parameters for each indicator. This adds significant meaning 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 raw indicator values for a symbol and timeframe, listing supported indicators with their parameters. It uses a specific verb ('get') and resource ('indicator values'), distinguishing it from other data-fetching tools like get_bars or get_market_context.

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

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

The description explains that the tool returns unlabelled values and the caller interprets them, and that exactly one of timeframe or timeframes must be provided. While it doesn't explicitly state when not to use it versus siblings, the context makes it clear for indicator 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?

Without annotations, description discloses data source, included fields (last change date, next decision), and terminal-dependent behavior. Lacks information on caching or rate limits, but adequately covers key traits.

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?

Three concise sentences, each providing essential information: function, output details, error case, and requirements. No fluff.

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 core functionality and error case, but with no output schema and no parameter description in text, the agent may lack clarity on response format. Adequate but not thorough.

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 0% description coverage, and description does not explain the 'currencies' parameter or its allowed values/enum. The agent must rely solely on the schema, which is insufficient for a tool with no output 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 returns central bank policy interest rates for major currencies from MT5's Calendar API. Distinct from siblings like 'get_rate_differential' or 'get_economic_calendar'.

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 mentions that it returns an error on MT4 and requires the 'analytics' capability (Team+ tier). Provides clear prerequisites and a when-not-to-use case, but does not compare with alternatives.

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

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

The description mentions 'available=false when the log cannot be read', indicating a failure condition. However, there are no annotations, and the description does not explicitly state that the tool is read-only or disclose other behavioral traits.

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

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

The description is concise with one sentence and a note about 'available'. It is front-loaded with the core purpose, but could be more informative without becoming 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 lack of output schema and the presence of siblings, the description is incomplete. It does not explain the return format, how to interpret the 'available' flag, or how this tool relates to 'query_journal'.

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 0%, and the tool description does not explain the parameters 'date' or 'count'. The description adds no value beyond the raw schema, failing to compensate for the lack of parameter documentation.

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 'returns' and the resource 'MT5 Journal log', making the tool's purpose obvious. However, it does not differentiate from the sibling tool 'query_journal', which may have a similar function.

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 guidance is provided on when to use this tool versus alternatives like 'query_journal'. The description lacks context about prerequisites or limitations.

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?

No annotations are provided, so the description carries the full burden. It discloses the computation methods (classical pivots, fractal detection, psychological levels) and that each level includes distance from current price. However, it does not mention whether the operation is read-only, any prerequisites, or error behaviors.

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

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

The description is a single paragraph of three sentences, covering the core functionality efficiently. It could be slightly more front-loaded (the verb 'computes' appears first), but overall it is concise with no extraneous 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?

The tool has 3 parameters and no output schema. The description mentions that each level includes its distance from current price but does not describe the return format (e.g., list of objects, order of levels) or any error conditions. It is adequate but lacks completeness for an agent to fully understand the output.

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 0%, meaning the description does not explain any parameters. While the schema defines 'symbol', 'timeframe', and 'swing_bars' with constraints, the description adds no meaning beyond listing the tool's capabilities. For example, it does not clarify that 'timeframe' is the prior period for pivot calculation or that 'swing_bars' controls lookback for swing detection.

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 computes support/resistance key levels including classic + Fibonacci pivots, swing highs/lows, and psychological round numbers. It distinguishes itself from sibling tool 'get_fibonacci_levels' by offering a broader set of level types.

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

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

The description mentions the 'Free+ tier' but does not explicitly state when to use this tool versus alternatives like 'get_fibonacci_levels' or 'detect_patterns'. Usage context is implied but not with clear guidance.

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

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

No annotations are provided, so the description carries the full burden. It discloses data source, MT4 incompatibility, and capability requirement, but does not explain error handling for invalid currency, rate limits, or whether data is cached vs fresh. More details on side effects (none expected) would improve 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?

Three sentences: what it does, data source, and constraints (MT4 error, capability). No redundancy, every sentence serves a distinct purpose.

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

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

The description mentions returned fields (actual, previous, forecast, surprise) but does not specify the response structure (e.g., array of objects, keyed by indicator) despite no output schema being provided. For a tool returning multiple indicators per currency, this leaves ambiguity about how to parse results.

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 0%, and the description fails to explain the 'indicators' parameter (an optional array of enums) or the format of currency (3-letter code). It only mentions 'for a currency' but does not define how to specify multiple indicators or the allowed values for the indicator field.

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 'returns' and the resource 'key macroeconomic indicators' with a list of specific indicators (CPI, GDP, NFP, etc.). It distinguishes this tool from siblings like get_economic_calendar and get_economic_surprise by focusing on latest values and surprise data.

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

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

The description provides context for when to use (for macro indicators), specifies data source (MT5 Calendar API), and notes terminals where it fails (MT4 returns error). It also states the required capability (analytics, Team+ tier). However, it does not explicitly list alternatives or when not to use.

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

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

With no annotations, description fully discloses behavior: reads server-side market-snapshot, degrades transparently (missing_inputs listed, never zeroed), risk_tone unknown unless both VIX and DXY present, returns MARKET_CONTEXT_UNAVAILABLE when no input.

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 fairly long but every sentence provides unique value. Front-loaded with purpose. Minor verbosity but still efficient.

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

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

Given zero parameters and no output schema, description fully covers return fields, degradation behavior, capability requirement, and relationship to sibling. 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?

No parameters in schema; baseline 4 applies. No parameter info needed, but description adds no param details (not required).

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 DXY, VIX, US 10Y yield with level, change, asof, source, and risk_tone. Explicitly distinguishes from sibling get_risk_regime ('raw-feed reader that get_risk_regime is not').

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?

Specifies when to use: need live cross-asset context in one call, works without terminal (incl. MT4), requires analytics capability. Also notes what it is not (composite 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?

Even without annotations, the description discloses key behaviors: broker dependency, MT4 limitation, and required capability (Pro+ tier read). This fully informs the agent of 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?

Three concise sentences, each adding unique information. No redundancy. Front-loaded with the core action.

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 main behaviors, error cases, and prerequisites. Missing return structure details, but with no output schema, the brief note on empty arrays/error is acceptable. Could mention expected array format.

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

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

Schema descriptions are absent (0% coverage), but the description does not explain the `levels` parameter (e.g., how many levels, default, range). It only mentions 'bid/ask levels' without specifying 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 the tool returns DOM bid/ask levels for a symbol, using specific verbs and resource. It distinguishes from siblings like get_market_snapshot or get_ticks by focusing on order book depth.

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

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

Provides clear context: requires broker DOM data, empty arrays if unavailable, and MT4 returns error. However, it does not explicitly differentiate from alternative tools for similar data (e.g., get_market_snapshot).

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

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

Description discloses that computation is pure server-side UTC and no EA dispatch is needed, which informs the agent about efficiency and no side effects. Since no annotations are provided, this transparency is valuable.

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

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

Two sentences, no redundancy. Front-loaded with the key output, then adds performance and tier info. Every sentence is essential 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?

Description covers the main output (which sessions, open/close times) and includes the UTC and tier context. Lacks details on return format, but given no parameters and no output schema, it is largely 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?

Tool has no parameters so baseline is 4. Description does not need to add parameter info; it correctly implies no input is needed.

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 returns which major trading sessions are open and next open/close times. It uses specific verb 'Returns' and names the resource ('major trading sessions'), distinguishing it from sibling tools like get_market_snapshot.

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 guidance on when to use this tool versus alternatives. While it mentions 'no EA dispatch required' as a performance note, it does not provide when-not or alternative tools, leaving the agent without decision 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?

No annotations are provided, so the description fully covers behavioral traits: limits (4 timeframes x 6 indicators, 10 values each), deadline handling with partial results and missing list, raw unlabelled values, and Free+ tier availability. 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 a single dense paragraph that front-loads the main purpose. Every sentence adds value, but it could be broken into structured bullet points for easier scanning. It is appropriately sized with 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 4 parameters and no output schema, the description covers purpose, parameters (partially), limits, and partial results. However, it misses explaining the 'bars' parameter and lacks a description of the response structure (e.g., JSON format), which would enhance 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 0%, and the description adds meaning for indicators and timeframes (defaults, max items, enum lists) but does not explain the 'bars' parameter (integer, default 3, min 1, max 10). Thus, it partially compensates for the lack of schema descriptions but leaves a gap.

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 market snapshot for one symbol including current tick and indicator sets across timeframes, using specific verbs and resources. It distinguishes itself from separate tool calls by consolidating 5-8 calls into one, making its purpose distinct from siblings like get_tick or get_indicator.

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

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

The description explains when to use this tool (e.g., 'Replaces 5-8 separate tool calls') and provides limits and defaults. However, it does not explicitly state when not to use it or mention alternative sibling tools for specific needs like single indicator retrieval or more than 6 indicators.

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?

No annotations provided, so description carries full burden. Disclosures include caching (5 min), error conditions, and capability requirement. Lacks details on rate limiting or pagination, but covers key non-obvious behaviors.

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

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

Two sentences: first states core purpose, second lists requirements and behaviors. No unnecessary words, 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?

No output schema or parameter descriptions in schema. Description covers prerequisites and caching but omits return format and parameter semantics. Adequate but has clear 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 has no descriptions for parameters (0% coverage). Description does not explain 'limit' or 'query' meanings, leaving the agent to infer from names and constraints.

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 verb 'Returns', resource 'recent forex/financial news articles', and source 'NewsAPI.org'. Distinct from sibling tools like get_bars or get_sentiment.

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?

Specifies prerequisites (NEWS_API_KEY, analytics capability) and error states (NEWS_NOT_CONFIGURED, NEWS_UNAVAILABLE). Does not explicitly state when not to use, but provides enough 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?

In the absence of annotations, the description discloses the exact return fields, edge case ('none' status), and required capability. It does not mention rate limits or error behavior, but for a read-only status tool this is sufficient.

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

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

Two clear sentences with no extraneous words. The most important information (what the tool returns and edge case) 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?

Given no parameters, no output schema, and simple read-only nature, the description covers all necessary context: return fields, edge case, and capability requirement.

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?

There are zero parameters, so schema coverage is 100%. The description adds value by explaining the return structure and the capability requirement, exceeding the baseline expectation for a parameterless 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 it returns the news guard configuration with specific fields (enabled state, last poll time, classifier mode, alert count) and handles the 'none' case. It distinguishes from siblings like get_equity_guard_status and set/remove variants.

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

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

The description implies usage for reading status but does not explicitly state when to use this tool vs alternatives like get_equity_guard_status. The context is clear from the name and sibling tools, but no formal usage guidance is provided.

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

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

With no annotations, the description should disclose behaviors like read-only, authentication needs, or rate limits. It only states the function, leaving critical traits unclear.

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 sentence, front-loaded, zero waste. Perfectly concise for the tool's simplicity.

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?

Lacks output format, pagination, or result count. For a list tool in a trading context, this is insufficient for correct agent usage.

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

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

No parameters exist, and schema coverage is trivially 100%. Baseline score of 4 is appropriate as the description adds no parameter info.

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 all pending orders, distinguishing it from get_positions and other order-related siblings. However, it doesn't define what constitutes a pending order or specify order types.

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

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

No guidance on when to use this tool versus alternatives like check_order or cancel_order. Missing context for usage decisions.

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?

With no annotations, the description carries full behavioral burden. It reveals the output format and sorting order, which adds transparency, but does not disclose side effects, permissions, or limitations. The information is useful but incomplete.

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 at two sentences, front-loading the purpose and then providing the output format. Every sentence adds value with no 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 lack of output schema and undocumented date parameters, the description fails to explain the required inputs or fully describe the response structure. The agent lacks key context for correct usage.

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

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

Schema description coverage is 0% and the description does not mention the two parameters (from_date, to_date). This means the agent gets no guidance on parameter semantics from the description, severely hindering correct invocation.

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 'P&L broken down per trading symbol,' which is a specific verb-resource combination. It distinguishes from its sibling 'get_pnl_by_time' by focusing on symbols, 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 implies use when needing per-symbol P&L but provides no explicit guidance on when to use or avoid this tool. No alternatives or exclusions are mentioned, leaving context implicit.

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

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

No annotations exist, so the description must carry behavioral context. It indicates a read operation (via prefix 'get') but does not mention any side effects, required permissions, or rate limits. The description is minimal but not contradictory.

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

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

Two concise sentences with the output format front-loaded. No redundant information, though it could be slightly more efficient by combining.

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 describing the output format, the description fails to cover essential usage context: parameter formats, default behavior, date range constraints, or expected behavior. With no output schema, more detail was 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?

Description provides no information about the parameters. The schema has 0% coverage, and the description does not explain the meaning of 'period', 'from_date', or 'to_date', nor their constraints or defaults.

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 returns P&L bucketed into time intervals and specifies the output format, distinguishing from sibling 'get_pnl_by_symbol' which is per symbol.

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

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

No explicit guidance on when to use versus alternatives. The tool name and description imply time-based aggregation, but no contrast with similar tools like 'get_trade_stats' or 'get_pnl_by_symbol' is provided.

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

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

No annotations provided, and the description only says 'returns all open positions with P&L'. It does not disclose any behavioral traits such as read-only nature, data freshness, or account scope. With zero annotation coverage, the description provides minimal 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 concise sentence with no wasted words. It effectively communicates the tool's purpose 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?

No output schema is provided, so the description should cover return structure. It mentions 'with P&L' but does not detail the format or account scope. Given the simplicity, it is adequate but could be more 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?

There are no parameters, and schema description coverage is 100% (vacuously true). The description does not need to add parameter info, earning a baseline of 4.

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

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

The description clearly states the tool returns all open positions with P&L, using a specific verb and resource. It distinguishes itself from sibling tools like get_pnl_by_symbol and close_position by explicitly stating it returns all 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?

No explicit guidance on when to use vs alternatives. The description implies it is for fetching all open positions, but lacks exclusions or references to other tools for filtered 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?

The description fully discloses behavioral traits: status driven only by loss rules and consistency violation, profit target/min-trading-days never worsen status, failsafe (stale true + block) when terminal unreachable, ~30s sampling loop causing lag, and conservative bands.

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

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

The description is well-structured, front-loading the main purpose, then detailing fields, behavioral notes, and requirements. Every sentence adds value 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 no output schema, the description thoroughly explains all return fields and behaviors, including edge cases like stale data and lag, making it fully self-contained.

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 zero parameters and 100% schema coverage, the baseline is 4. The description adds no parameter information since none exist.

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 decision-ready prop-firm verdict with specific fields (overall status, trade_advice, max_safe_risk_percent, etc.), distinguishing it from sibling tools like set_prop_firm_rules.

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

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

The description implies usage when needing prop-firm status before trading and explicitly requires the 'trade' capability, but does not mention when not to use it 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?

No annotations are provided, so the description carries the full burden. It states that the result is 'Computed server-side from get_interest_rates and get_symbol_info data,' indicating no side effects. However, it does not disclose potential behaviors such as error conditions, performance implications, or what happens if inputs are invalid. The description adds little beyond the basic function.

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

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

The description is two sentences that efficiently convey the tool's purpose and a key requirement. It is front-loaded with the primary function and uses no unnecessary 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 absence of an output schema, the description provides a sufficient but not detailed overview of the return value (rate differential and swap cost). It does not specify the output format, fields, or types. Parameter semantics are also not explained. The description is adequate but leaves gaps for a complete understanding.

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% description coverage, meaning no parameter descriptions. The tool description mentions 'the specified volume' but does not explain the meaning, format, or constraints of the symbol or volume parameters. No additional meaning is added beyond the schema's type and constraints.

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 interest rate differential between the two currencies in a pair, plus the annualised swap cost/credit for the specified volume.' This is a specific verb (returns) and resource (rate differential and swap cost), and it distinguishes itself from siblings like get_symbol_info or get_interest_rates by providing a computed result.

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

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

The description mentions the requirement: 'Requires the `analytics` capability (Team+ tier).' This gives a clear prerequisite. However, it does not explicitly state when to use this tool versus alternatives like get_interest_rates or get_symbol_info, though it implies that if you need the differential directly, use this. No when-not or exclusion guidance is provided.

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

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

The description thoroughly discloses behavioral traits: data quality labels (implied/calendar_only), approximate and delayed nature with flags, caching behavior on failures, and error responses. No annotations are provided, so the description fully carries this burden.

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 concise, packing essential details into a few sentences. It is front-loaded with the main output and each sentence adds value, though it could be slightly 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?

Given the simple parameter and no output schema, the description provides a complete picture of what the tool returns, including data quality and error handling. It is sufficient for the agent to understand the tool's behavior.

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

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

The schema provides an enum but no descriptions. The description adds meaning by explaining that 'currency' can be a single G10 currency or 'ALL' for the full map, which compensates for the 0% 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 that the tool returns the market's expected policy path per G10 central bank, including next meeting, current rate, last decision, and probabilities for USD. This is specific and distinct from sibling tools like get_interest_rates or get_cb_stance.

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

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

The description specifies that the tool accepts a single G10 currency or 'ALL' and highlights that it works independently of the terminal. However, it does not explicitly guide when to use this tool versus alternatives, leaving some ambiguity.

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

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

With no annotations, the description fully bears the burden. It discloses that the tool is a pure scoring function, uses z-scored market inputs, returns a score in [-1,1], includes confidence and missing_inputs fields, and has a condition for returning REGIME_UNAVAILABLE. 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 two sentences: the first conveys the core purpose, and the second adds details on output and constraints. It is front-loaded, efficient, and contains no unnecessary 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 no output schema and no parameters, the description covers the tool's inputs, output components, and constraints (minimum inputs, capability requirement). It is sufficient for an agent to use the tool correctly, though a brief note on the formula might enhance 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?

There are no parameters in the schema (0 params, 100% coverage). The description adds meaning by explaining that the tool uses market inputs internally and describes the output composition, which compensates for the lack of 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 returns a composite risk-on/risk-off score with a specific range, and lists the inputs (VIX, DXY, etc.) and outputs (confidence, missing_inputs, sizing_advice). It distinguishes from sibling tools by emphasizing it is a pure scoring function with transparent per-input drivers.

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

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

The description mentions the requirement of at least 3 available inputs and the need for the analytics capability, but does not explicitly state when to use this tool over alternatives like get_risk_summary or get_behavioral_insights. Usage context is implied but not fully specified.

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 behavioral details: currency exposure logic is FX-specific, results for other asset types are inaccurate, and requires analytics capability. With no annotations, this provides necessary 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?

Two sentences plus a note, very concise. Main action and components front-loaded, limitations and requirements clearly stated 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 no parameters, no output schema, and simple structure, the description fully covers purpose, content, limitations, and prerequisites. Nothing essential is missing.

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

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

No parameters exist so description cannot add schema meaning. Baseline 4 for zero parameters is appropriate.

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

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

Clearly states it returns a portfolio risk overview mentioning specific components (currency exposure, margin, correlated pairs). Differentiates from sibling tools like get_holding_risk and get_risk_regime by specifying aggregate scope.

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

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

Describes when to use (for aggregate risk overview) and notes limitation for non-FX symbols, implicitly guiding the agent to avoid it for indices, cryptos, stocks. Mentions required capability but no explicit alternative 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?

Discloses possible SENTIMENT_UNAVAILABLE response, caching duration, and access requirement. Annotations absent, so description carries full burden and does so thoroughly.

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?

Three concise sentences front-load purpose and key behavioral details with no waste.

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?

Explains return values and special case (SENTIMENT_UNAVAILABLE) adequately, though output schema absent and no error details beyond feed unreachable.

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 parameter is symbol; schema description coverage is 0%, and description adds no guidance on format, examples, or constraints beyond schema.

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

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

Clearly states the tool returns retail trader sentiment for a symbol, including percentages and contrarian signal, differentiating it from sibling tools like get_cb_stance or get_market_snapshot.

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?

Mentions free usage and required analytics capability, but does not explicitly contrast with alternative sentiment sources among siblings.

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

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

No annotations provided, so description carries full burden. Discloses use of daily high-low range (not tick-level data) and flagging logic. Lacks mention of data freshness, side effects (read-only), or error 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?

Three well-structured sentences. Front-loaded with purpose, each sentence adds unique value. No extraneous text.

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 purpose, calculation, and requirements. Omits output format, which may be necessary for agent to interpret the result. Also doesn't specify if data is real-time or delayed.

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 0%, so description must explain parameters. Explains role of threshold_multiplier in flagging condition, but symbol is only mentioned as 'for a symbol' without further detail. Could be more explicit about symbol format.

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 returns current spread vs historical average, explains average estimation method, and flagging condition. Distinguishes from siblings like create_alert/cancel_alert.

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 mentions required analytics capability (Team+ tier). Implicitly suggests use for retrieving alert status rather than creating alerts. Could explicitly state when to use vs alternatives.

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

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

No annotations are provided, so the description carries full burden. It states the tool returns spec data but does not explicitly confirm it is a read-only, non-destructive operation. The listed return fields (lot size, swap rates, digits) add some 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, front-loading the core purpose with no extraneous 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 simple tool with one parameter and no output schema, the description provides sufficient context about the returned data. It could mention error handling or response format but is adequate for basic usage.

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

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

Schema description coverage is 0%, but the description references 'symbol' in context, adding meaning that the parameter is the trading symbol to query. It also specifies what information will be returned for that symbol, compensating for schema verbosity.

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 contract specification (lot size, swap rates, digits) for a given symbol. This distinguishes it from siblings like 'get_symbols' which lists symbols, and other info 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 implies usage for getting detailed spec of a single symbol, but provides no explicit guidance on when to use this tool versus alternatives (e.g., when needing multiple symbols or different info). No when-not-to-use conditions are mentioned.

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

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

No annotations are provided, so the description carries the full burden. It does not disclose behavioral traits such as read-only nature, potential rate limits, or whether authentication is required. For a simple retrieval tool, this is a minor gap.

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 sentence with no waste. It is efficient but could be slightly more informative. Still, it is concise enough.

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 a simple purpose, the description is adequate. However, the lack of an output schema means the agent must infer the return format, which is a minor omission.

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?

There are zero parameters, and schema coverage is 100%. The description adds no parameter details, which is acceptable since none exist. Baseline 4 applies.

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 'returns' and the resource 'all symbols available in Market Watch'. It distinguishes from siblings like 'get_symbol_info' which likely focuses on a single symbol.

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

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

The description implies usage for retrieving all symbols but provides no explicit guidance on when or when not to use this tool over alternatives. However, given the simplicity, it 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?

With no annotations provided, the description carries the full burden. It correctly implies a read-only operation by stating 'Returns', and lists the output fields. Minor omission: no mention of side effects or rate limits, but for a trivial metadata fetch, this is sufficient.

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, well-structured sentence. Every word adds value, and the key elements (verb, resource, fields) are front-loaded.

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

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

Given the tool has no parameters and no output schema, the description fully covers what an agent needs to know: what the tool returns and the specific fields. 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?

There are no parameters, so the schema coverage is 100%. Per guidelines, zero parameters warrant a baseline of 4. The description adds no parameter details but none are needed.

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 uses a specific verb 'Returns' and identifies the resource 'MT5 terminal metadata', listing specific fields (name, company, path, build, max_bars). This clearly distinguishes it from sibling tools like get_account_info or get_symbol_info.

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

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

The description does not provide any guidance on when to use this tool versus alternatives. For a simple read tool, this is acceptable but does not exceed minimal requirements.

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 indicates a read-only query returning current data. However, it does not disclose staleness, update frequency, or any limitations (e.g., only works during market hours). With no annotations, the description carries the burden, but it is adequate for a simple data retrieval 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?

Single sentence, no extraneous words. Every word 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 one parameter, no output schema, and no annotations, the description covers the essential function and return values. It could mention data freshness, but is otherwise complete for a simple 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 description adds no parameter details beyond the schema property name 'symbol'. Since schema coverage is 0%, the description compensates minimally by implying the tool accepts a symbol, but does not explain length constraints or formatting expectations.

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 current bid, ask, and spread for a symbol. It distinguishes itself from siblings like get_tick_history (historical ticks) and get_bars (OHLC data) by specifying 'current' and the exact fields returned.

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 guidance on when to use this tool vs alternatives like get_tick_history or get_market_snapshot. No context on prerequisites, such as whether the symbol must be active or supported.

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?

No annotations are provided, so the description must disclose behavioral traits. It mentions the output shape but lacks details on rate limits, required permissions, or potential performance issues. It is adequate but minimal.

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, with two sentences that directly convey the function and output. No unnecessary words, perfectly 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?

With no output schema and 3 parameters, the description partially compensates by showing the return shape. However, it lacks context on the meaning of 'raw ticks', the relationship between parameters, and any usage examples. It is incomplete for safe invocation.

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

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

Schema description coverage is 0%, so the description should explain parameters. It does not define 'symbol', 'count', or 'from_date' beyond the schema. The output structure is shown, but parameter semantics are missing 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 description clearly states it returns a sequence of raw ticks for a symbol and provides the output structure. It distinguishes itself from sibling tools like 'get_tick' (singular tick) and 'get_bars' (candlesticks).

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 does not specify when to use this tool versus alternatives. While the purpose is clear, there is no guidance on constraints (e.g., applicable time frames) or comparison with similar tools like 'get_tick' or 'get_bars'.

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?

With no annotations provided, the description must disclose behavioral traits. It only states it returns closed trades and optional date range, but does not mention pagination, rate limits, or any side effects.

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 concise sentence with zero waste. However, it lacks structure such as listing parameters or clarifying optionality.

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 3 parameters, no output schema, and no annotations, the description is incomplete. It does not explain return format, pagination, or behavior beyond the date range filter.

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 0%, so description needs to add meaning. It explains that from_date and to_date are for date range filtering, but does not describe the 'limit' parameter. This partially compensates.

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 closed trades with an optional date range filter. It uses specific verb 'returns' and resource 'closed trades', but does not differentiate from sibling tools like get_positions or get_orders.

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

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

No guidance is provided on when to use this tool versus alternatives. There are many sibling tools, but no mention of context or exclusions.

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

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

No annotations are provided, and the description does not disclose behavioral traits such as side effects (e.g., read-only), permissions, or rate limits, which is a significant gap for a query 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?

A single sentence that front-loads the main purpose and lists output metrics concisely, though the list is somewhat lengthy; overall efficient but could be slightly improved in readability.

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

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

The description covers output metrics adequately but lacks parameter explanations and behavioral context, making it only partially complete for a tool with 3 parameters and no output schema.

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

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

With 0% schema description coverage, the description does not explain the parameters (symbol, from_date, to_date) or their formats, leaving the agent to infer from names alone.

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 aggregate statistics over closed trades' and lists specific metrics, making the purpose highly specific and distinguishable from sibling 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 no guidance on when to use this tool versus alternatives like get_pnl_by_symbol or get_behavioral_insights, leaving the agent without context 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?

With no annotations, the description carries full burden. It discloses an important behavioral trait: 'last_evaluated_at (stale while the terminal is disconnected — evaluation pauses)'. This adds significant value. However, it does not explicitly state if the operation is read-only, nor does it mention idempotency, rate limits, or authentication requirements. The safety profile is hinted but not fully specified.

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 sentence that efficiently communicates the tool's purpose, return fields, and an important caveat. Every word earns its place; there is no redundancy or filler.

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

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

Given no parameters and no output schema, the description adequately covers what the tool returns and a behavioral caveat. It could mention pagination or ordering, but for a list-all-alerts tool, it is reasonably complete. The critical contextual detail about terminal disconnection elevates it above a bare minimum.

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

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

The input schema has zero parameters and 100% schema coverage. The description does not add parameter-related information (none needed), but it adds context about the return fields, which is beyond parameter semantics. Baseline of 3 is appropriate as the description does not compensate for any missing parameter info.

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 'Lists all alerts for this license', specifying the verb (list), resource (alerts), and scope (for this license). It also enumerates the returned fields, leaving no ambiguity about the tool's purpose. However, it does not explicitly differentiate from sibling tools like create_alert or cancel_alert, though the name and description suffice.

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 guidance on when to use this tool versus alternatives. It mentions 'Available at Pro+ tier', which is a prerequisite, but does not provide when/when-not criteria or reference sibling tools that might serve similar purposes (e.g., poll_alerts for near-real-time updates).

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?

With no annotations, the description provides the key behavioral trait: it returns only EAs on open charts. However, it does not disclose what specific properties (e.g., name, chart symbol) are included in the output or whether the list is a live snapshot.

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 sentence that is front-loaded with the key action and resource. Every word is necessary; no waste.

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 and lack of output schema, the description is nearly complete. It defines the scope (open charts) and resource (Expert Advisors). Minor omission: no mention of output format or whether it includes disabled EAs.

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 no parameters, so baseline is 3. The description adds meaning by specifying the tool's output resource, but does not provide additional parameter-level detail since none exist.

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 all Expert Advisors attached to open charts. It specifies the verb 'Returns' and the resource 'Expert Advisors', and there is no sibling tool that lists EAs, so it is distinct.

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

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

The description implies the tool is used when you need a list of currently running EAs. No exclusions or alternatives are mentioned, but the tool's simplicity and uniqueness among siblings make usage obvious.

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?

With no annotations provided, the description carries full burden. It discloses that the tool modifies pending orders, requires at least one field, defaults to dry_run=true, and needs specific capabilities for live execution. While it doesn't describe the return value or side effects, the mutation intent is clear and no contradictions are present.

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

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

The description is two sentences: first states the action and fields, second adds constraints and live execution notes. Every sentence adds value, with no redundancy. It is appropriately sized and front-loaded.

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

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

Given no output schema and 6 parameters, the description covers the key aspects: modifiable fields, requirement of at least one, dry_run behavior, and live execution prerequisites. It does not explain the return value or potential errors, but it is sufficient for an agent to invoke correctly. Could be slightly improved by mentioning ticket parameter.

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 0%, so the description must compensate. It explains four parameters (price, stop_loss, take_profit, expiry) and their condition, plus dry_run default. However, the required 'ticket' parameter is not explicitly described, and the numeric constraints (exclusiveMinimum, minimum) are not mentioned. The description adds meaning but not full 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 defines the tool as modifying a pending order (price, stop_loss, take_profit, expiry). It distinguishes from siblings like modify_position (which modifies positions) and place_order (creates orders). The verb 'modifies' plus resource 'pending order' is specific and unambiguous.

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

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

The description explicitly states the condition that at least one of the four fields must be provided, and explains the dry_run default and how to execute live. It also notes capability and EA setting requirements. However, it does not explicitly contrast with alternatives like modify_position or when to use other 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?

Discloses default dry_run behavior and the need for specific capability and EA setting. No annotations, so description carries burden; it adequately covers key behavioral aspects 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?

Two concise sentences cover purpose, constraints, and requirements. No wasted words; front-loaded with 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?

Covers key constraints and capabilities but lacks detail on return values, error conditions, or behavior if position is not open. Given no output schema and moderate complexity, more completeness would help.

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% schema coverage, description explains the 'at least one of stop_loss/take_profit' rule and dry_run default, adding value. However, it omits descriptions for ticket and does not fully clarify that stop_loss and take_profit are price levels.

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 modifies stop_loss and/or take_profit of an open position, with specific constraints (at least one required). It distinguishes from sibling tools like close_position or modify_order.

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

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

Provides explicit conditions: at least one parameter required, dry_run default, and required capabilities. Lacks direct comparison to modify_order for pending orders, but context implies this is for positions.

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?

No annotations provided, but description fully covers behavior: dry_run behavior, error cases, and required capabilities (trade capability and inp_AllowTrading=true). 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?

Three concise sentences, all valuable information; front-loaded with main purpose.

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 3-parameter tool with no output schema, description is complete: explains behavior, error conditions, and prerequisites.

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

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

Although schema coverage is 0%, description explains volume constraint (must be less than full position) and dry_run default, adding meaning beyond schema's constraints.

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 closes a portion of an open position, distinguishing it from full close tools like close_position.

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

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

Provides clear when-to-use and conditions (volume must be less than full volume, dry_run default, and how to execute live). No explicit when-not-to-use alternatives, but context 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?

No annotations provided, so description bears full burden. It discloses dry_run default, expiry constraint, and required permissions—adding significant behavioral context beyond schema. Lacks details on error handling or return value 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?

Two sentences, zero waste, front-loaded with purpose. Highly concise and structured logically.

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 10 parameters, no output schema, and no annotations, the description covers essential behavioral details but omits return values, error handling, and documentation of many parameters. Adequate but not complete.

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

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

Schema description coverage is only 10% (expiry only). Description adds meaning for dry_run (defaults true) and expiry (pending-only). But other parameters (magic, price, stop_loss, etc.) are not explained. Compensates partially but not fully for low 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 tool places a market or pending order on MT5, using a specific verb and resource. It distinguishes from sibling tools like modify_order, cancel_order, etc., by focusing on order placement.

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

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

Provides clear context: defaults to dry_run=true, set false to live trade, expiry for pending orders, and requires trade capability and EA setting. However, no explicit when-not-to-use or comparison with alternative order-placing tools is given.

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?

Despite no annotations, the description fully discloses behavior: drains oldest first, marks delivered, retains events for 7 days, and explains the include_delivered effect. 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?

Three sentences, highly efficient. Main action is front-loaded, and every sentence adds essential information 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?

Covers purpose, behavior, returned fields, retention, usage guidance, and tier. No gaps given the tool's simplicity and lack of output schema.

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

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

With 0% schema coverage, the description adds value by explaining include_delivered to see retained history. The single parameter's purpose is well clarified.

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 drains undelivered fired-alert events, marks them delivered, and describes the content of each event. It distinguishes itself from siblings by focusing on draining/polling rather than creating or listing alerts.

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 calling periodically because alerts are pull-based, and mentions the optional include_delivered parameter for viewing history. Also notes the Pro+ tier requirement. Could be improved by contrasting with list_alerts.

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?

With no annotations, the description carries the full burden. It discloses ordering, the conditional inclusion of realized_pnl based on terminal connection, and the tier availability. This provides useful behavioral context beyond the schema.

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

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

Two sentences with no extraneous content. The first sentence immediately conveys the core purpose and ordering, and the second adds behavioral details and tier. Every sentence earns its place.

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

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

Given 8 parameters and no output schema, the description covers ordering, filters, a behavioral note about realized_pnl, and tier. It lacks pagination details and output format, but provides enough context for a query 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?

Only 25% of parameters have schema descriptions, but the description adds meaning by listing the filters and specifying that 'search' is case-insensitive. This compensates for the low coverage, though details on limit and offset are missing.

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 queries trade journal entries with ordering (newest first) and lists filters. It does not explicitly differentiate from sibling tools like 'get_journal', but the purpose is specific enough.

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?

Implies usage for filtering trade journal entries based on provided filters, but gives no explicit guidance on when to use this versus alternatives 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?

With no annotations, the description carries the full burden. It notes a behavioral trait (available=false in sandbox) but does not disclose other traits like read-only nature or potential side effects beyond returning lines.

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

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

Two concise sentences front-load the purpose and add a critical limitation. Every sentence is valuable and there is no fluff.

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

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

Given no output schema and no annotations, the description is adequate for a simple tool but lacks depth. It does not clarify the scope of 'EA log' (which expert) or provide examples, leaving room for ambiguity.

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