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

Annotations already declare readOnlyHint=false, destructiveHint=false, idempotentHint=false, and openWorldHint=false, so the safety profile is covered. The description adds nothing beyond that: no word on the coordinate system, whether placement auto-routes or renumbers references, or what happens on a duplicate reference.

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, but the brevity here is under-specification rather than disciplined concision for an 8-parameter mutation tool.

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

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

For a write operation with 8 parameters, 3 required, no output schema, and near-zero schema coverage, the definition is far too thin. An agent cannot confidently construct a call from this description plus the bare 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 only 13% (just workspace_root), so the description must compensate and does not. It says nothing about x/y units or coordinate origin, allowed 'kind' values, rotation format, value semantics, or the schematic_path requirement, leaving 7 of 8 parameters 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?

States a specific verb and resource ('place' + 'primitive component'), and 'primitive' hints it is for built-in parts rather than library parts. However, it never distinguishes itself from close siblings such as add_library_component, add_component_from_asy, or add_component_symbol_drawing, so the agent must guess which adder applies.

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 when-to-use, when-not-to-use, or alternative-routing guidance at all. Given that ~10 sibling tools also add schematic elements, this absence is a real selection hazard.

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

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

Annotations declare this is a non-readonly, non-destructive, non-idempotent mutation, but the description doesn't add behavioral context such as what gets created, whether existing components are affected, or what happens on duplicate reference. For an 8-param mutation, this is thin.

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 efficient sentence with no filler. It is appropriately sized, though its brevity contributes to the missing semantics.

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 8 parameters, 3 required, no output schema, and near-zero schema descriptions. The description is far too sparse to tell an agent how to call this correctly, especially versus sibling component-adding tools.

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 13%, so the schema documents one optional param (workspace_root) and leaves seven undocumented. The description mentions only the .asy filename, failing to explain reference, schematic_path, x/y, rotation, or value. It does not compensate for the 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 says it places a symbol using an .asy filename, which is a specific verb and resource, but it doesn't distinguish this from close siblings like add_component, add_component_symbol_drawing, or add_library_component. The purpose is vague relative to the crowded add_component family.

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 versus add_component or add_library_component, no prerequisites or exclusions. The agent must infer selection 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?

Annotations already declare the safety profile (readOnly=false, destructive=false, idempotent=false), so the description only needs to add context. It does add one useful behavioral fact – that this appends rather than replaces, and enumerates the supported shape kinds – but says nothing about which file gets mutated, whether the target must already exist, or what happens on an invalid shape.

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 tight sentence with zero filler and the key noun (the shape kinds) front-loaded. It is efficient, though the extreme brevity leaves no room for the prerequisite/format details an agent actually needs.

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 non-idempotent mutation tool with no output schema and 25% schema description coverage, the definition is too thin: the coords format is opaque, the asy_path contract is unstated, and there is no error or verification guidance. The agent can identify the tool but not confidently invoke it.

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 only 25% (workspace_root alone), so the description must carry the load. It effectively supplies the value vocabulary for 'kind' (LINE/RECTANGLE/CIRCLE/ARC) that the schema leaves as a bare string, but it gives no hint about the 'coords' string encoding or the asy_path target, which is the highest-risk ambiguity 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 a specific verb ('append') and the exact resource being added (LINE, RECTANGLE, CIRCLE, ARC) to a symbol, so an agent knows precisely what the call produces. It stops short of naming or contrasting with the obvious sibling remove_component_symbol_drawing, but the append-vs-remove distinction is inferable from the verb.

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 when-to-use guidance, no prerequisites (e.g. that asy_path must point at an existing .asy symbol file), and no mention of alternatives such as set_component_symbol_pin/text or create_asy_symbol. The agent must infer all routing 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?

Annotations already declare this is a non-readonly, non-destructive, non-idempotent write, so the safety profile is covered. The description usefully adds that a child sheet, In/Out pins, and a parent placement are produced, but it omits failure behavior, whether the parent is mutated in place, or what happens on repeat calls.

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 and the action stated first. It is efficient, though its brevity borders on under-specification for a 6-parameter editing tool.

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

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

For a hierarchical-schematic mutation with 6 parameters, no output schema, and near-zero schema coverage, one sentence is inadequate. An agent is left guessing what reference, x, and y do and what preconditions must hold before the call.

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 only 17% (only workspace_root is documented), so the description must compensate and does not. Terms like 'child sheet', 'In/Out pins', and 'parent' loosely gesture at block_name/schematic_path, but x, y, and reference are never explained in either the schema or the description.

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 ('Create a child sheet'), plus the side effects of adding In/Out pins and placing it on the parent. It is clear what the tool does, but it never distinguishes itself from nearby siblings like add_component or create_schematic, so an agent can't route on the description alone.

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 when-to-use guidance, no prerequisites (e.g. whether a parent schematic must already exist or be loaded), and no mention of alternatives like add_component. The agent must infer usage entirely from the name and title.

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

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

Annotations already declare this is a non-read-only, non-destructive, non-idempotent local mutation, so the safety profile is covered. The description adds nothing beyond that: it does not say the schematic file is modified, that repeated calls append duplicates (relevant given idempotentHint=false), or where the addition lands.

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 short, front-loaded sentence with no filler. It is concise, but the brevity is under-specification rather than efficiency, so it only meets the minimum bar.

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 5-parameter mutation tool with 20% schema coverage and no output schema, the description is far too thin. An agent lacks the information needed to know what gets modified, how x/y are used, or what happens on repeat calls.

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 20% (only workspace_root is documented), so the description is expected to compensate and largely fails. It weakly implies 'text' holds the directive/comment content, but says nothing about schematic_path, x, or y (placement), leaving four parameters undocumented in both places.

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 verb ('Add') and two resource types ('SPICE directive or a comment'), so the basic action is legible. However, it never defines what an 'instruction' is or how directive-vs-comment differs, and it does not distinguish itself from close siblings like add_net_label, add_wire, or remove_instruction.

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 when-to-use guidance, no mention of prerequisites (e.g. an open/valid schematic), and no routing to alternatives such as remove_instruction or the other add_* tools. The agent must infer all of this 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?

Annotations declare readOnlyHint=false, idempotentHint=false, and destructiveHint=false. The description doesn't disclose what happens if a junction already exists at that point, whether it requires an existing wire, or what the response contains. For a mutation tool, this leaves significant 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?

A single efficient sentence with no waste. Front-loaded verb and purpose, though very 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?

A 4-parameter mutation tool with no output schema and low schema coverage. The description doesn't explain coordinate semantics, preconditions (existing wire), or result. This is inadequate for correct invocation without trial and error.

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 25% – only workspace_root is described. The description doesn't explain x/y (coordinate units? grid? relative to what?), schematic_path, or how x/y relate to wire geometry. Since the schema is mostly bare, the description should compensate but doesn't.

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 ('split') and resource ('a wire', 'junction') with the coordinate-based mechanism. It's distinguishable from add_wire and remove_junction by the junction concept, though it doesn't name those siblings directly.

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 when-to-use, when-not-to-use, or alternatives mentioned. An agent must infer that this is for creating electrical junction points where wires cross, vs using add_wire or remove_junction.

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

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

Annotations already declare the safety profile (not read-only, not idempotent, not destructive, closed-world), so the description owes extra context and supplies none. It does not say whether placement overwrites existing components at the same coordinates, whether the schematic must exist first, or what happens on duplicate references.

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, so nothing is wasted, but at this length it is under-specified rather than concise given an 8-parameter mutation tool. The structure is fine; the content volume is the problem.

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 an 8-parameter, non-idempotent mutation with no output schema and near-zero schema documentation, the description is far too thin. It leaves required-parameter meaning, sibling selection, and mutation side effects entirely to inference.

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 13% (just workspace_root), so the description must carry the burden for x, y, value, rotation, reference, symbol_name, and schematic_path — and it adds essentially nothing. The phrase 'by name' loosely hints that symbol_name is the lookup key, but coordinates, rotation format, and reference semantics 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?

States a verb and resource ('Place a library symbol'), which is better than a tautology, but 'library symbol' is not distinguished from the very similar siblings add_component, add_component_from_asy, and add_component_symbol_drawing. An agent cannot tell from the description which of these four to call for a given input.

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 when-to-use guidance and no mention of alternatives, despite the crowded add_component* family in the sibling list. The agent is left to infer that 'library symbol' means a symbol resolved from a library rather than a raw .asy file.

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

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

Annotations already convey the safety profile (readOnly=false, destructive=false, idempotent=false, openWorld=false), so the bar is lower, but the description adds no behavioral context at all. It does not say whether the directive is appended, where in the netlist/schematic it lands, or what validation happens on the paths.

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?

It is a single front-loaded sentence with zero filler, which is good, but it is under-specified rather than appropriately sized. Conciseness is achieved by omission of necessary content rather than by tight editing.

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 is a mutation tool with 33% schema coverage and no output schema, yet the description supplies no return or side-effect information, no path-format expectations, and no note on required workspace context. Given the complexity and the number of sibling edit tools, the description is too thin to call it correctly.

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

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

