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

With no annotations available, the description carries the full burden. It discloses the data source ('stored metrics'), the cardinality ('two or more runs'), and a key non-behavior ('never looks up the latest HTML report'). It does not discuss output format or error cases, but the read-only diff behavior is reasonably 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 short sentences, front-loaded with the core function, followed by a meaningful caveat. There is no redundant fluff or repetition of schema 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 simple single-parameter tool, the description covers the core intent, the required input semantics, and a key behavioral boundary. The only notable gap is that it does not describe what the diff output looks like, but the absence of an output schema and the tool's low complexity make this acceptable.

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 no property descriptions (0% coverage), so the description must compensate. 'Two or more runs' adds meaningful semantics: the run_ids parameter should contain at least two run identifiers, which is not otherwise stated. It doesn't specify ID format, but the parameter name makes that reasonably clear.

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

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

The description clearly states a specific operation ('diff'), a specific resource ('stored metrics'), and scope ('two or more runs'). It also explicitly distinguishes itself from HTML-report lookup, which helps an agent differentiate it from report-oriented 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 clearly implies when to use it: when comparing stored metrics across multiple runs. The caveat that it never looks up the latest HTML report provides an exclusion, but it does not name an alternative tool or describe specific competing workflows.

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 behavioral burden. It does disclose two key traits: external compilation via MetaEditor and a publish side effect to a named destination. However, it stays silent on failure modes, log output, whether artifacts are overwritten, and the ability to compile without publishing via the publish=false option.

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 no filler. It identifies the action, resource type, mechanism, and destination efficiently, which is ideal for a tool-level summary.

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 five-parameter build tool with no output schema and no annotations, this description is not complete enough. It omits expected return/status information, workflow placement relative to backtesting or validation, side effects of publishing, and error behavior. An agent can invoke the tool from the schema but cannot reliably predict the outcome.

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 only clarifies `source` by restricting it to .mq5/.mq4 files. The remaining parameters — `include`, `publish`, `log_file`, and `timeout_sec` — receive no semantic explanation, so the agent must rely solely on names and 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?

The description states a specific action ('Compile') on a well-defined resource type (.mq5/.mq4 source), names the tooling (MetaEditor), and gives a clear destination ('Experts/TradeLab MCP'). This differentiates it from sibling validation and testing tools even without cross-references.

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 gives no guidance on when to use this tool versus siblings such as validate_ea_standard or run_backtest. It also does not mention prerequisites, workflow ordering, or cases where compile should or should not be used. Usage context must be inferred entirely from the name and schema.

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 burden, and 'Show' clearly signals a non-mutating, read-only operation. It also sets expectations about the content: capabilities, defaults, and workflow. It does not detail the output format, but for a zero-parameter informational tool that 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?

A single front-loaded sentence with no filler. Every word contributes to scope: 'capabilities', 'defaults', and 'pre-generation workflow'.

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 no-input, no-output-schema tool, the description is sufficient for an agent to invoke it correctly and understand its intended timing. It could more explicitly connect to sibling tools, but no required information 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?

The tool has zero parameters, so the description has nothing to add beyond the empty schema. The baseline of 4 applies because parameter semantics are not relevant here.

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

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

States an explicit verb ('Show') and a clear object ('TradeLab EA capabilities, defaults, and the mandatory pre-generation workflow'). It doesn't explicitly name sibling tools, but the informational intent distinguishes it from planning, validation, and registry tools in the sibling list.

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

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

The phrase 'mandatory pre-generation workflow' implies this should be consulted before EA generation, but it never states when to use this tool versus plan_ea_creation, validate_ea_standard, or ea_registry. The usage context is implied rather than explicit.

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

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

There are no annotations, so the description carries the full burden. It discloses that this is a query over a catalog and that loading sources is avoided, which is useful. However, it does not disclose behavior such as how stale results are handled, whether refresh_if_stale is honored, or what the query syntax is. The refresh_if_stale=true default is a behavioral signal that is not explained.

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?

One sentence, front-loaded with the core action and the reason for using it. Every word earns its place.

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

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

