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

With no annotations at all, the description carries the full disclosure burden. It does valuable work explaining the return contract (per-scenario CEP deltas, verdict values, and how to interpret 'mixed' as a trade-off), but it never says whether the patch is persisted or purely experimental, how many runs are executed, or whether the operation is expensive or read-only in effect.

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

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

Front-loaded with the action, followed by the A/B definition, the return contract, and one interpretive caveat. Every sentence adds information an agent would otherwise have to guess, and nothing is repeated from the schema.

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?

There is no output schema, and the description compensates by describing the result shape and verdict vocabulary. But for a 4-parameter tool with a nested free-form object and zero schema coverage, the failure to explain presets/scenarios scoping or whether the patch is persisted leaves real gaps for correct 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 must compensate. It explains config_patch well with a JSON merge-patch example, but 'presets', 'scenarios' and 'seeds' are never described in either place — the agent cannot tell that presets/scenarios select the comparison set or that seeds is a repetition count (default 5).

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 a specific verb and resource ('A/B test a configuration change across scenarios on identical seeds') and defines exactly what A and B mean in terms of the config_patch. It doesn't explicitly distinguish itself from the similar-sounding sibling compare_filters, so the agent must infer the boundary, but the core action is 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?

Implicit guidance: it's clearly for evaluating a proposed config change against current defaults on comparable seeds. However, there is no explicit when-to-use/when-not, no mention of the alternative paths (editing config via engine_config, or single-scenario validation via simulate_scenario), and no note about cost/runtime relative to a single simulation.

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. It usefully discloses that results are averaged over seeds and that scenario_overrides is a JSON merge patch where null deletes a key, but it omits return format, how many seeds are used by default, and what config_patch changes.

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 short and front-loaded with the core computation, followed by a compact example for the most unusual parameter. It avoids waste, though it could mention returned metrics or defaults more explicitly.

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 comparison tool with no annotations and no output schema, this is only minimally complete. The scenario_overrides behavior is well covered, but config_patch, return structure, and sibling differentiation are 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?

Schema description coverage is 0%, so the description should compensate for five undocumented parameters. It explains scenario_overrides well and implies the roles of scenario, filters, and seeds, but leaves config_patch and the expected filter-name format 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 states a specific computation: mean CEP50, CEP95, and convergence across several filters on one scenario, averaged over seeds. This is more specific than a bare verb, but it does not distinguish the tool from the sibling ab_test, which may also compare configurations.

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?

Usage is implied by the scenario_overrides example: vary one fault to test a hypothesis. The description does not say when to choose compare_filters over ab_test or run_regression, nor does it state prerequisites such as needing a scenario name.

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 full behavioral burden. It implies a read of venue metadata but does not explicitly say it is read-only, whether it errors for unknown venues, or what the response structure looks like.

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 short and front-loads the returned fields without wasted words. However, it is a sentence fragment rather than an action-oriented statement, which slightly weakens clarity despite the brevity.

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 annotations, no output schema, and no documented parameters, the description leaves important gaps. It tells the agent what venue attributes are involved but not what it receives, whether the call is safe, or how to supply the required venue argument 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%, and the sole parameter 'venue' has no type description beyond being a string. The example 'office_floor' gives a hint about the expected identifier format, but the description does not name the parameter, explain how to obtain valid values, or clarify whether it is a name, ID, or path.

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 enumerates the venue attributes returned (floor size, wall count, attenuation, beacon positions), which makes the resource clear. However, it is a noun phrase with no verb and does not explicitly state that the tool retrieves or describes a venue, leaving the action implicit from the name.

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 use this tool, what it requires, or how it relates to any sibling tool. The sibling list is about scenarios and runs rather than venue metadata, so there is little opportunity for confusion, but the description still provides no usage context.

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

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

With no annotations, the description carries the full burden. 'Effective ... configuration' implies a computed read, and the merge-patch behavior is disclosed, but the ambiguity that matters is left open: is the patch applied persistently or is this a preview? Nor does it confirm the operation is non-destructive. Useful context, meaningful 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?