Schema coverage is only 33%: workspace_root is documented, but the two required parameters (schematic_path, library_path) have no description in the schema and none in the description. The description therefore fails to compensate for the coverage gap on the parameters that actually matter.

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 (add) and object (.lib directive), so the basic operation is identifiable, but the term '.lib directive' is jargon and the description gives no scope (which schematic, what it affects). It also does nothing to distinguish this from siblings like add_library_component or list_includes.

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 when-to-use guidance, no prerequisites (e.g. must the schematic exist first), and no mention of alternatives such as list_includes or resolve_model_libraries. The agent is left to infer everything from the 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?

Annotations already declare readOnly=false, idempotent=false, destructive=false, so the mutation profile is partly covered. The description adds nothing beyond this — no mention of validation, what happens on duplicate directives, permissions, or side effects on the schematic.

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 waste, but its brevity reflects under-specification rather than efficiency — nothing beyond the minimum is conveyed.

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 non-idempotent mutation tool with no output schema and low parameter coverage, the description omits what a .model directive is, where it is inserted, and what success or failure looks like. This is inadequate 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 coverage is low (33%), with model_text and schematic_path carrying no descriptions, yet the description supplies no meaning for any parameter. Names are somewhat self-explanatory, but the description does not compensate for the coverage 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?

States a specific verb (add) and resource (.model directive), which is meaningful in a SPICE context. However, it does not distinguish itself from the closely related sibling set_element_model, 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?

There is no guidance on when to choose this over alternatives such as set_element_model, resolve_model_libraries, or add_library_include, nor any prerequisites or conditions for 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?

Annotations declare readOnlyHint=false, destructiveHint=false, and idempotentHint=false, so the agent knows this is a non-destructive but non-idempotent mutation. The description adds nothing on top of that — no mention of what gets modified in the schematic, whether the label requires an existing wire/net, or how duplicates are handled.

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 short but this is under-specification rather than conciseness. No information beyond the title is conveyed, so the sentence does not earn its place as documentation.

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 5-parameter mutation tool with no output schema and only 20% schema description coverage, the description is completely inadequate. An agent has no basis for supplying correct coordinates, a valid schematic path, or a meaningful net name.

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 20%: just one of five parameters (workspace_root) is documented in the schema, and the description supplies no meaning for x, y, name, or schematic_path. Coordinate units and coordinate space for x/y 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 'Add a net label.' merely restates the tool name and title with no added specificity. It does not distinguish this from siblings like add_wire, add_junction, or remove_net_label, nor does it state what a net label is or where it is placed.

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 when-to-use guidance, no prerequisites, and no mention of alternatives such as remove_net_label or add_wire. An agent must infer entirely from the name when this tool is appropriate.

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

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

Annotations already declare readOnlyHint=false, idempotentHint=false, destructiveHint=false, and openWorldHint=false, so the agent knows this is a non-idempotent, non-destructive local mutation. The description adds nothing on top of that — it does not say what gets mutated, whether the wiring layer must exist, or what happens on duplicate coordinates. With annotations carrying the safety profile, the description is still expected to add context it does not provide.

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

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

It is short, but one of its two sentences is meaningless filler ('Exposed as ``add_wire`` by the tool module'), and the remaining text is too sparse to be useful. This is under-specification rather than genuine conciseness.

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

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

For a six-parameter, non-idempotent mutation primitive with no output schema and almost no schema documentation, the description leaves essentially everything to inference. Nothing an agent needs in order to call it correctly — coordinate semantics, preconditions, side effects — 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?

Schema description coverage is only 17% (only workspace_root is documented) across 6 parameters, five of them required. The description supplies no meaning for x1/y1/x2/y2 — no coordinate units, coordinate space, or orientation — and does not clarify schematic_path versus workspace_root. It makes no attempt to compensate for the low 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 is effectively a restatement of the name and title: 'Add a wire.' It gives no indication of what a wire is in this domain, what it connects, or how it differs from siblings like add_junction, add_net_label, or remove_wire. An agent cannot distinguish the scope of this tool from the other add_* schematic primitives without inspecting the schema.

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 when-to-use guidance, no preconditions (e.g. a schematic must exist or be loaded), and no mention of alternatives such as remove_wire or add_junction. The second sentence, 'Exposed as ``add_wire`` by the tool module,' is an implementation note that carries no invocation guidance.

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

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

Annotations already declare readOnlyHint=false, destructiveHint=false, idempotentHint=false, and openWorldHint=false, so the safety profile is largely covered. The description adds nothing beyond the mutation implied by "replace" — it does not say what happens to the existing layout/content or whether the operation is reversible, and the word "replace" sits in mild tension with destructiveHint=false without clarifying which reading is correct.

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?

It is a single, front-loaded sentence with no wasted words, which is structurally clean. But for a three-parameter mutation tool the brevity reflects under-specification rather than disciplined conciseness.

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

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

For a non-idempotent mutation with no output schema and only one of three parameters documented, the description is too thin: it omits the required parameter, valid spec_name values, and any effect/rollback behavior. Annotations carry the safety profile, but the agent still lacks what it needs to invoke this correctly.

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

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

Schema coverage is only 33% (only workspace_root is documented). The description names no parameters; "built-in layout" only loosely hints at spec_name, and schematic_path — the sole required parameter — is never explained. With low coverage the description needed to compensate and does not.

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 verb (replace) and a resource (schematic) plus the source of the replacement (a built-in layout), so the general intent is inferable. However, "replace a schematic" is imprecise about scope — it reads as overwriting the whole schematic rather than applying a layout spec to it — and it gives no differentiation from the sibling describe_schematic_layout_spec, which an agent must disambiguate against.

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 when-to-use guidance, no prerequisites, and no named alternative. With siblings like describe_schematic_layout_spec and suggest_component_placement, the description leaves the agent to guess when this tool is the right 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?

Annotations already declare destructiveHint=true, readOnlyHint=false, and idempotentHint=false, so the safety profile is covered. The description adds one genuinely non-obvious state-machine rule (a completed batch is a no-op), but omits the more important behavior for a cancel tool: what happens to an in-progress batch, whether partial results are discarded, and whether it requires authorization.

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 action and followed by the one caveat that matters. No filler, no restatement of the tool name.

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 mutation with no output schema this is only adequate. The no-op edge case is covered, but the effect on a running batch, the return value, and batch_id provenance are all absent, leaving meaningful gaps for a destructive operation.

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

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

Schema description coverage is 0%, so the schema documents nothing about batch_id, and the description provides no compensating detail about its format, where to obtain it, or whether it accepts an id from submit_batch. With one undocumented parameter, the description leaves the agent to guess.

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 ('Mark a batch cancelled'), which is enough to know what the tool does. It does not, however, differentiate itself from the adjacent cancel_run sibling, which an agent could easily confuse it 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?

'A finished batch stays completed' implies the useful precondition that cancelling is only meaningful for a non-finished batch. But there is no explicit when-to-use guidance, no mention of the cancel_run alternative, and no statement of prerequisites for obtaining a batch_id.

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

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

Annotations already declare destructiveHint=true, readOnlyHint=false, and idempotentHint=false, so the safety profile is covered. The description adds the scoping fact that it targets a simulation "started for this source path," but says nothing about what is destroyed, whether stopping is synchronous, or whether partial results survive.

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. It is efficient, though arguably terse given the mutation semantics involved.

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

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

For a destructive, non-idempotent operation in a large simulation toolset, the description is thin: no output/return behavior, no interruption semantics, and no linkage to run_simulation or cancel_batch. Annotations cover the safety angle, so this is barely adequate rather than deficient.

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 50% – workspace_root is documented, source_path is not. The description's reference to "this source path" clarifies that source_path identifies the run to cancel, adding useful meaning beyond the bare schema for the required 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?

States a specific verb ("Stop") and resource ("a simulation started for this source path"), so an agent can identify the target run clearly. It does not, however, distinguish itself from siblings like cancel_batch, leaving the run-vs-batch distinction to inference.

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 when-to-use guidance, no prerequisites, and no alternative named. The agent is left to guess whether this applies to only running simulations, what happens if none is active, or how it relates to cancel_batch.

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

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

Annotations already declare readOnlyHint, idempotentHint, destructiveHint=false, and openWorldHint=false, so the safety profile is covered. The description adds a meaningful behavioral constraint—no LTspice execution—but omits return format, what problems are reported, and any side effects or auth needs. With annotations carrying the safety profile, this is an adequate but not rich addition.

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. It is appropriately sized for the amount of information it chooses to convey, though the information itself is incomplete.

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, so the description should explain what the tool returns (e.g., a list of problems, severity, pass/fail). It also omits what structural checks are performed and the expected schematic_path format. Annotations cover safety, but the description is not complete enough for reliable 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 50%, and the description adds no parameter information. The required schematic_path has no schema description and no format guidance in the description, leaving the agent to infer the expected path; the optional workspace_root is documented only in the schema. The description fails to compensate for the coverage 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 states an action ('Report structural problems') and a scope ('without running LTspice'), so the agent can recognize a static schematic checker. However, it never names the resource (schematic) or the kinds of problems checked, and it does not distinguish this tool from siblings such as inspect_schematic or validate_topology_contribution. The purpose is recognizable but vague.

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

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