The tool has two parameters, no annotations, no output schema, and 0% schema coverage. The description is too minimal for an agent to know the query semantics, the refresh behavior, or the return shape. Given the sibling tools include refresh_ea_registry and ea_capabilities, more guidance is needed to avoid conflating them.

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 explain either parameter ('query' or 'refresh_if_stale'). The description only mentions the catalog query in general terms, so an agent cannot know what query format is expected, whether 'query' is a search string or filter object, or what refresh_if_stale=true actually triggers.

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 ('Query') and resource ('compact EA catalog'), and adds a clear scoping reason ('without loading every .mq5 source into the AI context'). It conveys what the tool does, though it does not explicitly differentiate it from the sibling refresh_ea_registry or ea_capabilities.

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 when to use this tool: when you want EA information without loading many source files. It does not explicitly state when to use alternatives, such as refresh_ea_registry (to refresh) or ea_capabilities (for capabilities), but the practical context is reasonably clear.

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

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

With no annotations provided, the description carries the full burden. It discloses that the tool loads several artifact types, suggesting a read-only retrieval operation, but it does not mention behavior for missing run_ids, permissions, or side effects. The listed artifacts give useful context beyond the tool name.

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 sentence with no filler. It front-loads the action and enumerates the loaded artifacts in a compact list, giving high information density in minimal space.

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 one-parameter retrieval tool, the description is mostly complete: it states the input (existing run_id) and the output content categories. It does not describe return format or error behavior, but those are less critical given the simplicity of the tool and the absence of an output schema.

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

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

Schema description coverage is 0%, so the description must compensate. It adds the meaningful qualifier 'existing' to run_id, clarifying that the parameter must reference an already-created run. However, it does not explain the expected format, origin, or how to obtain a valid run_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?

The description uses a specific verb ('Load') and names concrete resources: manifest, config, metrics, files, and errors. It clearly targets an existing run_id, making the tool's purpose understandable, though it does not explicitly distinguish itself from siblings like get_trades or compare_runs.

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 phrase 'for an existing run_id' implies the tool should be used after a run has been created and cannot be used for a new run. However, it provides no explicit guidance on when to prefer this over sibling retrieval tools like get_trades or compare_runs.

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 present, so the description carries the full disclosure burden. It hints at a read-like operation and mentions 'normalized' output, but it does not explain what 'normalized' means, whether trades can be empty or paginated, what fields are returned, or any other behavioral characteristics such as performance or prerequisites.

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 no filler. It is efficient and easy to parse, though it is arguably too terse to fully guide an agent's decision-making.

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 no output schema and no annotations, the description is thin. It identifies the input and a general return category, but leaves the agent without enough information about the result shape, normalization rules, or edge cases. The presence of several run-related sibling tools makes the missing comparison guidance more significant.

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 compensate. It adds the semantic link 'trades for a run_id', which clarifies that run_id identifies the run whose trades are requested. However, it does not explain the expected format or origin of run_id, nor what counts as a 'trade' in the normalized output.

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 the specific verb 'Return' and a clear resource, 'normalized trades', scoped to a run_id. This distinguishes it from siblings like get_run or compare_runs at a basic level, though it does not explicitly differentiate itself from get_run beyond the word 'trades'.

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

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

The intended use is implied: call this tool when you want normalized trades for a specific run_id. However, there is no explicit guidance about when not to use it, how it compares to get_run or compare_runs, or whether it is appropriate for certain run types.

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 must carry the behavioral burden. The word 'Verify' suggests a read-only diagnostic rather than a mutating operation, and the listed components clarify the scope. However, it does not explicitly state that no changes are made, what a successful verification looks like, or how results are reported.

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 compact sentence that front-loads the action and then enumerates the exact verification targets. Every word contributes meaning, with no filler or redundancy.

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

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

For a simple no-argument health check, the description adequately enumerates what is verified across the environment. It does not explain return values, but there is no output schema and the main missing piece—when to use it—is already penalized under usage guidelines.

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

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

The tool has zero parameters, so parameter-level documentation is unnecessary. Per the rubric, a no-parameter tool gets a baseline of 4; the description adds no conflicting parameter information.

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 ('Verify') and names the resource scope: MT5 install, MetaEditor, terminal, data dir, Experts, Tester, and build. It is clear what the tool checks, but it does not differentiate itself from sibling validation tools such as validate_tester_ini or validate_ea_standard.

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?

There is no guidance on when to run this health check versus the many sibling tools, nor any mention of prerequisites or whether it should be run first. The usage context is only implied by the tool name and the generic verification wording.

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?