Two sentences, no filler, with the core function stated first and the workflow hint second. Every clause contributes either scope, valid values, or a usage rule.

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 two-parameter tool with no annotations and no output schema, the description covers the input side adequately but omits the return shape entirely. Since the tool's stated purpose is discovering tunable parameter names, a sentence on what the configuration object looks like (nested key paths, units, defaults) would materially help an agent use the result.

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 and only partly does: it enumerates the preset values and labels config_patch a JSON merge patch. It never explains what the presets mean (pf vs ekf vs wcl), gives no patch format example, and does not say what a null patch yields. The enum-like preset list is the main value added.

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?

Names a specific resource (effective engine configuration) scoped to a preset, and enumerates the four valid presets inline (pf, pf-nomap, ekf, wcl), which the schema does not. It also states the merge-patch capability. It stops short of explicitly differentiating itself from siblings like simulate_scenario or list_scenarios, but the verb+resource pairing is 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 second sentence gives a concrete use case and a sequencing rule: call this to discover tunable parameter names before writing a config_patch. That is real routing guidance rather than a restatement. It does not name an alternative tool or state when not to use it, so it falls short of a 5.

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

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

No annotations are provided, so the description carries the full burden. It does usefully disclose the return structure (windows, peak true/estimated position, nearest beacons), which substitutes for the missing output schema. However, it says nothing about it being a read-only diagnostic, the cost of the computation, or how the defaults behave, leaving meaningful behavioral gaps.

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 filler, and the core output shape is front-loaded before the use case. Every clause adds 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?

Adequate but with clear gaps for a 3-parameter tool with no annotations and no output schema. The return shape is covered, but the required run_id is unexplained, the two tuning parameters lack units/defaults, and the tool's position relative to the other nine diagnostic siblings is unstated.

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 carry parameter meaning, and it only partially does. "Above a threshold" and "time windows" loosely map to threshold_m and min_duration_s, but no units, defaults (3 m, 1 s), or filtering semantics are given. run_id, the sole required parameter, is never mentioned at all.

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 specifies the resource precisely: time windows where error exceeded a threshold, with true/estimated positions at the peak and nearest beacons. An agent can distinguish this from plot_run or compare_filters because the output shape (threshold-crossing windows, peak positions) is stated. It falls short of 5 because it never explicitly says this analyzes a single run's error trace, nor names which sibling it competes with.

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?

"Useful for spotting moved beacons and divergence" gives a purpose but no when-to-use versus alternatives and no exclusions. Nothing tells the agent whether to reach for this or for plot_run / compare_filters / run_regression when diagnosing error. Usage is implied by context only.

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

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

With no annotations, the description carries the full behavioral burden. 'List' implies a safe read, and it does disclose what each result contains, but it says nothing about whether all scenarios are returned, whether results are ordered, or how large the catalog can get.

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 verb and resource, with the return contents appended rather than buried. Nothing redundant.

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 read tool with an output schema covering return values, the description gives what an agent needs: what is listed and what each item includes. Only the lack of any volume/ordering note keeps it from 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 tool takes zero parameters, so there is nothing for the description to disambiguate. Baseline 4 applies; the schema is fully described and requires no narrative support.

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 a specific verb ('List') and resource ('simulation scenarios'), and adds what each entry carries (venue + injected real-world effect). This is clearly a catalog read, distinguishable in kind from simulate_scenario or run_replay, though the description never names a sibling to sharpen that contrast.

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?

Usage is only implied: a parameterless list reads naturally as a discovery step before simulate_scenario or run_replay, but the description never says so or mentions any alternative. No when-not-to-use guidance is offered.

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 output artifact (PNG) and what is visualized, which is useful, but does not state whether the tool writes a file or returns bytes, whether it is read-only, or what happens if the run_id is invalid.

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 unnecessary words. The key output format ('PNG') is included without burying the 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 simple one-parameter plotting tool, the description covers what is rendered and the output format. However, it omits the meaning and sourcing of run_id and any indication of error behavior, leaving a noticeable gap for correct 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% for the single required parameter 'run_id', and the description does not explain what a run_id is or where to obtain one. The parameter name is somewhat self-explanatory, but the description adds no semantic meaning beyond the schema.

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

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