No explicit when-to-use guidance, alternatives, or prerequisites are given. The phrase 'without running LTspice' implies a static-check scenario, but it does not tell the agent when to select this tool over inspect_schematic or other validation tools.

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

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

Annotations already declare readOnlyHint=false, destructiveHint=false, idempotentHint=false and openWorldHint=false, so the safety profile is covered and the description does not contradict it. The description adds only the scope constraint that the target process was launched by this server; it says nothing about unsaved state, whether the session must be running, or idempotency of a repeated close.

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 zero waste. It is efficient, though arguably terse to the point of under-specification rather than over-writing.

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

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

For a mutation tool with no output schema and an undocumented required parameter, the description leaves key gaps: how the session is identified (schematic_path?), what the caller receives on success, and how it relates to the other live_gui_session lifecycle tools. Annotations cover safety only, so the description should carry more.

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 only 50%: workspace_root is documented in the schema, but the required schematic_path has no description. The description supplies no parameter meaning at all, so it fails to compensate for the undocumented required parameter that presumably identifies which session to close.

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 (stop) and resource (GUI process) with the scoping constraint 'this server launched', so an agent understands it terminates a server-managed GUI. It does not differentiate itself from siblings like close_remote_session or the other live_gui_session tools, which would be needed for a 5.

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 explicit when-to-use or when-not-to-use guidance and no named alternative (e.g. close_remote_session). The phrase 'this server launched' hints at a scope restriction, but the agent is left to infer when closing is appropriate versus leaving the session open.

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

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

Annotations already declare readOnlyHint=false, destructiveHint=false, idempotentHint=false, and openWorldHint=false. The description adds useful context beyond those hints by clarifying that the session is dropped from memory while files on disk remain, which is consistent with destructiveHint=false. It still omits whether closing is allowed during an active run, whether it cancels work, and what authentication or state conditions apply.

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 action and then the disk-preservation effect. Every sentence earns its place and there is 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?

For a simple one-parameter tool with no output schema and four annotations, this is close to adequate. However, it does not explain session_id, nor does it distinguish this from close_live_gui_session or cancel_run, so an agent lacks routing information in a large sibling set.

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 carries the burden of explaining the required session_id parameter. It does not mention session_id at all, leaving its format or expected source undocumented, though the parameter name itself is fairly self-explanatory.

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 a clear verb ('Drop') and resource ('a session from memory'), and it adds the side effect that files on disk are left in place. It does not, however, distinguish this tool from siblings like close_live_gui_session or cancel_run, so an agent cannot tell from the description alone which close/cancel tool is appropriate.

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, no prerequisites, and no named alternatives. The description states a behavioral fact about files but does not help an agent decide between this and other session-ending tools.

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

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

Annotations declare readOnlyHint=false, idempotentHint=false, destructiveHint=false, openWorldHint=false, which is an unusual profile for a retrieval-looking tool. The description does not resolve the tension: it never says whether collecting consumes/removes the stored result, whether repeat calls fail, or what happens if the batch is incomplete. With annotations present but this ambiguity unaddressed, the description leaves real behavioral questions open.

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 short sentence, front-loaded, with no padding. However, brevity here shades into under-specification rather than economy: the one sentence carries almost no actionable content, and "stored" adds no meaning.

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, so the description must convey what is returned, and it does not (result format, size, presence of per-point data). Against a batch toolset with submit_batch, get_batch_status, cancel_batch and summarize_batch as siblings, the description is too thin to place this tool correctly in the 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% for the single parameter batch_id, so the schema itself explains nothing. The description does not compensate: it never says what a batch_id is, its format, or that it comes from submit_batch. This is the one field the agent must supply and it is left undefined.

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?

"Return the stored batch result" names a verb and a resource, so the basic purpose is legible. But "stored batch result" is vague and the description gives no signal to separate this from the closely related siblings get_batch_status, summarize_batch, or submit_batch.

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 when-to-use guidance at all: no statement of the prerequisite (a batch must first be submitted via submit_batch), no indication of whether results are ready, and no named alternative such as get_batch_status for checking progress. The agent must infer the workflow entirely.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true, destructiveHint=false and openWorldHint=false, so the safety profile is fully covered structurally. The description adds no behavioral context beyond that — nothing about what a comparison reports (mismatches vs all values), whether missing components are surfaced, or how results are shaped.

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 wasted words. It is efficient, though its brevity reflects under-specification rather than disciplined conciseness.

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

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

With a 3-parameter tool, 33% schema coverage, and no output schema, the description should carry more weight on comparison semantics and result shape. It leaves the agent unsure what "component values" comparison returns or how mismatches are reported, making it incomplete for the tool's 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 only 33%, and only workspace_root carries a schema description. The description implies left_path and right_path are the schematics being compared, but does not clarify whether they are file paths, schematic names, or workspace-relative references, nor how they interact with workspace_root. It does not compensate for the coverage 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 states a specific verb ("Compare") and a specific resource and dimension ("component values between two schematics"), which distinguishes it from siblings like check_schematic or inspect_schematic. It stops short of naming an alternative such as compare_waveforms, so it earns a 4 rather than a 5.

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 when-to-use guidance, no stated preconditions, and no pointer to sibling tools like check_schematic or inspect_schematic. The agent must infer the trigger conditions entirely from the 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?

Annotations already declare readOnly, idempotent and non-destructive, so the safety profile is covered. The description adds only that the comparison is on means rather than full waveform traces; it does not say what is returned, whether a tolerance/significance notion applies, or how mismatched or missing signals are handled.

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 or redundancy. It is efficient, though so terse that it omits information an agent would need, which keeps it out of the top tier.

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 four parameters at 25% coverage and no output schema, the description needed to explain both the comparison result (e.g. mean values or a verdict) and the file/signal argument conventions. It provides neither, so an agent cannot predict what comes back or verify it passed the right inputs.

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 25% (just workspace_root), so the description carries the burden for signal, left_path and right_path. 'One signal in two raw files' loosely implies those three parameters but gives no format for the signal name or path, leaving the required arguments effectively undescribed.

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 verb (compare) and a specific subject (the means of one signal across two raw files), which is enough to separate it from compare_schematics and merge_waveforms. It stops short of explicitly naming a sibling it is not, so it does not reach the 5 tier.

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 statement of when to reach for this tool versus merge_waveforms, compare_schematics, or measure_waveform, and no prerequisites (e.g. that both files must be raw simulation outputs sharing the same signal). Usage must be inferred entirely from the 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?

Annotations already declare readOnlyHint=true, idempotentHint=true, and destructiveHint=false, so the safety profile is covered elsewhere. The description adds no behavioral context at all - no mention of required inputs being an existing raw file, of failure modes for a bad fundamental, or of what gets returned. It neither contradicts nor enriches the 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?

Four words with no waste, but this is under-specification rather than conciseness. Nothing about the operation is front-loaded because there is essentially nothing to front-load.

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 4-parameter computation tool with no output schema and sparse parameter documentation, the description should at minimum explain the input contract and the resulting metric. As written, an agent must open the schema and still cannot infer units, expected signal form, or output shape.

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 25% (only 'workspace_root' is documented) and the description supplies nothing beyond the bare term. The semantics of 'signal', 'raw_path' (file vs. identifier), and 'fundamental_hz' (units, expected range) are left 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 merely expands the acronym in the title ("Compute Thd" -> "Total harmonic distortion."), which is close to a tautology. It does not say what the tool computes over, from what input ('signal', 'raw_path'), or how it differs from neighbours like read_fourier or export_fft_spectrum that also deal with spectral content.

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 when-to-use, when-not-to-use, or alternative routing is given. An agent cannot tell from the text whether this belongs in a measurement workflow versus read_fourier or measure_waveform, so it must guess from sibling names 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?

Annotations already state readOnlyHint=false, destructiveHint=false, and idempotentHint=false, and 'Write' is consistent with that. However, the description adds almost nothing beyond the annotations: it does not say where the file lands, whether an existing file at output_path is overwritten, or what (if anything) is returned. No contradiction with annotations.

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

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

A single front-loaded sentence with no filler, which is efficient. It is arguably under-specified rather than genuinely concise, but structurally there is nothing wasted.

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 write tool with 20% schema coverage and no output schema, the description should at minimum explain the parameters and the overwrite/return behavior. Instead it supplies one terse sentence, leaving the agent without enough context to invoke it 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 only 20% (just workspace_root), yet the description documents none of the undocumented parameters (value, prefix, description, output_path). 'Two-pin' hints at pin semantics but no parameter corresponds to pins, so the description neither maps to the schema nor compensates for its 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 gives a specific verb+resource ('Write a ... ``.asy`` symbol') and adds a scope qualifier ('two-pin'), so an agent knows this produces a symbol file rather than, say, exporting one. It does not explicitly differentiate itself from the closest siblings (export_symbol_to_asy, add_component_from_asy), which is why it stops short of a 5.

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 when-to-use guidance, no prerequisites, and no reference to alternatives such as export_symbol_to_asy or add_component_from_asy. The agent must infer from the name alone whether this is the right tool for a given symbol-creation task.

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

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