'Force-kill' explicitly surfaces that this is a non-graceful, destructive operation, which is useful because no annotations are provided. However, it does not disclose side effects, irreversibility, or what happens to running tasks or processes, so the description carries only part of the behavioral 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 one short, front-loaded sentence with no filler. Every word contributes: it names the action, the resource, and the scope.

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 zero-parameter utility, the description provides the essential context: what gets killed and against which configuration. It stops short of describing side effects or return value, but the low complexity and clarity of the destructive action make the omission non-critical.

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 the schema is complete, so there is nothing to document. The phrase 'for the configured edition' clarifies that the target is determined by existing configuration rather than call arguments, which is still useful.

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

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

The description clearly states a specific destructive action (force-kill) on a specific resource (terminal processes) with a scope qualifier (configured edition). It is immediately distinguishable from siblings such as list_terminals, select_terminal, and health, which are inspection or configuration operations.

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 gives no information about when to invoke this tool, what conditions justify a force-kill, or whether it should follow select_terminal or replace a graceful shutdown. There are no exclusions or alternatives mentioned, leaving the agent without decision 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 present, the description carries the behavioral disclosure burden. It clearly conveys a read-only enumeration operation over a specific filesystem path. It does not detail edge cases or output formatting, but for a zero-input list tool the core behavior is transparently stated.

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 that leads with the action verb and contains no filler or redundant information. 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?

For a tool with no parameters and no output schema, the description provides the essential operational context: what is enumerated and where. It could add the expected return shape (e.g., a list of absolute paths) or clarify behavior when APPDATA is unavailable, but these are minor gaps for such 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 input schema has zero parameters and schema coverage is 100%, so there are no parameter semantics for the description to clarify. The 0-parameter baseline of 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 states a specific verb ('Enumerate'), a clear resource ('MetaTrader terminal data folders'), and a precise location ('%APPDATA%\MetaQuotes\Terminal'). It is immediately distinguishable from siblings like select_terminal or kill_terminal because it only lists folders and does not act on them.

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

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

The description implies the tool should be used when the agent needs to discover installed MetaTrader terminal data folders. However, it does not explicitly mention when to prefer this over select_terminal or any other sibling, nor does it state any 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, the description carries the full burden of behavioral disclosure, but it only says the tool does a registry lookup and records a decision. It does not clarify side effects, idempotency, failure behavior, or what the decision record contains. The write implication of 'record' is present but too vague to understand consequences.

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 no filler. It is appropriately concise, though the brevity comes at the cost of content needed in other dimensions.

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 11 parameters, no annotations, and no output schema, this description is far too thin. It omits return values, error conditions, and how the mandatory registry lookup and decision record connect to the rest of the EA workflow.

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 mentions none of the 11 parameters. Parameters like setup, filters, exit_rule, and signal_bar have no semantic guidance beyond their names and types. This is a severe gap for an agent trying to construct a valid call.

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 gives the tool a role: a mandatory pre-step that performs a registry lookup and records a decision before EA creation or modification. It names verbs and a resource, so it is not a tautology. However, what the tool actually does is ambiguous—'decision record' is undefined, and the operation could easily be confused with ea_registry.

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 tool is mandatory before generating or modifying an EA, which tells an agent when to call it. It does not name alternatives or state when not to use it, but the 'before generating/modifying' condition provides clear contextual 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 behavioral disclosure burden. It does explicitly state that the tool rebuilds two specific files, indicating a write/mutation operation. However, it does not disclose side effects such as overwriting manual edits, prerequisites like compilation, or whether the process is safe/idempotent. The core behavior is disclosed, but important behavioral nuances are missing.

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 filler. The action ('Rebuild') and resources are front-loaded, followed by the condition. Every word contributes value, making it highly efficient for an agent to parse.

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, no output schema, and no annotations, the description is nearly complete: it states what is rebuilt and when. It could optionally mention what 'EA source' refers to or whether any prior step (e.g., compile) is required, but for a focused registry-refresh command, the essential context is present.

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

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