The description uses a specific verb ('Render') and names the exact resource and outputs: floor plan with true and estimated tracks plus error over time, as a PNG. This clearly distinguishes it from siblings like error_breakdown or compare_filters.

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?

Usage is implied: you render after a run exists, but the description does not say when to choose this over error_breakdown or other diagnostic tools. No prerequisites or exclusions are stated.

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 does disclose real scope ('every scenario and preset'), which signals a broad, expensive operation, but says nothing about runtime, whether failures abort the run, what artifacts are written, or whether it mutates any state. Too thin for an unannotated whole-suite execution 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?

One sentence, front-loaded with the action and immediately scoped. No filler. It is efficient, though the terseness is partly the cause of the gaps elsewhere.

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?

A whole-suite accuracy gate with no output schema and no annotations needs the description to explain the pass/fail contract and the seed parameter. Neither is covered, so the agent cannot predict the result shape or the cost of a larger seed count.

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 single parameter 'seeds' has 0% schema description coverage and is never mentioned in the description. The agent must guess that increasing seeds means more repetitions per scenario and what the cost tradeoff is. One undocumented parameter pulls this below the zero-param baseline.

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

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

Specific verb+resource: it runs the CI accuracy gate over every scenario and preset against a named baseline file. That clearly separates it from simulate_scenario, run_replay and ab_test, which operate on targeted cases. It stops short of naming a sibling, but the scope statement does the differentiation work.

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?

'CI accuracy gate' implies the when: an all-up correctness check rather than an exploratory run. No explicit exclusion, no statement of when a targeted replay/simulation is preferable, and no prerequisite is stated. Usage is inferable but not spelled out.

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 does useful work: it discloses that simulation happens in memory and that results come back as metrics plus a reusable run_id. It does not say whether artifacts are persisted for plot_run, what happens on invalid filter/scenario, runtime cost, or whether a single sample is noisy beyond the hint that one run is one sample.

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 short sentences, front-loaded with the action, followed by outputs then the usage caveat. No 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?

All 7 parameters are undocumented in the schema and mostly unaddressed in the description, with no output schema and no annotations to fall back on. For a 7-parameter entry-point tool that gates the rest of the workflow, this leaves too much for the agent to guess.

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% across 7 parameters, so the description carries the full burden, yet it only touches scenario, trace, and filter. It says nothing about seed (presumably reproducibility), venue, config_patch, scenario_overrides, or the mutual exclusivity/defaults between scenario and trace.

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 a specific verb and resource: run one scenario (in-memory simulation) or a recorded trace file through a filter. It also implicitly scopes this as a single-sample run, which separates it from the aggregate siblings ab_test and compare_filters.

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

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

Explicitly says 'One run is one sample: use ab_test or compare_filters for conclusions', naming the alternatives and the condition that selects them. It also names error_breakdown and plot_run as downstream consumers of run_id. It does not clarify when to pick scenario vs trace input, though that is arguably a parameter-level choice.

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, yet it only says a trace is generated. It does not disclose whether files are written to disk, whether the operation is deterministic with a seed, whether an existing scenario is required, or what the output looks like. For a generator with mutation-like side effects, this is a significant 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 short, front-loaded with the core action, and the override examples earn their place by clarifying merge behavior. The second sentence is slightly dense but not wasteful.

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 three parameters, no annotations, no output schema, and zero schema descriptions, the definition is incomplete. An agent knows what is generated but not what inputs mean, where the output goes, or what side effects occur, making correct invocation uncertain.

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 `overrides` object and its merge semantics with concrete examples, but leaves `scenario` (string) and `seed` (integer/null) completely undefined — the agent cannot tell whether `scenario` is an ID, name, path, or JSON payload, nor what the seed controls.

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 and resource: 'Generate a synthetic trace (IMU, BLE, ground truth) for a scenario,' which tells an agent exactly what the tool produces. It does not differentiate from related siblings such as run_replay or ab_test, leaving the agent to infer the boundary.

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 'to test one hypothesis at a time' and the override examples imply an experimentation use case, but there is no explicit guidance on when to use this instead of run_replay, ab_test, or compare_filters. Usage is implied rather than stated.

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