Annotations already declare readOnlyHint=false, idempotentHint=false, and destructiveHint=false, so the safety profile is covered. The description adds the meaningful qualifier 'empty' (no components are populated), but omits what happens if the path already exists, whether creation overwrites, and what the call returns.

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 four-word sentence with zero waste and the verb front-loaded. It is efficient, though the brevity contributes to the specification gaps noted 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?

With no output schema and no annotations explaining the result, the description should at least indicate what is returned (path, handle) and whether re-invocation fails. For a non-idempotent creation tool with an undocumented required path parameter, the description is too thin.

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 50%: workspace_root is documented in the schema, but schematic_path (the required parameter) has no description anywhere. The description does not compensate with path format, extension, or relative-vs-absolute semantics, leaving the most important parameter under-specified.

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 ('Create an empty schematic'), and the word 'empty' implicitly distinguishes it from the sibling create_starter_schematic. However, it does not name or contrast with that sibling explicitly, so differentiation requires the agent to infer it.

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 when-to-use guidance and no mention of alternatives such as create_starter_schematic or save_schematic_as. The agent gets no signal about which creation tool to pick or what preconditions (existing file, workspace) apply.

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

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

Annotations already declare the safety profile (readOnlyHint=false, destructiveHint=false, idempotentHint=false), so the mutation and repeat-call behavior is covered structurally. The description adds no behavioral context of its own: it does not say what a 'starter' schematic contains, whether schematic_path is created or overwritten, or what happens on a repeat call.

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 zero waste, and the most useful fact (the three kinds) sits first. It is arguably over-terse for a 3-parameter write tool, which keeps it from a 5.

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 non-idempotent file-creating tool with 33% schema coverage and no output schema, the description leaves out what the agent needs: the meaning of schematic_path, overwrite/create semantics, and how the generated circuit relates to the requested kind. The information gap is substantial even accounting for the annotations.

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 only 33% – workspace_root is the sole documented parameter. The description partially compensates by enumerating the valid 'kind' values (divider, RC, buck), which the schema's bare "type": "string" does not convey. However the required schematic_path gets no format or expectation guidance from either source, so this is only a partial offset.

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 (Create) plus the resource (starter schematic) and enumerates the three supported kinds (divider, RC, buck), so an agent knows exactly what gets produced. It does not differentiate itself from the sibling create_schematic or materialize_reference_circuit, so it stops short of a 5.

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 when-to-use, when-not-to-use, or alternative-tool guidance. With create_schematic, materialize_reference_circuit, and several scaffold_* siblings all producing schematics, the description gives the agent nothing to route on. The kind list hints at scope but not at 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?

Annotations already declare readOnlyHint=true, idempotentHint=true, destructiveHint=false, so the safety profile is fully covered by structured data. The description adds nothing beyond the annotations — no hint about the scope of results, what 'clean-room editor' means, or what class of edits it reports.

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 padding. It is efficient, though the terseness is part of why the scope is ambiguous.

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-only introspection tool with no output schema, the description should at least clarify what it returns and how it relates to describe_schematic_edit_support. Annotations cover safety, but the missing differentiation and return-scope detail leave a real gap.

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 are no parameter semantics for the description to explain. Baseline 4 applies. (Schema coverage is reported as 100% on an empty object, so the schema does no work either.)

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 a verb ('Describe') and a resource ('edits the clean-room editor performs'), so the general purpose is discernible. However, it does not distinguish this tool from the near-identical sibling 'describe_schematic_edit_support' (or describe_server_capabilities), leaving the agent unsure which capability-description tool to pick.

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 statement of when to call this versus the many other 'describe_*' siblings, nor any prerequisite or exclusion. The agent must guess 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?

Annotations already declare readOnly/idempotent/non-destructive and closed-world, so the safety profile is covered. The description adds nothing beyond that, such as whether it reveals optional GUI modes, prerequisites, or platform requirements, and does not mention the zero-argument nature or return shape.

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 short sentence with no waste. It is appropriately sized but under-front-loaded in terms of substance, not length.

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

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

For a capability-discovery tool with no output schema, the description should say what the caller learns (which GUI launch modes/commands are supported) and when to call it. As written, an agent has almost nothing to distinguish this from other describe_* tools.

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?

Zero parameters, so the baseline is 4. The description appropriately says nothing about parameters and does not mislead.

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?

Restates the name almost verbatim ('describe ... GUI launch support' vs 'Describe Live Gui Support'). It does identify the resource (GUI launch support), but gives no detail on what the description contains or how it differs from siblings like describe_server_capabilities or describe_edit_capability.

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 when-to-use, when-not-to-use, or alternatives mentioned. An agent can only infer that it is a capability-discovery call from the verb 'describe'.

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

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

Annotations already declare readOnlyHint, idempotentHint, destructiveHint=false and a closed world, so the safety profile is fully covered. The description adds only the mild signal that the response includes both supported and unsupported ('can and cannot do') capabilities; it says nothing about the form, breadth, or limits of that answer.

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 short sentence with the capability scope front-loaded and zero filler. Nothing to trim and nothing buried.

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-only capability-query tool with no output schema, the description adequately conveys that the return is a supported/unsupported capability summary. It could say slightly more about what domains are covered (e.g. netlist, simulation, or schematic aspects of mixed-signal), but nothing an agent needs to invoke it 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 takes zero parameters and the schema is empty, so there is nothing for the description to disambiguate. 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?

States a specific informational verb ('State') and a specific resource (mixed-signal authoring capability of LTspice), including the scope 'can and cannot do'. It is distinguishable from the many other describe_*_support siblings only by its topic noun, not by any explicit contrast, so it falls just short of a 5.

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 call this versus describe_server_capabilities, describe_schematic_edit_support, describe_protocol_support, or the other capability-query siblings. The intent is inferable (check capability before authoring mixed-signal content), but nothing states a trigger, prerequisite, or exclusion.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true, destructiveHint=false and a closed world, so the safety profile is covered. The description does add meaningful domain substance the annotations cannot convey — that the I2C/SPI scaffolds are behavioral teaching circuits rather than real protocol implementations. It stops short of saying what the response looks like (prose? structured flags?), so this is a moderate add.

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 short sentence with no filler, and the substantive point (I2C/SPI scaffolds are teaching circuits) is front-loaded. It loses a point only because the imperative 'State that...' framing is an instruction rather than a tool description, which is a slightly confusing structure for a definition field.

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 parameters and no output schema, the description is not required to enumerate returns, and it does communicate the core payload (protocol scaffolds are educational, not functional). It remains thin for a description tool though — it never says what the tool returns or how it interacts with the scaffold_* siblings, so an agent is left guessing at the response shape.

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 and the schema is empty, so there is nothing for the description to disambiguate. Baseline 4 applies; no param-level gaps exist to compensate for.

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 name and title identify a 'describe' tool about protocol support, and the description narrows the subject to I2C/SPI scaffolds being behavioral teaching circuits. But the imperative phrasing 'State that...' describes an instruction to the agent's output rather than what the tool itself does/returns, leaving the verb-resource relationship ambiguous. It also doesn't distinguish itself from neighbors like describe_mixed_signal_support or scaffold_i2c_device/scaffold_spi_device.

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 when-to-use guidance, no prerequisites, and no mention of alternatives. Given many sibling 'describe_*' and 'scaffold_*' tools, the agent gets no signal about when this specific explanation is the right call versus scaffold_i2c_device/scaffold_spi_device or describe_mixed_signal_support.

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

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

Annotations already declare readOnly, idempotent, and non-destructive, so the safety profile is covered structurally. The description adds nothing beyond that — no indication of what 'describe' returns, whether the recipe must exist, or what happens for an unknown recipe_id.

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 short sentence with no filler and nothing buried, so it is structurally clean. However, the brevity stems from under-specification rather than efficiency, which caps the score.

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

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

For a read-only lookup tool with one undocumented parameter and no output schema, the description should at least say what is returned and how to source the recipe_id. Neither is present, leaving the definition too thin to guide a correct call.

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 recipe_id parameter, and the description does not compensate: it never explains what a recipe_id is, where to obtain one, or its format. The one-parameter description therefore adds no semantic 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 states a verb and resource ('Describe one reference circuit'), but it reads as a restatement of the tool name rather than an explanation of what describing yields. It does not distinguish itself from siblings such as list_reference_circuit_recipes or materialize_reference_circuit, so an agent gets only a minimal sense of 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?

There is no guidance on when to call this versus list_reference_circuit_recipes (to enumerate recipes) or materialize_recipe (to instantiate one). No prerequisites, no conditions, no alternatives 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?

Annotations already declare readOnlyHint=true, idempotentHint=true, destructiveHint=false and openWorldHint=false, so the safety profile is fully covered by structured data. The description adds no behavioral context beyond that—no indication of what the returned capability set includes, whether it is static or session-dependent, or any scope caveats.

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?

It is a single short sentence with no padding, but that brevity comes from under-specification rather than economy—it conveys almost no information, so the sentence does not really earn 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?