The input schema has zero parameters, so there is no parameter semantic burden. The description does not need to explain parameters, and the '0 params = baseline 4' rule applies. The trigger condition 'after an EA source changes' covers the only contextual input the agent needs.

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 ('Rebuild') and names the exact resources it acts on ('experts/registry.json and REGISTRY.md'). It also includes a trigger condition ('after an EA source changes') that clearly distinguishes it from the sibling tool 'ea_registry', which likely reads or displays the registry. This leaves no ambiguity about what the tool does.

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

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

The description provides a clear usage context: run this tool after an EA source changes. This tells the agent when to invoke it and implicitly separates it from read-only registry access tools. It does not explicitly mention alternatives or exclusions, but the trigger condition is sufficient guidance for a zero-parameter maintenance command.

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 behavioral burden, but it only says the tool runs and stores a backtest. It does not disclose side effects like terminal selection, disk usage, blocking behavior, timeouts, or what the run_id means operationally. The 'store' behavior is a small positive, but important behavioral traits are missing.

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 single sentence is efficient and front-loaded with the core action, but it is under-specified for a tool with 11 parameters and meaningful behavioral complexity. Conciseness alone is not enough when so much operational context is absent.

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?

This tool has high parameter count, no output schema, no annotations, and many related siblings, yet the description covers only the basic action. It fails to explain return values, how run_id is used, prerequisites, failure modes, or any relationship to the broader backtest workflow.

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 there are 11 parameters, but the description adds no meaning to any parameter. There is no mention of date formats, symbol/timeframe expectations, deposit defaults, inputs object, or timeout semantics, so an agent has almost no help beyond raw property names.

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

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

The description states a specific action ('Run'), a specific resource ('one official MT5 Strategy Tester backtest'), and a concrete outcome ('store it under a unique run_id'). This clearly differentiates it from sibling tools like run_batch or walk_forward at a high level, even without naming them.

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

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

No guidance is given about when to use this tool versus alternatives such as run_batch, walk_forward, or smoke_test. The word 'one' implies a single backtest, but there is no explicit context about prerequisites, sizing, or selection criteria.

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 transparency burden. It discloses sequential execution and per-asset run IDs, but omits side effects, failure behavior, results handling, and timeout/resource implications.

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 short sentences carry high signal with no redundancy. The main verb and resource are front-loaded, and the additional run_id behavior 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 11 parameters, no output schema, and no annotations, this description is too thin for an agent to call the tool confidently. Missing parameter semantics, result retrieval, and failure/cleanup behavior are significant 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%, and the description only loosely clarifies the roles of 'strategy' and 'symbols'. It does not explain the required period/date fields or the optional parameters such as model, deposit, currency, leverage, and timeout_sec.

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

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

The description clearly identifies the action and resource: run a given strategy sequentially across multiple symbols. The 'Each asset gets its own run_id' clause adds useful output semantics, though sibling differentiation is implicit rather than explicit.

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 natural use case—batch execution of one strategy over multiple symbols—but it gives no explicit guidance about when not to use this tool or which sibling alternative (e.g., run_backtest, walk_forward) to choose instead.

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

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

With no annotations provided, the description carries the full behavior disclosure burden. 'Switch' implies a state-changing operation and 'for this session' implies non-persistence, but the description does not explain what happens when parameters are null, whether validation occurs, or what side effects changing the active terminal may have.

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 no filler or redundancy. It earns its place by conveying the core action and scope, though it is quite terse.

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 four optional parameters, no output schema, and no annotations, this description is incomplete. It leaves ambiguous how to specify the terminal, what the result of switching is, and what happens with invalid or missing input, making correct invocation unlikely without external knowledge.

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 explain any of the four parameters (hash, origin, edition, install). An agent has no way to know how these parameters identify a terminal, which combination is required, or what defaults mean beyond the schema's bare values.

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

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

The description states a specific verb and resource: 'Switch the active terminal data folder for this session.' It clearly indicates what the tool does and adds session scoping, but it does not explicitly differentiate itself from sibling tools like list_terminals or kill_terminal.

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 only usage hint is 'for this session,' which implies a temporary, session-scoped action. There is no guidance about when to choose this tool over alternatives, no prerequisites, and no mention that list_terminals should be called first to discover available terminals.

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?

There are no annotations, so the description carries the burden of explaining side effects. It discloses the high-level pipeline and journal scanning, but it does not mention deployment/terminal modifications, process creation, cleanup behavior, or what the journal scan actually does with findings.

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, front-loaded sentence with no filler. It is concise, though the brevity sacrifices important behavioral and parameter context.

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

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