For a zero-parameter capability-reporting tool the description should explain what 'schematic edit support' encompasses and how it differs from the several sibling describe_* tools. There is no output schema to fall back on, and the one-sentence description leaves the agent guessing about scope.

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; per the rubric, a parameterless tool sets a baseline of 4. No parameters are misdocumented or omitted.

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 'Describe schematic edit support for clients' is essentially a restatement of the tool name/title. While it implies a read-only capability-reporting tool, it doesn't say what 'edit support' actually covers (which operations, which limits), and it gives no basis for distinguishing it from siblings like describe_edit_capability or describe_server_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?

There is no when-to-use guidance, no mention of when a client should call this versus describe_edit_capability or the other describe_* capability tools. The only hint is 'for clients', which is not an actionable selection criterion.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true, and destructiveHint=false, so the safety profile is covered. The description adds nothing behavioral beyond 'built-in', which only vaguely hints that the specs are predefined rather than user-supplied.

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 short, front-loaded sentence with no waste, but its brevity stems from under-specification rather than disciplined editing, so it does not earn more than a middling score.

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 0% parameter coverage, the description is the only source of information about this tool, yet it says nothing about what the spec description returns or how to select a spec. For a discovery tool this leaves the agent under-equipped.

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, but it never mentions spec_name. The word 'built-in' weakly implies the parameter names a predefined spec, yet there is no mention of valid values, whether it is optional, or what happens if omitted.

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 'Describe a built-in layout spec' essentially restates the tool name (describe_schematic_layout_spec) with no added specificity. It gives a verb and resource but no scope, no indication of what a 'spec' contains, and no differentiation from the sibling apply_schematic_layout_spec.

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 call this versus alternatives such as apply_schematic_layout_spec or describe_schematic_edit_support. Usage is only faintly implied by the verb 'describe', leaving the agent to infer the 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?

Annotations already declare readOnlyHint, idempotentHint, non-destructive, and closed-world, so safety is covered. The description adds the subject matter reported (engine, tool groups, feature flags) but says nothing about return shape or how capability data should be interpreted.

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 twelve-word sentence with the payload front-loaded and zero wasted text. Appropriately sized for a no-argument discovery tool.

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

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

With no parameters, no nested objects, and no output schema, the description only needs to say what is reported, which it does. A brief note on the granularity of tool groups/feature flags would make it fully self-sufficient, but 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?

Zero parameters, so the schema imposes no semantic burden and the baseline is 4. There is nothing for the description to clarify beyond the empty object.

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 (report) and resource (LTspice engine, tool groups, feature flags), which is more informative than the bare name. It is distinguishable from sibling describe_* tools by being the server/engine-level one, though it does not explicitly contrast itself against describe_edit_capability or describe_schematic_edit_support.

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 — call it to learn what the server supports — but no explicit when-to-use or when-not guidance is given despite several related describe_* siblings that could be confused with it. Minimum viable.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true, destructiveHint=false, and openWorldHint=false, so the safety profile is fully covered externally. The description adds nothing on top: it does not say what the returned format specification looks like, how long it is, or whether it documents a required structure for contributions. No contradiction with annotations, but no added value either.

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 short sentence, front-loaded and free of filler, which is an appropriate size for a no-argument documentation tool. The brevity borders on under-specification rather than efficient conciseness, which keeps it below a 5.

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 schema is empty and there is no output schema, so the description is the only place an agent can learn what this call yields. It never states what the 'topology note format' contains, nor how it relates to validate_topology_contribution or ingest_topology_contribution, leaving the agent unable to reason about when it is the right tool despite the trivial 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?

The tool takes zero parameters, so there is nothing for the description to disambiguate; the baseline for a parameterless tool applies. No parameter meaning is missing, though no extra semantics are contributed either.

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 has a clear verb ('Describe') and a named resource ('topology note format'), so it is not a tautology. However, 'topology note format' is jargon that is never defined, and the description does nothing to separate this tool from close siblings such as describe_topology_block, validate_topology_contribution, or ingest_topology_contribution. An agent cannot tell from the text alone whether this returns a spec, a template, or a list of conventions.

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 when-to-use guidance, no prerequisites, and no mention of alternatives among the many topology siblings. A reader can only infer that it should be consulted before authoring or ingesting a contribution, and that inference is not 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?

Annotations already declare readOnlyHint, idempotentHint, destructiveHint=false, and openWorldHint=false, so the safety profile is covered. The description adds nothing beyond them — no note about what a 'topology note' contains, what happens on an unknown block_id, or the return shape.

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?

It is a single, front-loaded sentence with no filler, which is structurally clean. But it is under-specified rather than appropriately concise, given the ambiguity of 'topology note.'

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

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

For a read-only lookup keyed on an undocumented identifier, the definition omits everything an agent needs: what a topology block/note is, where block_ids come from, and how this differs from the sibling list/search tools. No output schema exists to offload return-value explanation.

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 single required parameter block_id is completely unexplained. The description does not compensate by clarifying what a block_id is, its format, or how it relates to blocks returned by list/search tools.

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 verb (Return) and a resource (topology note), so the basic operation is inferable. However, it neither distinguishes itself from the many topology siblings (list_topology_blocks, search_topology_blocks, describe_topology_authoring_support) nor resolves the terminology mismatch between the tool name's 'block' and the description's 'note.'

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 indication of when to use this tool versus list_topology_blocks or search_topology_blocks, nor any prerequisite such as needing an existing block_id. The agent is left to infer that a block_id is required and where it comes from.

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

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

Annotations declare readOnlyHint=false, idempotentHint=false and destructiveHint=false, implying some state change (likely writing files to disk), but the description's 'Return artifact paths' conveys a pure read and never discloses any side effect. It also omits session-lifecycle context (must the session be closed first?) and error behavior. The only added value is the 'finished session' precondition.

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 short, front-loaded sentence with no filler. It is efficient, though its brevity contributes to the ambiguity noted 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?

For a one-parameter remote-session tool with no output schema, the description omits what 'recorded' artifacts are, how a session becomes 'finished', and where the paths originate. Given the dense cluster of remote-execution siblings, richer lifecycle context is needed 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?

The single parameter session_id has 0% schema description coverage. The description's 'for a finished session' loosely ties the parameter to a session, but adds no format, source, or lookup guidance for the id, so it does not compensate for the coverage 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 gives a verb ('Return') and a resource ('artifact paths'), but 'Return artifact paths' directly conflicts with the name and title 'Download Remote Artifacts', leaving the agent unsure whether the tool fetches file content or merely enumerates paths. It also does not distinguish this from sibling remote-session tools such as close_remote_session or poll_remote_run.

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 explicit guidance on when to call this versus alternatives, nor any mention of prerequisites beyond the loose hint 'for a finished session'. The agent is left to infer that a remote session must exist and be complete before 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?

Annotations declare readOnlyHint=false and idempotentHint=false, so the agent knows this may mutate state, but the description offers nothing about what is modified, where results land, or whether evaluation has side effects on the raw file. With annotations present the bar is lower, but this description adds essentially zero behavioral context for a non-read-only, non-idempotent 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?

One short sentence with no filler, but it is under-specified rather than genuinely concise – the brevity comes at the cost of information an agent needs. A few additional clauses would earn their place here.

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 four-parameter tool with 25% schema coverage and no output schema needs the description to explain the expression language and expected return; it does neither. The undefined output format is especially costly since no output schema exists to fall back on.

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 25% – raw_path, expression, and max_points are all undocumented in the schema. The description's phrase 'built from raw signal names' weakly hints that the expression references signals inside the raw file, but gives no syntax, units, or meaning for max_points, so the coverage gap is not compensated.

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 verb ('evaluate') and a resource ('expression built from raw signal names'), but 'evaluate' is left undefined – it's unclear whether this computes derived samples, returns a scalar, or writes to the raw file. Against siblings like read_waveform and measure_waveform, the distinction is not made 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?

No guidance on when to choose this over read_waveform, measure_waveform, plot_waveforms, or export_derived_raw, all of which operate on the same signal data. No prerequisites or conditions 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?

Annotations already establish the safety profile (write, non-destructive, non-idempotent), and the description adds two useful facts beyond them: the output is small/bounded and covers exactly one trace, so it cannot be used for multi-signal dumps. It still omits whether an existing file at the target path is overwritten, how the two path parameters interact, or what happens if the trace is unavailable.

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 compact sentence with no filler and the action front-loaded, which is structurally sound. However, that brevity comes at the cost of under-specification for a four-parameter write tool rather than being genuinely economical.

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

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

For a mutation tool with 25% schema coverage, no output schema, and an ambiguous pair of path parameters, the description leaves too much unresolved: unclear raw_path vs output_path roles, no overwrite semantics, and no distinguishing context against sibling exporters. It is not adequate to call the tool correctly with confidence.

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 only 25%: signal, raw_path, and output_path have no descriptions, and the description addresses none of them. Critically, raw_path (required) and output_path (optional) are two path-like parameters whose relationship is left entirely unexplained, so the caller cannot tell which one receives the exported file.

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 concrete action and output ('Write a small ASCII raw file containing one trace'), but the term 'derived raw' is unexplained jargon and the description never distinguishes this from the near-identical sibling export_waveform_ascii. An agent can guess what it does but not why it exists alongside several other ASCII/CSV/SPICE exporters.

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 when-to-use guidance, no exclusions, and no mention of alternatives despite a crowded export family (export_waveform_ascii, export_waveform_csv, export_waveform_spice, export_measures_csv). The 'one trace' phrasing implies a per-signal scope but never says when an agent should prefer this exporter over them.

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

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

Annotations already declare this is a non-readonly, non-idempotent, non-destructive, closed-world write. The description adds only that the output is a CSV of FFT magnitude, but says nothing about overwrite behavior, required permissions, or what happens to an existing output_path.

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 wasted words, but its extreme brevity leaves important structure and detail absent rather than making it optimal for a 4-parameter export tool.

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

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

For a four-parameter file-export tool with 25% schema coverage and no output schema, the definition is too thin. It lacks input semantics, overwrite behavior, and enough context to distinguish it from the numerous other export siblings.

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 25%, with just workspace_root documented, so the description must compensate for the undocumented signal, raw_path, and output_path parameters. It provides no parameter-level meaning at all, leaving key distinctions such as raw input versus CSV destination unclear.

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: 'Write an FFT magnitude CSV.' This distinguishes it from generic waveform exports among the siblings, but it does not clarify how it differs from tools like export_waveform_csv beyond the FFT magnitude qualifier.

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 export versus the many sibling export tools (export_waveform_csv, export_derived_raw, export_measures_csv, etc.), nor any prerequisites or exclusions. The agent must infer usage from the name and one-line purpose.

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

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

Annotations already declare readOnlyHint=false, destructiveHint=false, idempotentHint=false, and openWorldHint=false, which cover the safety profile. The description adds only that the output is CSV and the rows are .meas rows, but does not disclose overwrite behavior, path handling, or other side effects beyond what the annotations imply.

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 wasted words and is front-loaded, but it is drastically under-specified for a three-parameter mutation tool. Brevity here reflects missing information rather than efficient conciseness.

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

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

Given the mutation nature, three parameters with only one schema description, and no output schema, the description is far too sparse. It does not explain what .meas rows are, where output goes by default, or how log_path and output_path interact.

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 33%, with log_path (required) and output_path completely undocumented in the schema. The description does not explain any parameter, leaving the required log_path and output_path semantics entirely unclear.

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 clear verb (Write) and resource (.meas rows) and output format (CSV), so the action is identifiable. It does not differentiate from sibling export tools such as export_waveform_csv or export_touchstone_s2p, but the basic purpose is clear.

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

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

The description provides no guidance on when to use this tool versus alternatives. It does not mention list_measures, read_measures, or other export tools, and gives no prerequisites, conditions, 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?

Annotations already declare it is a non-readonly, non-idempotent, non-destructive write, and 'write a .asy' is consistent with that. The description adds output-shape context (two-pin, named for the component), but says nothing about overwriting an existing file, required permissions, or what is returned, which matters for a non-idempotent file write.

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; the verb and artifact come first. It is efficient, though the extreme terse-ness borders on under-specification rather than crispness.

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, low parameter coverage, and a file-writing side effect, the description does not carry enough to call the tool confidently. It omits path/format expectations, overwrite behavior, and any success/failure signal an agent would need.

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 only 25%, so three of four parameters (schematic_path, reference, output_path) are undocumented anywhere. The description only obliquely implies reference/output naming ('named for a placed component') and gives no hint about paths, formats, or the workspace_root override.

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 (write) and artifact (.asy), and adds that the output is two-pin and named after a placed component. However, it never explains what a 'placed component' is in this workflow or distinguishes itself from nearby siblings like create_asy_symbol or add_component_from_asy, leaving the agent to infer the niche.

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 when-to-use guidance, no prerequisites, and no named alternative despite several closely related asy/symbol tools in the sibling list. The agent must guess whether this is the right export path versus create_asy_symbol or read_component_symbol.

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

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

Annotations declare a non-read-only, non-idempotent, non-destructive write. The description is consistent and adds genuine domain behavior: the resulting file's S-parameter construction. It does not disclose overwrite/return behavior for output_path or why the operation is non-idempotent, so it only partially goes beyond the 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?

A single front-loaded sentence with no filler. It is efficient, though the dense notation ('one-port-style S2P') borders on cryptic for readers without Touchstone familiarity.

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 write/export tool with six parameters, 17% schema coverage, and no output schema, the definition is too thin. It never explains the source (raw_path), the destination (output_path), impedance (z0), or the export workflow, leaving the agent short of what it needs to call it 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 only 17% (only workspace_root is documented), so the description must compensate, and it largely does not. It hints that output_signal and reference_signal drive the S21 value, but raw_path, output_path, and z0 remain undocumented in both schema and description.

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 (Write) and resource (a one-port-style S2P), and even specifies the content rule (S21 = output/reference, other terms 0). This is concrete and unambiguous about what gets produced. It does not, however, differentiate itself from other export tools or explain S2P/Touchstone 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?

There is no when-to-use guidance, no mention of prerequisites (e.g. a completed simulation/raw file), and no reference to alternatives among the many export_* siblings. The agent is left to infer when this is the right export tool.

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

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

Annotations declare non-read-only, non-destructive, non-idempotent, and closed-world behavior. The description adds the output format but does not disclose what overwriting entails, permission requirements, or whether existing files are replaced.

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. It is efficient, though arguably too terse for a four-parameter export tool, which keeps it from a perfect score.

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 write tool with no output schema and sparse parameter documentation, the description is under-specified. It does not clarify the role of raw_path versus output_path or how the export is performed.

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 25% and the description does not explain any of the four parameters. It implies 'signal' is the data to export but leaves raw_path, output_path, and workspace_root undocumented, failing to compensate for the coverage 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?

States a concrete verb ('Write'), the resource ('one signal'), and the serialization format ('whitespace-separated text'). This distinguishes it from sibling exporters like export_waveform_csv and export_waveform_spice, though it does not name them explicitly.

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 choose ASCII over CSV or SPICE exports, no prerequisites, and no mention of alternatives. Usage is only implied by the tool name and format description.

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

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

Annotations declare readOnlyHint=false and destructiveHint=false, and the description's 'Write' is consistent with that. But beyond confirming a write, it says nothing about whether an existing CSV is overwritten, what happens if output_path is omitted, or where the file lands – gaps that matter for a mutating file-producing 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 front-loaded sentence with zero filler, which is efficient. It is arguably too terse given the under-specification elsewhere, but as pure conciseness it 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?

With four parameters, no output schema, and no annotation detail on file outputs, the definition should carry more weight. It omits what raw_path points to, the expected signals format, and output_path default/overwrite behavior, leaving the agent unable to call it confidently in edge cases.

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 25% (just workspace_root), so raw_path, signals, and output_path are undocumented in structured fields. The description's phrase 'selected signals' hints at the signals parameter but adds no syntax, format, or default information to compensate for the coverage 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?

States a verb (write) and resource (signals) with a format (CSV), so the basic action is discernible. However, it is nearly a restatement of the name and does nothing to distinguish it from close siblings like export_waveform_ascii, export_waveform_spice, or export_measures_csv that also serialize waveform 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?

There is no when-to-use guidance, no mention of prerequisites, and no routing to alternatives despite several export siblings competing for the same task. The agent is left to infer selection entirely from the 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?

Annotations already declare this is a non-read-only, non-idempotent, non-destructive write, and the description's 'Write' aligns with that. However it adds no behavioral context beyond the annotations: it does not say where output goes, whether output_path must exist, or what happens on repeat calls.

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 short sentence, but it is under-specified rather than concise. The brevity comes at the cost of essential information an agent needs, so it does not earn its place as a complete definition.

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 4-parameter export tool with no output schema and only 25% schema coverage, this one-liner is inadequate. It omits output destination, file format details, and parameter meaning, leaving the agent unable to invoke it confidently.

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 only 25% (workspace_root alone is documented), so the description must compensate for signal, raw_path, and output_path — and it does not. The vague reference to 'one real trace' hints at signal/raw_path semantics but conveys no format, selection, or destination meaning.

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

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

States a specific verb ('Write') and a resource ('a PWL statement for one real trace'), but 'PWL' is unexplained jargon and the description never says it writes to a file or where. It also fails to distinguish this from siblings like export_waveform_ascii, export_waveform_csv, or export_derived_raw, all of which also export waveform 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 phrase 'for one real trace' gives a faint scope hint, but there is no when-to-use guidance, no prerequisites, and no named alternative among the many export_* siblings. An agent has no basis for choosing this over export_waveform_ascii/csv.

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

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

Annotations declare readOnlyHint=false, so the operation is not a pure read, yet the description never explains what non-read side effect occurs or where the kept rows go (returned inline? written to a file?). It adds the matching rule but nothing about output destination, overwrite behavior, or permissions. Since annotations are present, the description does not contradict them, but it leaves the key behavioral question open.

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 zero waste. It is efficient, though arguably under-specified rather than merely 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?

For a non-read-only filter tool with no output schema, the description should indicate where filtered rows go and what is produced. That crucial context is entirely absent, leaving the agent unable to predict the tool's effect.

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 only 33% (workspace_root is the lone documented param). The description compensates for the undocumented ``device`` param by clarifying it is a substring matched against row names, but log_path and the output implications remain unexplained in both places.

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 (keep/filter), resource (operating-point rows), and criterion (name contains ``device``), which is concrete and distinguishes it from read_device_operating_points and summarize_device_operating_points at a functional level. It does not, however, explicitly name those siblings or contrast its scope with 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 on when to use this filter versus read_device_operating_points or summarize_device_operating_points. There is no statement of prerequisites or context, only a restatement of the filtering behavior.

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

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