With 11 parameters, no output schema, and no annotations, this description is not complete enough. It defines the basic stages but leaves the agent without parameter semantics, expected output/return values, or failure behavior.

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

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

Schema description coverage is 0% and the description explains none of the 11 parameters. Even the required 'source' parameter is only loosely associated with 'compile/deploy', and fields like model, period, from_date, to_date, expert_name, and timeout_sec are entirely unexplained.

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 specific verbs—compile, deploy, run, scan—and names the resource (a smoke test over an EA source). It implies a multi-stage workflow that distinguishes it from a plain backtest or compile, although it does not explicitly contrast with run_backtest or compile.

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 'short official tester pass' and the tool name imply it is for quick verification, but the description does not explicitly state when to use smoke_test versus run_backtest, run_batch, or walk_forward. No exclusions or alternative routing are 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 must disclose behavioral traits itself. 'Check that' implies a read-only validation, but it does not state whether the tool parses source, requires a compiled EA, or returns pass/fail diagnostics, so agents lack key behavioral expectations.

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 no filler, and it packs the core purpose and scope efficiently. Slightly more detail would be welcome, but conciseness itself is strong.

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 one-parameter validation tool, the description omits the meaning of the source parameter, any usage context, and behavioral outcomes. This leaves a capable agent to guess at invocation details and expected 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 coverage is 0% and the description never mentions the 'source' parameter or what format it expects. The phrase 'an EA' weakly implies source identifies the EA, but this is not explicit enough to reliably populate the required string parameter.

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

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

The description names a specific verb ('Check') and resource ('an EA'), and lists precise aspects being validated: guarded TradeLab stop, sizing, metadata, and bar helpers. This distinguishes it from validate_tester_ini and other siblings focused on terminal/runtime tasks.

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 given about when to use this tool instead of validate_tester_ini or other validation/compile siblings. The intended context must be inferred entirely from the tool name and the list of checked features.

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 present, so the description carries the full disclosure burden. It mentions validation against official MT5 formats including Leverage=1:100, but does not state whether the operation is read-only, what happens on invalid configs, whether it returns detailed errors, or what output the caller can expect.

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 the main action and resource front-loaded. The parenthetical about Leverage=1:100 adds useful validation context, though it is slightly cryptic.

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 no annotations and no output schema, this description is too thin. It leaves the caller uncertain about parameter semantics, return values, side effects, and how validation results are reported, which are essential for invoking 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 explain the parameters. It indirectly hints that 'config' relates to a tester.ini file, but does not clarify whether config is a file path, raw content, or object, and 'source' is entirely unexplained. This is only minimal compensation for the schema 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 names a specific verb ('Sanity-check'), a concrete resource ('a tester.ini'), and the standard against which it validates ('official MT5 formats'). It is distinguishable from siblings like validate_ea_standard by the resource type, though it does not explicitly name sibling alternatives.

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 have a tester.ini file to validate before running tests or backtests. However, it provides no explicit when-to-use guidance, no exclusions, and no mention of alternatives among the sibling tools.

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

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

With no annotations, the description carries the full burden, but it only discloses that the tool executes a sequence of official tester runs. It does not mention long execution time, side effects, required setup, failure modes, or how IS/OOS windows are scheduled.

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 one compact, front-loaded sentence with no filler. It sacrifices completeness but remains clean and easily parsed.

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 14 parameters, no output schema, and no annotations, a single conceptual sentence is insufficient. An agent would not know what results to expect, what inputs are needed beyond the obvious, or how the walk-forward windows relate to the date parameters.

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 for the 14 parameters, but it only hints at is_days/oos_days through 'IS/OOS windows.' Required params like strategy, symbol, timeframe, and dates are not connected to usage, and optional params like model, inputs, deposit, and step_days are entirely unexplained.

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 identifies walk_forward as a walk-forward procedure composed of official tester runs with IS/OOS windows, which is a specific concept distinct from a plain single backtest. It lacks an explicit verb and doesn't name a sibling, but the core purpose is recognizable.

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?

There is no guidance about when to use this tool instead of run_backtest, run_batch, or other siblings. The description only defines what walk-forward is, not the conditions or prerequisites for choosing it.

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