Annotations cover the safety profile (readOnlyHint=false, destructiveHint=false, idempotentHint=false), so the write nature is already declared and the description is consistent with it. The description adds the useful behavioral detail that a fallback 'clean-room renderer' exists, implying LTspice may not be required, but it says nothing about side effects, overwrite behavior, or where output lands.

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 padding. It is efficient, though the 'clean-room renderer' phrase is unexplained jargon that a reader must already know.

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 write tool with no output schema and only 33% schema coverage, more is needed: what source is consumed, where the netlist is written, and when to prefer this over save_netlist_copy. The description leaves most of that to inference.

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 only 33%: source_path and output_path have no schema description, and the description gives no meaning for either (what is the source, where does the netlist get written, is output_path optional/derived). With coverage well under 50%, the description fails to compensate for the undocumented 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 verb+resource are concrete ('Write a netlist'), and it names the two rendering backends (LTspice '-netlist' or the clean-room renderer). It does not, however, distinguish this from close siblings like save_netlist_copy or prepare_net, so the agent cannot route on the description alone.

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 when-to-use guidance, no prerequisites, and no mention of alternatives. The existence of save_netlist_copy and prepare_net among siblings makes the absence of routing guidance a real gap.

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

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

Annotations already declare readOnlyHint, idempotentHint, destructiveHint=false, and openWorldHint=false, fully covering the safety profile. The description adds no behavioral context beyond restating that it returns a summary, offering nothing about scope, auth, or limitations.

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 wasted words. It is appropriately terse for the tool's simplicity, though the terseness borders on under-specification.

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 a vague term like 'batch manifest summary,' the description should explain what the summary contains and clarify the required identifier. It leaves key return-value and parameter context completely unspecified.

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 never mentions the required batch_id parameter, so an agent gets no semantic detail about what identifier is needed or its expected form.

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 clear verb+resource: 'Return a batch manifest summary.' However, it does not differentiate from closely named siblings such as summarize_batch or collect_batch_results, leaving an agent to infer the distinction from name alone.

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 versus alternatives like summarize_batch, collect_batch_results, or poll_remote_run, nor any mention of prerequisites or context for calling it.

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

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

Annotations already establish the safety profile (readOnlyHint=false, destructiveHint=false, idempotentHint=false), so the mutation and non-destructive nature is covered. The description adds that content is written 'into the workspace', but says nothing about overwrite behavior, conflicts, or failure modes for an import that will not be idempotent.

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 that covers the primary action without padding. The odd double-backtick markup around ``.asc`` is a minor blemish but the structure is otherwise 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?

For a mutating import tool with no output schema and an incomplete parameter schema, the description should clarify what the import produces and how the workspace/destination interact. It leaves an agent unable to reason about placement and result of the imported circuit.

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 only 33% and the description only partially compensates by implying bundle_path is a zip or .asc. It does not explain destination_dir, nor how it relates to workspace_root (which is the only parameter with a schema description). Two of three parameters remain effectively 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 names specific verbs ('unpack', 'copy') and resources (a zip of schematics, a .asc file), so the agent knows it imports circuit content. However, it does not differentiate itself from adjacent import-like siblings such as materialize_reference_circuit, materialize_recipe, or create_schematic.

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

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

It hints at two modes ('or copy one .asc') but gives no guidance on when to use a zip versus a single .asc, no prerequisites, and no alternatives. The agent must infer the branch condition from the input path 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?

Annotations already declare readOnlyHint=false, destructiveHint=false, idempotentHint=false, and openWorldHint=false, so the safety/mutation profile is covered. The description adds the "validated" precondition, which is genuine extra context, but says nothing about duplicate handling, overwrite behavior, or storage location.

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 efficient sentence with no filler, and the mutation verb is front-loaded. It is terse to the point of under-specification rather than padded.

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 mutation tool with no output schema, one undocumented string parameter, and no explanation of what a valid payload looks like or what ingestion produces. Too little is said for an agent to call this correctly without inspecting sibling tools.

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?

One required parameter (payload) at 0% schema description coverage, and the description gives no hint of its format, structure, or expected content. With coverage this low the description should compensate for the gap and does not.

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 ("Store") and resource ("contribution") scoped to a workspace, so an agent knows it is a write operation. However, it never names or distinguishes itself from validate_topology_contribution or the other topology_* siblings, relying on the reader to infer the pipeline position.

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

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

The only usage signal is the word "validated," which faintly implies running validate_topology_contribution first. There is no explicit when-to-use, no statement of the precondition for the payload, and no mention of alternatives.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true, destructiveHint=false, and openWorldHint=false, so the safety profile is covered. The description adds nothing beyond that – no indication of what the summary contains, how large the schematic may be, or whether it is text or a structured digest.

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?

It is short and front-loaded, but brevity here is under-specification rather than efficiency – two words that omit all scope, format, and usage detail. Nothing is wasted, but nothing is earned either.

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 bears the burden of explaining what the summary looks like, yet it says nothing about return structure or scope. A single-line description is inadequate for a tool whose entire value is the shape of its summarized 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 only 50%: workspace_root is documented inline, but schematic_path (the required parameter) has no description. The description does not compensate by explaining path format, resolution rules, or the effect of the workspace_root override.

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?

"Summarize a schematic" names a verb (summarize) and a resource (schematic), so the basic action is identifiable. However, it does nothing to separate this tool from near-neighbors such as check_schematic, read_net_connectivity, render_schematic_image, or list_components, leaving the agent to guess what "summarize" actually returns.

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 when-to-use guidance, no prerequisites, and no mention of alternatives among the many schematic-inspection siblings. The agent gets no signal about when this tool is preferable to check_schematic or list_components.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true, destructiveHint=false, and closed-world, so the safety profile is fully covered by structured data. The description adds nothing on top — no indication of scope (whole schematic vs. a sheet), ordering, pagination, or result size, which is the kind of context that would actually earn credit here.

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 zero filler, which is structurally clean. The problem is under-specification rather than verbosity, so it lands at the minimum-viable level.

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 carries the burden of explaining what is returned (component identifiers, references, values?) and in what shape. It says only 'placed components', leaving the return contract and the required schematic_path semantics unexplained.

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 50%: workspace_root is documented but schematic_path is not. The description contributes no parameter meaning at all, so it fails to compensate for the undocumented required path 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?

States a specific verb and resource ('List placed components'), so the agent knows exactly what operation is performed. However, it does nothing to distinguish itself from close siblings like read_component, inspect_schematic, or list_subcircuits, which an agent could easily confuse with it.

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 versus alternatives such as read_component (single component detail) or inspect_schematic (broader survey). No prerequisites, no scoping conditions, nothing to route the agent among the many sibling list/read tools.

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

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

Annotations already declare readOnly, idempotent, non-destructive, closed-world behavior, so the safety profile is covered. Beyond the resource type, the description adds nothing about the return shape, error behavior, or whether nested/inherited includes are resolved.

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 short sentence with no waste, and the key content is front-loaded. It is terse but arguably under-specified rather than over-elaborated.

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 listing tool with no output schema, the agent is not told what the returned list looks like or how source_path is used. Given a required undocumented parameter and no return description, the definition leaves important 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?

The required 'source_path' has no description in the schema and is never mentioned in the description; only 'workspace_root' is documented (schema coverage 50%). The description does nothing to compensate for the undocumented required path 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?

States a specific verb ('List') and resource ('.lib' and '.include' directives), which clarifies what the cryptic 'includes' refers to. It does not, however, distinguish itself from related siblings such as add_library_include or list_subcircuits.

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 when-to-use guidance, no prerequisites, and no alternatives. An agent knows what is listed but not when to reach for this tool versus, say, inspecting a schematic or reading a subcircuit.

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

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

The annotations already declare readOnlyHint=true, idempotentHint=true and destructiveHint=false, so the safety profile is fully covered by structured data; no contradiction exists. The description itself adds no behavioral context at all — no scoping, no ordering, no indication of what happens with an empty or missing measurement set — so it earns no credit above the annotation baseline.

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 short sentence is front-loaded and wastes no words, which suits a simple list tool. It is terse to the point of under-specification rather than genuinely concise, and the stray doubled backticks around '.meas' are formatting noise.

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, so the description should describe the return shape, but it only says 'names' without conveying ordering, count, or behavior when no .meas directives exist. Combined with the undocumented required log_path and zero usage routing, the definition is too thin for an agent to call confidently.

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 50% schema coverage, the required log_path parameter has no description anywhere, and the description does not compensate by explaining what log_path should point to (raw output? netlist log?) or what a workspace_root override changes. The one documented parameter (workspace_root) is the optional one, leaving the mandatory parameter 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 names a verb ('List') and a resource ('.meas' measurement directive names), so the basic action is recoverable. However, it does not differentiate itself from closely related siblings like read_measures or export_measures_csv, and '.meas' is unexplained jargon that a non-expert agent may not map to measurement directives.

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 when-to-use guidance, no statement of prerequisites (e.g. that a log_path pointing at a completed simulation log is required), and no routing to read_measures for values or export_measures_csv for export. The agent must infer all selection logic from the tool 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?

Annotations already declare readOnlyHint=true, idempotentHint=true, destructiveHint=false, and openWorldHint=false, so the safety profile is fully covered. The description adds no behavioral context beyond the purpose, such as whether a valid schematic is required, what the suggestions contain, or any dependency on saved state.

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 wasted words. However, it is so terse that it omits necessary context about the required schematic input and the nature of the suggestions, making it under-specified rather than optimally 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?

For a tool that requires a schematic path and returns plot suggestions without an output schema, the description should explain what the suggestions are based on and what they contain. Instead it gives only a one-line purpose, leaving an agent without enough information to invoke it confidently.

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 50%: workspace_root is described, but the required schematic_path is undocumented in both the schema and the description. The description does not mention either parameter or explain what schematic_path should point to, so it fails to compensate for the coverage 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 gives a clear verb ('Suggest') and resource ('voltages and currents an agent can plot'), so an agent can tell it produces plot suggestions. It does not differentiate itself from siblings like list_signals or list_measures, which may also list plottable quantities, so it falls short of a 5.

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 versus alternatives such as list_signals or plot_waveforms. The phrase 'an agent can plot' implies it is used before plotting, but no explicit when/when-not or prerequisites 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?

Annotations already declare readOnlyHint=true, idempotentHint=true, openWorldHint=false and destructiveHint=false, so the safety profile is fully covered. The only added context is the word 'bundled', which implies the recipes come from built-in packages rather than user workspaces; nothing is said about return format, size of the catalog, or pagination.

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

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

A single short sentence with zero filler and the resource front-loaded after the verb. It is efficiently written, though the brevity borders on under-specification rather than tightness.

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, so the description should carry the burden of explaining what comes back and how to use it, yet it does not say whether entries are names, ids, or full specs, nor that an id feeds into describe_reference_circuit_recipe/materialize_reference_circuit. For a catalog entry point in a 90-plus tool environment, that linkage is the missing piece.

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 per the rubric the baseline is 4. The description adds no parameter information because none is needed, and the empty schema is self-explanatory.

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 clear verb (List) and resource (bundled reference circuits), so an agent knows this is a catalog enumeration. However, it never distinguishes itself from close siblings such as describe_reference_circuit_recipe or materialize_reference_circuit, and it silently renames 'recipes' (per the tool name) to 'reference circuits', leaving the agent to guess they are the same thing.

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 when-to-use guidance, no stated relationship to the recipe workflow, and no mention that this should precede materialize_reference_circuit or describe_reference_circuit_recipe. The agent must infer the place of this tool in the recipe pipeline entirely on its own.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true, destructiveHint=false, and openWorldHint=false, so the safety profile is fully covered. The description adds nothing beyond that: no indication of what a raw file is, whether a missing or malformed path errors, or how large result sets are handled. No contradiction with annotations.

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

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

A single short sentence with zero padding and the resource front-loaded. It is efficient, though the brevity edges into under-specification rather than true crispness.

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, so the description carries the burden of explaining what is returned, and it does not say whether the result is signal names, metadata, or counts. For a tool whose entire value is the shape of its listing output, this is a meaningful gap.

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 50%: workspace_root is documented in the schema while raw_path is not. The phrase 'in a raw file' loosely implies raw_path points to a raw simulation output file, giving marginal semantics beyond the bare string type, but it does not specify path format or resolution behavior.

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 verb (List) and a resource (signals in a raw file), which is enough to distinguish it from mutation siblings like add_wire or remove_component. However, it does not differentiate from adjacent read/list tools such as list_measures or list_steps, nor does it clarify what a 'signal' is in this 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?

No when-to-use guidance, no prerequisites, and no mention of alternatives such as list_measures or read_waveform. The agent must infer from the name alone that this inspects a raw simulation file.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true, destructiveHint=false, and openWorldHint=false, so the safe-read profile is covered. The description adds that output derives from a raw file plus an optional log, which is useful context, but it says nothing about the returned structure or pagination.

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

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

A single front-loaded sentence with no wasted words. It is efficient, though the terseness borders on under-specification rather than tightness.

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 ideally convey what a 'stepped run' listing returns, and it does not. Annotations carry the safety profile, but the return-value gap leaves the definition minimally adequate for this listing 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 only 33% (just workspace_root). The description loosely maps raw_path to 'a raw file' and log_path to 'the log', partially compensating, but the required/optional distinction and the workspace_root override are not clarified in the description.

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 (stepped runs) with the source scoping ('from a raw file and, when given, the log'). It does not, however, distinguish itself from nearby siblings like read_log or list_signals, leaving the agent to infer exactly what a 'stepped run' is versus other waveform listings.

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 explicit when-to-use guidance and no named alternative. The phrase 'when given, the log' implies the tool is useful after a stepped simulation, but the agent gets no signal about prerequisites or how to choose this over read_log or list_signals.

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

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

Annotations already declare readOnlyHint, idempotentHint, non-destructive and closed-world, so the safety profile is fully covered. The description adds no behavioral context beyond that: it says nothing about pagination, ordering, what a hierarchical symbol entry looks like, or how results relate to the source_path. With annotations carrying the safety load, this thin description leaves real 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?

A single front-loaded sentence with zero filler. It is efficient, though arguably too terse for a tool with an undocumented required path parameter; brevity here borders on under-specification.

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, so the description would need to convey what gets returned (names? a tree? counts?), and it does not. Combined with an undocumented required parameter and no usage context, the definition is not complete enough for an agent to invoke it confidently.

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 50%: workspace_root is documented in-schema, but source_path has no description anywhere. The description does not explain what source_path should point to (a .asc schematic? a netlist?) or what the workspace_root override affects, so it fails to compensate for the coverage 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?

States a specific verb ('List') and a specific resource ('.subckt blocks and hierarchical symbols'), so an agent knows it enumerates subcircuit definitions rather than reading one. It is distinguishable from read_subcircuit, though the description never names that sibling or clarifies scope. Clear but lacking explicit sibling differentiation.

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 when-to-use guidance and no mention of the obvious alternative read_subcircuit (or list_components). The agent must infer that this enumerates whereas read_subcircuit fetches a single definition. No prerequisites 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?

Annotations already declare readOnlyHint, idempotentHint, and destructiveHint=false, so the safety profile is covered. The description contributes no additional behavioral context such as scope, filtering defaults, pagination, or result ordering.

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?

It is a single front-loaded sentence with no waste, but it is under-specified rather than genuinely concise — the brevity comes from omitting information rather than from tight writing.

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 describe what a 'topology block' is and what the listing returns, but it says nothing. For a tool whose name and description disagree on nouns, this leaves the agent guessing about the result set.

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 per the rubric the baseline is 4; there is nothing for the description to clarify on the parameter side and no ambiguity introduced.

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 restates the tool name with a different noun ('notes' vs 'blocks'), which is essentially a tautology and introduces terminology inconsistency. It does not distinguish this tool from the sibling search_topology_blocks or clarify the relationship to describe_topology_block.

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 when-to-use guidance and no mention of the closely related search_topology_blocks, leaving the agent to guess when unfiltered listing is preferable to searching. The verb 'List' only weakly implies an enumeration context.

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

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

The annotations already declare readOnlyHint=true, idempotentHint=true, destructiveHint=false, and openWorldHint=false, so safety is covered. The description adds only 'bundled' as a minor source hint and does not describe return behavior, pagination, or content format beyond what the annotations provide.

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

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

The definition is a single, front-loaded sentence with no wasted words. It is appropriately terse for a zero-parameter list tool, though its extreme brevity also reflects the lack of substantive 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 zero-parameter, read-only list tool whose safety profile is fully covered by annotations, the description is barely adequate. It omits what a workflow note contains and how it relates to read_workflow_instruction, but the tool's invocation complexity is low enough that an agent could still call it.

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 the parameter-semantics baseline is 4. There are no parameter details for the description to add or omit.

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 'List bundled workflow notes' essentially restates the tool name and title, swapping 'instructions' for 'notes' without explaining what a workflow note is or how it differs from the sibling read_workflow_instruction. No specific scope or content distinction is provided.

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 when-to-use guidance, no exclusions, and no mention of the obvious alternative read_workflow_instruction. The agent is left to infer that this lists available notes while the sibling retrieves one, but nothing in the description states that.

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

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

Annotations already declare readOnlyHint=false, idempotentHint=false, and destructiveHint=false, so the mutation profile is known. The description adds only that the write goes 'into the workspace' and does not disclose overwrite behavior, whether repeated calls create duplicates, or what happens if destination_path already exists.

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 wasted words. However, for a three-parameter mutation tool with low schema coverage, it is under-specified rather than optimally sized.

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 does not explain what is produced, where the recipe comes from, or what workspace changes occur. Given the non-idempotent write behavior and partially documented schema, the description leaves important context 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 only 33%, with workspace_root being the sole documented parameter. The description does not explain recipe_id, destination_path, or the relationship between them, so it fails to compensate for the undocumented parameters.

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