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

With no annotations, the description carries the full behavioral burden, but it only restates parameter meanings. It does not disclose that this mutates a board, requires an open document, or what side effects or permissions are involved.

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 purpose is front-loaded in one sentence, followed by a compact args list. Every line adds useful information without redundancy.

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

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

The output schema covers return values, and the description covers purpose and parameters. However, with no annotations and no usage guidance, it leaves gaps about when to prefer this over add_arc_track and what mutation side effects to expect.

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

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

Schema description coverage is 0%, so the description must compensate. It does so by defining all eight parameters with meaning and units: start/mid/end coordinates in mm, layer name, and outline width in mm.

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: "Add a graphic arc." The word "graphic" distinguishes it from the sibling add_arc_track, and the start/mid/end definition makes the operation concrete.

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 add_arc_track, add_line, or add_circle. No prerequisites, exclusions, or context are provided beyond the parameter list.

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

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

With no annotations, the description carries the full behavioral burden, yet it only describes geometry inputs. It does not disclose whether a board must be open, whether the mid point is validated as lying on the arc, whether the track is DRC-checked, or whether the operation is undoable.

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 one-line summary is front-loaded and the Args block is a compact, scannable list. Slightly verbose in layout but every line carries unique parameter information that the schema lacks.

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?

An output schema exists so return values need no explanation, and parameter documentation is thorough. However, with no annotations and no usage or behavioral context, the definition is still incomplete for judging when and under what conditions to invoke the tool.

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

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

Schema description coverage is 0%, so the description must explain all nine parameters — and it does, giving units (mm) for every coordinate and width, plus the meaning of the mid point and the optionality of net_name. This fully compensates for the empty schema descriptions.

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

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

States a specific verb and resource ('Add a curved (arc) copper track') and immediately names the three defining points, which distinguishes it from the sibling straight-track tools add_track and add_track_path as well as the non-copper add_arc.

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 add_track, add_track_path, or add_arc, and no stated preconditions such as requiring an open board or an existing layer/net. The agent is left to infer usage 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?

With no annotations, the description carries the full behavioral burden. It states the target layer and that it adds an outline, but omits whether it replaces an existing outline, permission/auth requirements, error conditions, or whether the operation is destructive. A write operation with zero annotation coverage demands more.

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

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

Front-loaded with the core action in the first sentence, followed by a compact args list. No filler; every element serves to clarify the operation.

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

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

The description covers the operation and all parameters, and an output schema exists so return values need not be explained. However, for a board-mutating tool with zero annotation and zero schema description coverage, it lacks usage context and critical behavioral details (e.g., overwrite semantics), leaving notable gaps.

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

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

Schema coverage is 0%, so the description must document parameters. It does so for all five: top-left and bottom-right corners in mm, and outline stroke width in mm. This fully compensates for the empty schema descriptions, though it does not restate the schema's default for width_mm.

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 (rectangular board outline) and the target layer (Edge.Cuts), which implicitly distinguishes it from generic drawing tools like add_rectangle. However, it does not name or contrast with any alternative sibling, so it stops short of 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?

No when-to-use guidance, no prerequisites, and no mention of alternatives (e.g., add_rectangle, add_line) or when not to use it. The description only states what the tool does, leaving the agent to infer usage 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?

With no annotations, the description carries the full behavioral burden yet only documents argument meanings. It does not state that this mutates board state, whether the change is undoable/revertable, or what the return value indicates. The mm units are the one genuinely useful behavioral detail.

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 purpose sentence followed by a tight parameter list; no filler. Front-loaded purpose statement, every line earns its place given the zero schema coverage.

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?

An output schema exists, so return values need not be described. For a board-mutating tool with no annotations, however, the definition should mention that it modifies the document and whether an open board is required; that gap keeps it at minimum-viable.

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

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

Schema description coverage is 0%, so the description must compensate, and it does: all six parameters are explained with units for the geometric ones. It omits the defaults encoded in the schema (layer=F.SilkS, width_mm=0.15, filled=false), which limits it slightly below a 5.

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

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

States a specific verb and resource ('Add a graphic circle'), which is enough for an agent to distinguish it from siblings like add_rectangle, add_arc, and add_polygon. No explicit sibling differentiation in the text, but the resource noun is unambiguous.

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

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

There is no guidance on when to use this versus add_rectangle, add_arc, or add_polygon, nor any prerequisite context (e.g., that a board/document must be open). Usage must be entirely inferred from the tool name.

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

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

No annotations are provided, so the description carries full responsibility for behavioral disclosure. It says 'Add' and mentions graphic layers, but does not cover whether a board must be open, whether the operation is undoable, what happens to existing items, or any permission requirements. For a mutation tool with zero annotation coverage, this is a significant gap.

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

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

The description is front-loaded with the core purpose and then uses a compact argument list. Every line earns its place, especially given the schema's lack of parameter descriptions, and there is no redundant or filler text.

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

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

The output schema exists, so return values need not be explained. However, for a mutation tool with six parameters and no annotations, the description is incomplete: it lacks usage guidelines relative to siblings and omits operational prerequisites or side effects. It is adequate but has clear gaps.

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

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

Schema description coverage is 0%, so the description must compensate. It documents all six parameters with units (mm) and gives layer examples ('F.SilkS', 'Edge.Cuts'), adding useful meaning beyond the bare parameter names. It omits default values, which are present in the schema, but otherwise provides strong parameter context.

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

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

The description states a specific verb and resource ('Add a graphic line segment') and gives examples of target layers (silkscreen, fab, Edge.Cuts), which implicitly distinguishes it from copper tracks and other shape-adding siblings. However, it does not name an alternative sibling or explicitly rule out copper use, so it falls short of full 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?

The layer examples imply that this tool is for non-copper graphical layers, but there is no explicit when-to-use, when-not-to-use, or alternative recommendation (e.g., use add_track for copper). Guidance is inferred rather than 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?

No annotations are provided, so the description carries the full behavioral burden for a mutation tool. It notes the schematic must be open but says nothing about whether the label persists, requires a save, is undoable, or what happens on invalid coordinates.

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 purpose sentence is front-loaded and the Args block is terse. Efficient overall, with no filler sentences, though the Args formatting is raw docstring output.

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?

An output schema exists, so return values need not be described. However, for a mutation tool with zero annotation coverage, the description is silent on side effects, save requirements, and failure modes.

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

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

Schema description coverage is 0%, but the Args block documents all three params: text as the net name, and x_mm/y_mm as position in mm. This compensates for the bare schema, though it adds no constraints, valid ranges, or units beyond 'mm'.

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: 'Add a local net label to the open schematic.' An agent can distinguish this from siblings like add_schematic_text or list_labels from the wording alone, though it doesn't explicitly call out which sibling to prefer.

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 versus add_schematic_text, add_text, or other annotation tools. The only contextual cue is the implicit prerequisite of an 'open schematic.'

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

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

No annotations are provided, so the description carries the full burden. It does not disclose whether the tool requires an open board, what permissions are needed, whether the operation is undoable, or any other behavioral trait beyond the fact that it creates a polygon.

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

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

The description is front-loaded with the purpose and then uses a clear Args block. It is concise and every sentence contributes. It could be slightly tighter, but it is well-structured for its 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?

An output schema exists, so return values need not be explained. However, the description lacks usage context, does not mention the default layer or that a board must be open, and offers no behavioral guidance. For a 4-parameter creation tool with no annotations, it is only minimally viable.

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

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

With 0% schema description coverage, the description must compensate. It explains the points format ('each {"x_mm": .., "y_mm": ..} or [x, y]'), enforces a minimum of 3 points, and clarifies layer, width_mm, and filled. Only minor detail (e.g., layer default) is missing, but the description adds substantial meaning beyond the bare schema.

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

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

The description states a specific verb and resource: 'Add a graphic polygon.' This clearly identifies the action and object. However, it does not differentiate from sibling creation tools such as add_rectangle, add_circle, or add_zone, so it falls short of the top score.

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

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

The description provides no guidance on when to use this tool versus alternatives. There is no mention of prerequisites, context, or exclusions. It only lists parameters, leaving usage entirely inferred.

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

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

No annotations are provided, so the description carries the full behavioral burden. It says nothing about state effects on the board, whether changes are undoable, required document/permission context, or failure conditions for a mutating add 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?

Purpose is front-loaded in the first sentence, followed by a compact Args block with no filler. The Args-list format is slightly schema-like but every line adds semantic 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?

An output schema exists, so return values need no explanation, and parameters are covered. Still, for a mutating 7-parameter tool with zero annotation coverage, no usage context (which document must be open, relationship to other shape tools) 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?

Schema description coverage is 0%, so the description must compensate, and it does: it documents all seven parameters with units and meaning (x/y min as top-left, max as bottom-right, layer name, outline width in mm, filled solid fill). It omits the schema defaults (F.SilkS, 0.15, false), but the coordinate and width semantics are the key additions.

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 first sentence states a specific verb+resource ("Add a graphic rectangle"), so the operation is unambiguous. It does not distinguish itself from siblings like add_board_outline_rect, add_polygon, or add_line, leaving the agent to infer that this is a decorative/copper graphic rectangle rather than a board geometry primitive.

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 use this tool versus add_board_outline_rect, add_polygon, or add_zone_rect, nor any prerequisite (e.g. an open board/document). The description lists only parameters, so all routing context is left to inference.

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

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

No annotations are provided, so the description carries the full burden. It implies a mutation of the open schematic but says nothing about required state, whether the object is selectable/movable afterward, layer/grouping behavior, or failure modes when no document is 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?

The purpose sentence is front-loaded and the whole definition is short with no filler beyond a boilerplate 'Args:' block. Efficient, though the arg lines are near-duplicates of the schema.

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

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

For a 3-required-param mutation tool with no annotations and 0% schema coverage, the description is under-specified: it omits document-state requirements, anchoring behavior, and any post-condition. The presence of an output schema excuses it from explaining return values, but little else is covered.

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

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

Schema coverage is 0%, so the description must compensate, but it only restates the schema titles: 'text: Text string' and 'x_mm, y_mm: Position in mm'. The mm unit is the sole piece of added meaning, and it is largely echoed by the property titles 'X Mm'/'Y Mm'.

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+resource: 'Add a free text object to the open schematic.' The 'schematic' scoping distinguishes it from board-level siblings like add_text and add_line, though it never names a sibling 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 when-to-use guidance, no prerequisites (e.g. a schematic must be open), and no routing to alternatives such as add_text (board) or add_local_label (labels). The only implied context is the word 'open schematic'.

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

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

With no annotations, the description bears the full behavioral burden, yet it only lists parameters. It does not say whether the text is durably committed, whether it requires a specific layer/selection state, what happens on illegal layers, or whether it returns the created object.

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?

Purpose is front-loaded in one sentence, followed by a tight per-argument list. It echoes the schema property names but each line adds units or an example, so it mostly 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?

An output schema exists, so return values need not be described, and parameters are well covered. However, for a mutation tool with zero annotations, the description omits any behavioral or usage context, leaving 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?

Schema description coverage is 0%, so the description must compensate, and it largely does: it gives units (mm) for x_mm/y_mm/size_mm/thickness_mm, explains size_mm as glyph height and width, thickness_mm as stroke, and gives a concrete layer example 'F.SilkS'. This meaningfully exceeds what the bare schema titles provide.

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: 'Add free text to the board.' The word 'board' (versus schematic) implicitly separates it from add_schematic_text/add_local_label, but no sibling is named explicitly, 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 guidance, no prerequisites, and no mention of alternatives among the many sibling add_* tools. The agent must infer context 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?

With no annotations, the description carries the burden and does reasonably well: it discloses that width_mm defaults to the net's netclass width, that layer defaults to F.Cu, and that net_name must already exist on the board (a real precondition). It omits any note on permission/board-state requirements, whether the track is validated against clearance, or error behavior, keeping it short of a 5.

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

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

Front-loaded with purpose and the sibling redirect in the first two sentences, followed by a compact per-argument list. Every line carries information the schema does not; no filler or 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 7-parameter mutation tool with no annotations, the description covers purpose, defaults, preconditions, and alternatives, and an output schema exists so return values need not be explained. It is nearly complete, missing only failure/validation behavior and any hint about required board state.

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

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

Schema description coverage is 0%, so the description must compensate entirely and it does: all seven parameters are documented with units (mm) and meaning, and it explains the non-obvious semantic that a null width_mm resolves to the netclass width. Layer examples ('F.Cu', 'B.Cu') and the net existence constraint add value the schema lacks.

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 ('Add a straight copper track segment') and immediately distinguishes itself from siblings add_arc_track, add_track_path, and route_pads by scoping to a single straight segment. An agent can identify the tool's role without opening 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?

Explicitly routes the agent away from this tool toward route_pads and add_track_path with a stated reason ('they avoid hand-copied coordinates'). It does not spell out the condition under which add_track itself is the correct choice, but the guidance is clear and actionable.

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

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

With no annotations, the description carries the full burden and does meaningful work: it discloses that both ends are checked for connection and spacing, that rollback_on_conflict reverts the path on any clearance problem, and that net_name must already exist. It stops short of describing failure modes or return behavior, but that is partly covered by the output schema.

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

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

Front-loaded purpose sentence followed by a clean Args block; each line earns its place. Slightly loose phrasing in 'check both ends are connected and nothing is too close' 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 5-parameter mutation tool with no annotations, the description covers geometry format, net/layer requirements, width defaulting, and rollback behavior, and an output schema exists so return values need not be explained. Only permissions/preconditions beyond net existence are unaddressed.

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

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

Schema description coverage is 0%, so the description must compensate, and it documents all five parameters: the points value formats and the 'at least 2' constraint, the existence requirement for net_name with examples, layer meaning, width defaulting to the netclass width, and the exact rollback semantics of rollback_on_conflict.

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 ('draw a connected multi-segment track') and the scope ('through a list of points in one step'), which implicitly separates it from the single-segment sibling add_track. It does not explicitly name an alternative, 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?

Usage is implied by 'in one step' and the connectedness check, but the description never says when to prefer this over add_track, add_arc_track, route_pads, or autoroute, nor any prerequisites beyond 'net must exist'. Clear context, but no explicit alternatives or exclusions.

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

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

With no annotations, the description carries the full burden. It usefully discloses that diameter/drill default from the netclass and that the tool reports clearance problems with other nets on the outer layers. However, as an implicit write operation it says nothing about permissions, whether the placement is reversible, or what happens on netclass mismatch.

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 primary action and its key default behaviors are front-loaded in the first sentence, followed by a tidy Args block. It is slightly longer than strictly necessary but every line maps to a parameter or behavior, so nothing is 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?

An output schema exists, so return structure need not be spelled out. The description still adds the key return-side signal (clearance conflict reporting) plus defaults and constraints. Coverage of behavior is solid, with only the write/authorization semantics left implicit.

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

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

Schema coverage is 0%, so the description must carry all semantics, and it does: it documents units (mm), the geometric role of x_mm/y_mm as the via centre, the netclass-derived defaults for diameter_mm and drill_mm, and the constraint that net_name must exist on the board. This fully compensates for the empty schema descriptions across all 5 parameters.

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

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

The description opens with a specific verb+resource: 'Add a through via at a position', and adds meaningful scope (sizing defaults from netclass, clearance reporting). The via resource is unambiguous against siblings like add_track/add_zone, though no sibling is named explicitly. Clear but not differentiated by name.

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

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

There is no explicit when-to-use, when-not-to-use, or named alternative. The reader must infer usage purely from the action description; the only contextual precondition is that the assigned net 'must exist on the board', which is a parameter constraint rather than routing guidance.

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

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

With no annotations, the description carries the full behavioral burden. It usefully explains that refill runs after creation and is slower and reflects in the editor, but it omits permissions required, whether existing zones are affected, and the mutation's reversibility or side effects.

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

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

The description is front-loaded with a one-sentence purpose, followed by an Args block with one line per parameter. Every sentence and line earns its place with 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?

The output schema exists, so return values need not be explained, and the description thoroughly covers the six parameters for a mutation tool. It is slightly incomplete on usage routing and broader behavioral traits such as authentication or destructive effects.

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

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

Schema description coverage is 0%, so the description must compensate, and it does: all six parameters are documented with formats, required minimums, examples, defaults, and semantics such as points as vertices, layers as names, and net_name as the pour connection.

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: 'Add a copper zone (filled pour) bounded by a polygon outline.' The 'polygon outline' phrasing implicitly distinguishes it from sibling add_zone_rect, so an agent can identify the intended operation.

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

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

The description explains what the tool does but gives no explicit when-to-use guidance, no prerequisites, and no comparison with alternatives like add_zone_rect or refill_zones. Usage context is left to inference.

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

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

No annotations are provided, so the description carries the full behavioral burden. It discloses that refill zones after creating and that it wraps add_zone, but it omits mutation side effects, permission needs, and what happens to existing overlapping zones, leaving notable gaps for a write operation.

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

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

The description is front-loaded with the purpose and then presents parameters in a clean Args list. Every line earns its place, and there is no redundant or filler text.

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

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

Given 9 parameters, 0% schema description coverage, no annotations, and an output schema that handles return values, the description is only partially complete. It thoroughly documents parameters but lacks usage guidance and behavioral safety details, so an agent still has to infer important context.

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

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

Schema description coverage is 0%, so the description must compensate, and it does: it explains all nine parameters, including coordinate corner semantics, layer names, net names, optional name, priority, and refill. Examples are given for layers and net_name, adding meaningful clarity beyond the bare schema titles.

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: 'Add a rectangular copper zone'. It also distinguishes itself from the sibling add_zone by identifying itself as a 'convenience wrapper around add_zone', so an agent can tell it apart without opening 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?

It names the underlying alternative (add_zone) and implies this tool is for rectangular zones, but it does not explicitly state when to choose this over add_zone or other shape tools, nor does it list exclusions. Usage is implied rather than spelled out.

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

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

With no annotations provided, the description carries the full burden and does well: it discloses the kicad-cli read path, the save-first requirement, current-propagation from loads back through regulators/drivers/series parts, the structured 'questions' return on missing data, and the 'unverified_parts' flagging of database values. It stops short of stating whether the tool mutates anything or how heavy/long the run is, but the behavioral picture is substantially richer than a bare 'analyze' verb.

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 text is long but front-loaded (purpose first, then runtime behavior, then remediation workflow, then args) and each block earns its place. The workflow and per-arg guidance are genuinely load-bearing rather than padding, though it could be trimmed slightly and the args section duplicates some schema-documented structure.

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 complex 6-param analysis tool, the description covers the input contract, the runtime preconditions, and the shape of the response keys an agent must act on ('questions', 'unknown_parts', 'unknown_connectors', 'unverified_parts'). Since an output schema exists, detailed return-field documentation is not required, and nothing critical for correct invocation 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?

Schema description coverage is 0%, so the description must compensate fully — and it does. Every one of the 6 parameters is explained with meaning the schema cannot convey: the schematic_path accepted extensions and default, external_loads value shapes ({"J2": 2.5} vs {typ_a/max_a/note}) plus the 'pins' restriction for multi-pin connectors, sources defaults, net_voltages purpose for regulator dissipation, and the role of temp_rise_c/copper_oz in width suggestions.

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 opening sentence gives a specific verb and resource ('Estimate how much current every supply net carries, from the schematic, and suggest track widths / net classes'), which clearly differentiates it from siblings like calc_track_width (geometry-only) and set_part_current (writes database values). The scope ('works for any kind of board') and inputs are unambiguous.

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

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

It states the prerequisite ('Reads the saved schematic via kicad-cli (save it first)') and a full remediation workflow when data is missing (answer questions, resolve unknown_parts via datasheets + set_part_current, unknown_connectors via external_loads). It does not explicitly contrast itself with alternatives such as calc_track_width or check_clearance, so an agent must infer when this tool is preferred.

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

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

No annotations are provided, so the description carries the burden. It usefully discloses atomicity ('one undo step') and the fallback behavior of courtyard-to-courtyard packing when pitch_mm is omitted, which is real behavioral context. It is silent on permissions, whether existing placements or locks are affected, and error behavior for non-existent 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?

Front-loads the one-line purpose, then a structured Args block where every entry adds distinct meaning. Slightly verbose in places (the multi-line pitch_mm entry) but nothing is 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?

An output schema exists, so return values need not be explained. For a mutation tool with 7 parameters and no annotations, the description covers purpose, atomicity, and all parameter semantics well. It could add one line on prerequisites (e.g., parts must exist / be unlocked) to be fully complete.

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

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

Schema coverage is 0%, so the description must carry all parameter meaning, and it does: it documents references ordering with an example, the start origin, the pitch-vs-gap interaction and fallback, direction values ('x' row / 'y' column), and angle_deg as an absolute rotation. This is comprehensive compensation for a completely undescribed schema.

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

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

States a specific verb+resource+scope: 'Line several parts up in a row or column in one undo step.' The agent can distinguish this from single-item siblings like move_footprint or rotate_footprint. It does not explicitly name a sibling alternative like place_relative or batch_move_footprints, so the sibling differentiation is implied rather than stated.

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 'one undo step' phrasing implies this is the atomic way to arrange multiple parts at once, and the pitch/gap/direction semantics imply the batch-arrangement use case. However, there is no explicit when-to-use vs when-not guidance and no mention of alternatives such as place_relative for single-part placement.

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

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

With no annotations, the description carries the full burden and does so: it discloses that the open board is saved and backed up to <board>.pre-autoroute.kicad_pcb, that routing happens on disk then reloads, that this wipes the editor undo history, that existing tracks are locked, and that zones are refilled and DRC run afterward.

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

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

Front-loads the action, then workflow, then side effects, then args — well structured. Slightly long, and the Args block partly restates parameter names, but each entry adds semantics rather than padding.

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 complex, side-effecting operation it covers prerequisites, destructive consequences (undo history loss, backup as the way back), post-steps (zone refill, DRC), and points to the 'drc_after' result field; with an output schema present it need not detail return values further.

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

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

Schema description coverage is 0%, so the description must compensate, and it does: all five parameters are explained with meaning beyond their names (max_passes needs Freerouting 2.2+, timeout_s is a hard limit in seconds, lock_existing keeps tracks in place, skip_netclasses takes e.g. ['HighCurrent'], board_file routes an on-disk file instead of the open board).

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+resource ('Route the remaining connections with Freerouting') and scopes it to what is left unrouted, which distinguishes it from sibling adders like route_pads, add_track, and add_track_path.

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?

Gives an explicit ordered workflow ('set net classes (configure_netclasses), route or pour the high-current nets yourself, then autoroute the rest with those classes in skip_netclasses'), naming the prerequisite tool and the when-not condition for high-current nets.

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

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

With no annotations, the description carries the full burden. It usefully discloses that all moves occur in a single undo step, but omits permission requirements, error handling, and behavior for missing or locked footprints.

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 purpose is front-loaded in one sentence, followed by a compact Args block and a concrete example. Every part earns its place with 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 mutation tool with no annotations and a vague schema, the description covers the essential call shape and the undo grouping behavior. Remaining gaps are minor but real: it does not state whether x_mm/y_mm are absolute coordinates and does not describe failure handling for invalid references.

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 nested moves array has no property documentation. The description fully compensates by naming required keys 'reference', 'x_mm', 'y_mm', optional 'angle_deg', and providing a concrete example.

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 (move/rotate), resource (footprints), and scope (several in one undo step). This clearly distinguishes it from sibling single-item tools like move_footprint and rotate_footprint.

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

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

The description implies batch use through 'several footprints in a single undo step,' but gives no explicit guidance on when to prefer this over individual move/rotate calls or arrangement tools like arrange_row. Usage is inferable but not spelled out.

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

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

With no annotations, the description carries the full behavioral burden; it does disclose the conditional behavior (length triggers resistance/drop/loss) and the physical model nuance that inner layers need ~2.5x width because they cool worse. It never states that this is a side-effect-free calculation that does not touch the board, which is the key thing an agent needs to know amid a set of mutating siblings.

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

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

Front-loaded summary sentence followed by a compact, line-per-parameter Args block; no filler. The opening is a noun phrase rather than a verb clause, a minor structural weakness, but the content is tight and well organized.

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?

An output schema exists, so return values need no explanation, and every input is documented. For a side-effect-free calculator it is nearly complete; it could still note the assumption set (e.g., ambient, formula basis) but nothing essential to correct invocation 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?

Schema description coverage is 0%, so the description must compensate and it does: all five parameters are documented with units (amps, C, mm, oz), defaults, and physical meaning, including the non-obvious semantics of internal_layer. This fully covers the gap left by the bare schema.

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

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

The opening sentence names a specific computation (IPC-2221 minimum track width) tied to a specific input (current), and adds the two conditional outputs (resistance and voltage drop) that only appear when length is supplied. An agent can immediately distinguish this from board-mutation siblings like add_track since it is a pure calculation.

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 'use this when...' vs alternative routing (the closest sibling, analyze_power_budget, is never mentioned). However, the arg documentation embeds practical selection guidance such as '10 C is conservative' and '1 oz = 35 um is the usual default', which helps with invocation but not with tool 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?

No annotations are provided, so the description carries the disclosure burden. It clearly states the check is approximate and that run_drc is authoritative, but does not explicitly state that it is read-only and does not modify the board, leaving a minor gap for a no-annotation tool.

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

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

The description is front-loaded with the tool's purpose, then scope guidance, then the important authoritative-tool caveat. The Args section is minimal and every sentence adds useful 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?

An output schema exists, so return values need not be described. The description adequately covers purpose, scoping, and approximation caveat, though with no annotations a brief explicit read-only note would make it fully complete.

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

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

The sole parameter is undocumented in the schema (0% description coverage), but the description compensates fully: item_ids are track KIIDs, and an empty value checks every track on the board. This adds essential runtime semantics beyond the bare anyOf schema.

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

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

States a specific verb and resource: clearance check of tracks against other nets' copper, including the relevant copper types (tracks, vias, pads) and the netclass-clearance basis. It also distinguishes itself from the authoritative sibling run_drc.

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

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

Explicitly explains how to scope the check via track KIIDs, what an empty argument means, and names run_drc as the authoritative alternative for final verification. The agent can choose between quick approximate checking and authoritative DRC without inference.

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

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

No annotations are provided, so the description carries the burden. It discloses which measurements are produced and the interpretation of airwire length ('lower usually means easier routing'), which implies a read-only analysis, but never states that nothing is modified, nor any cost, permissions, or side effects.

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

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

The description is short and front-loaded: the measurement scope comes first, then the interpretation, then per-argument notes. No filler sentences, though the line-wrapped arg notes are slightly less polished.

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?

An output schema exists, so return values need not be described. Combined with the metric list and fully explained parameters, the definition gives an agent enough to call it correctly; only mutation-safety and inter-tool routing are left implicit.

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

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

Schema coverage is 0%, so the description must compensate, and it does: exclude_nets is explained with a concrete typical value ('GND') and the reason (a ground pour will connect it), and top_airwires is explained as the count of longest airwires to list. Both parameters gain meaning beyond the bare schema.

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

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

The description opens with a specific verb and resource ('Score the current placement') and enumerates the exact metrics computed: courtyard overlaps, off-board parts, and total airwire length. This clearly separates it from siblings like check_clearance or run_drc, though it never names those alternatives 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?

It gives a workflow hint ('compare before/after when moving parts'), which implies usage during iterative placement, but offers no explicit when-not guidance or comparison against the similar-sounding check_clearance and run_drc siblings.

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

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

With no annotations, the description carries the full behavioral burden, and it offers no details beyond the operation itself. It does not clarify whether this is an in-memory/UI state change or a persistent board modification, nor any side effects or permissions.

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, complete sentence with no wasted words and the key action front-loaded. It is appropriately sized for a simple zero-parameter operation.

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 tool with an output schema, the description is largely sufficient; return values need not be explained. The only gap is the lack of usage context, which is a minor miss given the operation's self-evident nature.

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 baseline is 4. There are no parameter semantics to document, and the schema fully covers the empty argument 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?

The description states a specific verb ('Clear') and resource ('current selection') with scope ('in the PCB editor'). It is clearly distinguishable from siblings like get_selection or select_items, though it does not explicitly name an alternative to route the agent.

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, prerequisites, or mention of alternatives is provided. The agent must infer that this is used to deselect everything, with no explicit context for choosing it over related selection tools.

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

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

With no annotations the description carries the full burden and does well: it explains that KiCad would overwrite the change on next save, that replace_patterns drops all existing patterns (a destructive effect), and that priority 'lower wins' on overlap. It does not cover permissions or failure modes, but for a local file-editing tool the disclosure is strong.

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 purpose and the project-must-be-closed constraint are front-loaded before the args. The args block is long but every line documents a distinct key or behavior, so it earns its space; only mild verbosity keeps it off 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 5-parameter mutation tool with no annotations and an output schema already present, the description supplies the preconditions, per-field semantics, nesting example and destructive behavior needed to call it correctly. Nothing material 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?

Schema description coverage is 0%, so the description must compensate, and it does: it enumerates the classes object keys (name required, nets with KiCad wildcard/root-sheet matching, current_a IPC-2221 sizing vs track_width_mm, clearance_mm, via_diameter_mm, via_drill_mm, priority) and explains project_path, temp_rise_c, copper_oz and replace_patterns, with a concrete example.

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+resource ('Create/update net classes and assign nets to them') plus the target artifact (.kicad_pro file). An agent can distinguish it from read-only siblings like list_netclasses and get_netclass_config without opening a 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?

Gives a critical precondition ('The project must be CLOSED in KiCad ... Reopen it afterwards') and the current-vs-fixed width choice. However it never explicitly routes to alternatives (e.g. use list_netclasses/get_netclass_config to inspect first), so it is clear context rather than full when/when-not/alternative guidance.

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

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

No annotations are provided, so the description carries the full disclosure burden. It usefully reveals '(single undo step)', which tells the agent deletion is reversible in one action, but it omits any permission/scope requirements or what happens to dependent items. Partial but genuine behavioral value.

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

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

Front-loaded with the action, then the undo qualifier, then a short Args block. Efficient overall; the Args line slightly restates the schema but stays brief.

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?

An output schema exists, so return values need not be explained. For a one-parameter destructive tool the description covers the action, the ID source, and undo behavior, leaving only permissions unaddressed.

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 has 0% schema description coverage, so the description must compensate, and it does: it names item_ids as KIID strings and specifies they come from any list_* tool, which is real sourcing guidance beyond the bare array-of-strings schema.

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

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

States a specific verb (Delete) and resource (board items) and qualifies the identifier type (KIID strings). No sibling competes for this operation, and an agent can immediately tell it apart from select_items, set_items_locked, or the list_* 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?

The clause 'Item KIID strings from any list_* tool' implies the upstream workflow (obtain IDs via a list tool), but there is no explicit when-to-use guidance, no when-not, and no named alternative. Usage is inferred rather than stated.

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

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

With no annotations, the description carries the full burden and does well: it discloses in-process execution, the pre-bound names, nanometre internal units, undo grouping via a commit context manager, result-variable return, stdout capture, and autosave semantics. It stops short of flagging that arbitrary code can be destructive or irreversible, which is the one behavioral caveat an escape hatch should spell out.

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

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

Front-loaded with the purpose and escape-hatch framing, then organized into bindings, conventions, args, and a worked example. The example is lengthy but earns its place for an arbitrary-code tool; the block is dense with no filler sentences.

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 complex, full-control tool with no annotations and 0% schema coverage, the description supplies everything needed to invoke it safely and correctly: available bindings, unit conventions, mutation pattern, and output channel. An output schema exists, and the description reinforces rather than duplicates 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 0%, so the description must compensate, and it does: it explains that `autosave` saves the open board after the code runs (conditional on a board being open) and defines how `code` communicates output via a `result` variable and captured stdout. The `code` parameter itself is only trivially described, keeping this from a 5.

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

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

States a specific verb and resource ('Run arbitrary Python against the live KiCad session') and immediately frames the scope as a FULL-CONTROL escape hatch. The routing statement 'anything not covered by a dedicated tool' cleanly distinguishes it from the 70+ dedicated siblings like add_track or move_footprint.

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?

Gives an explicit selection rule: use this only for what the dedicated tools don't cover, which is exactly the decision an agent faces given the dense sibling list. It also names the prerequisites implicitly (a live session, an open Board/Schematic) and the fact those bindings may be None.

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

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

No annotations are provided, so the description carries the full burden. It does disclose the two useful behavioral facts that this is a pure string transform and that values come from the project's variable store, but it is silent on what happens when a referenced variable is undefined or malformed.

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

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

Front-loaded one-sentence purpose, then a compact Args block. The parameter line is mildly redundant with the first sentence but earns its place by giving the ${VAR} format.

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?

An output schema exists, so return-value shape is already covered, and the tool takes one simple parameter. The description is nearly complete for such a small tool; only the undefined-variable/error behavior is unaddressed.

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

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

Schema coverage is 0% and the single parameter has no schema description, but the description compensates by documenting the expected content ('Text possibly containing ${VAR} references'), telling the agent the input format beyond the bare string type.

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+resource ('Expand ${...} text variables in a string') and the data source ('the project's values'), which is enough for an agent to distinguish it from the sibling get_text_variables/set_text_variable tools. It stops short of naming those siblings explicitly, so it lands just below the top band.

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

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

Usage is implied by the purpose: it is the tool that turns stored variables into resolved text, versus get_text_variables (list) and set_text_variable (define). However, no explicit when-to-use, when-not-to-use, or alternative is stated, so the agent must infer the routing.

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

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

No annotations are provided, so the description carries the full burden. It usefully discloses the save_first behavior and that schematic_path defaults to the open project, but says nothing about overwriting an existing CSV, required permissions, or side effects of the export. Partial behavioral context only.

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

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

Front-loaded with the purpose sentence, then a compact Args list that maps cleanly to the parameters. Minimal waste, though the leading and trailing whitespace and bare 'Args:' block are slightly less polished than prose.

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 an output schema present, return values needn't be explained, and the three parameters are covered. However, for a file-writing export tool with no annotations, the description omits overwrite behavior and failure modes, leaving an agent without enough to predict side effects.

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

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

Schema coverage is 0% and 3 parameters exist, so the description must compensate and largely does: it documents output_path as the destination .csv, schematic_path as an explicit .kicad_sch defaulting to the open project, and save_first as saving before export. It adds real meaning beyond the bare schema, though it doesn't clarify path format or relative-vs-absolute handling.

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 (Export), resource (bill of materials CSV), and source (the open schematic). This cleanly distinguishes it from siblings like export_netlist, export_gerbers, and export_pdf, so an agent can route correctly without opening 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?

The description implies usage context (requires an open schematic or an explicit schematic_path) but never states when to prefer this over sibling export tools or any exclusions. Usage is inferable but not spelled out.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It adds some useful context: output_dir is 'created if needed' and save_first 'Save the board before exporting.' However, it does not disclose whether existing files are overwritten, what happens on failure, or any permission requirements, leaving meaningful behavioral gaps.

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

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

The description is tightly structured: a single-sentence purpose statement followed by a compact Args section. Every sentence serves a purpose, and the core action is front-loaded. No wasted words.

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

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

For a simple export tool with an output schema already documenting return values and no annotations to cover, the description is largely complete. It covers purpose and both parameters adequately. A minor gap remains regarding overwrite behavior and error conditions, but these are not critical for basic invocation.

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

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

Schema description coverage is 0%, so the description must compensate for the schema's lack of parameter documentation. It defines both parameters: output_dir as the destination directory (created if needed) and save_first as saving the board before exporting. This adds clear meaning beyond the bare schema titles, though it could include more detail on path format or overwrite 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 states a specific verb and resource: 'Export drill files (Excellon) for the open PCB into a directory.' It clearly distinguishes this tool from other export siblings (e.g., export_gerbers, export_step) by naming the exact file type and format. An agent can identify the tool's purpose without opening 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?

The description offers no explicit guidance on when to use this tool versus alternatives like export_gerbers or export_pos. It merely restates the tool's action, leaving the agent to infer usage context entirely. No prerequisites, exclusions, or comparative conditions are provided.

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

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

No annotations are provided, so the description carries the full burden. It discloses that output_dir is created if needed, that empty layers exports all enabled plottable layers, and that save_first saves the board before exporting. However, it omits important write-safety details such as whether existing files are overwritten or how errors 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?

Front-loads the purpose in one sentence, then uses a clean Args list. No redundant or filler text; every sentence earns its place.

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

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

For a 3-parameter export tool with no annotations and an output schema, the description covers purpose, parameter semantics, and key side effects well. It lacks usage routing among sibling export tools and edge-case behavior like overwrite handling, but is otherwise complete.

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

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

Schema description coverage is 0%, so the description must compensate. It fully documents all three parameters: output_dir (created if needed), layers (comma-separated list with example and empty default meaning all enabled plottable layers), and save_first (saves board before exporting). This adds substantial meaning beyond the bare schema.

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

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

States a specific verb ('Export') and resource ('Gerber files for the open PCB'), with clear scope ('into a directory'). The file format inherently distinguishes it from sibling export tools like export_drill or export_step, though no sibling is named 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 explicit when-to-use guidance or alternatives are provided. It only implies use when Gerber files are needed, without helping the agent choose between this and other export_* siblings.

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

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

There are no annotations, so the description carries the full behavioral burden. It does disclose a real side effect — that the schematic may be saved first — but says nothing about file overwrite behavior, failure modes, or permissions. Given zero annotation coverage, this is a partial but incomplete behavioral picture.

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?

Purpose is front-loaded in the first sentence, followed by terse per-argument notes. No wasted sentences, though the docstring 'Args:' block is functional rather than elegantly integrated.

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?

An output schema exists, so return values need no explanation, and all three inputs are documented. For a simple single-target export tool with no annotations, the description is nearly complete; only behavioral edge cases are missing.

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

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

Schema description coverage is 0%, so the description must supply parameter meaning, and it does: it documents all three params, gives a format hint (e.g. .net), explains schematic_path defaults to the open project, and clarifies save_first's behavior. This substantially compensates for the bare schema.

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

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

States a specific verb+resource ('Export a netlist') and the source ('from the open schematic'), which cleanly separates it from the export_gerbers/export_step/export_bom siblings. It does not explicitly name an alternative, but the purpose is unambiguous.

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

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

No when-to-use guidance, prerequisites, or alternatives are given. The reader must infer that this runs against the currently open project. Nothing tells the agent when netlist export is the right choice versus other export 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?

No annotations are provided, so the description carries the full burden. It does disclose one meaningful behavioral trait – that the board is saved before export (default true) – via the save_first argument, but it says nothing about overwriting an existing PDF, what the plot contains, or whether this requires a loaded document.

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 purpose sentence is front-loaded and the Args block is terse, with no filler. The key action and scope are readable at a glance.

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?

An output schema exists, so return values need not be described, and all three inputs are covered. For a simple one-shot export tool the picture is nearly complete; only when-to-use routing and overwrite behavior are missing.

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

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

Schema description coverage is 0%, so the description must compensate, and it does document all three parameters: output_path as the destination .pdf, layers as a comma-separated list, and save_first as a pre-export save. It omits the schema defaults (F.Cu,B.Cu,Edge.Cuts and true), which would be useful for an agent choosing whether to pass layers at all.

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

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

The description states a specific verb and resource ('Export a PDF plot of selected PCB layers'), and the PDF format implicitly distinguishes it from siblings like export_gerbers, export_svg, and export_step. It stops short of explicitly naming an alternative, so it is clear but not fully sibling-differentiated.

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 the other export_* siblings or when it is unnecessary. The agent must infer the use case entirely from the purpose sentence.

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

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

With no annotations, the description carries the full behavioral burden. It does disclose that save_first saves the board before exporting, and it defines the allowed values for fmt and side. However, it omits key behaviors such as whether output_path is overwritten, whether the board must already be open, and any error conditions or side effects.

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

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

The description is compact and front-loaded: the purpose appears in the first sentence, followed by a clear Args list. Every sentence contributes useful information, and there is no redundant 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?

The tool has 4 parameters, no annotations, and an output schema (so return values need not be explained). The description covers purpose and parameter meanings, but it lacks usage routing among sibling exports and deeper behavioral context such as overwrite behavior and preconditions, leaving gaps for an agent with no annotation support.

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

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

Schema description coverage is 0%, so the description must compensate, and it does document all four parameters, including the allowed values for fmt ('csv', 'ascii', 'gerber') and side ('front', 'back', 'both'). It stops short of stating defaults (csv, both, true) or output_path format constraints, but it adds substantial meaning beyond the bare schema.

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

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

The description states a specific verb and resource: 'Export a component placement (pick-and-place) file.' This clearly distinguishes it from sibling export tools such as export_gerbers, export_bom, or export_step. An agent can immediately tell what this tool produces without opening 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 guidance about when to use this tool versus the many other export tools in the sibling list. It does not state prerequisites or conditions, such as requiring an open board or needing the board saved first. The argument list is informative but does not address usage context.

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

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

No annotations are provided, so the description carries the full burden. It does disclose one real behavioral trait — that save_first saves the board before export, a side effect worth knowing — but says nothing about overwrite behavior, required permissions, or what the tool writes beyond the destination 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?

Front-loaded one-line purpose followed by a tight Args block; no waste. The Args format is a docstring convention rather than prose, but it is efficient and readable.

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?

An output schema exists, so return values need no explanation, and both parameters are covered in the description despite 0% schema coverage. It is adequate for a simple two-parameter export, with only minor gaps around failure/overwrite behavior.

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

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

Schema description coverage is 0%, so the description must compensate, and it largely does: it explains output_path as the destination .step/.stp file and save_first as a pre-export save. It adds meaning beyond the bare property names, though it omits the save_first default value already encoded in the schema.

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

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

States a specific verb (Export) and resource (3D STEP model of the open PCB), which cleanly distinguishes it from sibling exports like export_gerbers, export_pdf, export_svg, export_pos and from render_3d. An agent can pick it out without opening any 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?

No when-to-use context, no prerequisites, and no reference to the obvious alternative (render_3d) or related exports. The agent is left to infer that this is the STEP-specific export path.

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

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

With no annotations, the description carries the full burden. It usefully discloses the save_first side effect (board is saved before exporting) and that output goes to a file, but says nothing about overwrite behavior, whether directories are created, required permissions, or error conditions for an invalid 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?

Front-loaded with the core action in the first line, followed by a compact per-parameter list. Efficient with little waste, though the Args block largely restates parameter names already visible in the schema.

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

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

An output schema exists, so return values need not be explained. All three parameters are addressed and the save-first behavior is noted, making it adequate for invoking the tool; only format-selection reasoning relative to sibling exporters 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?

Schema description coverage is 0%, so the description must compensate, and it documents all three parameters: output_path as a destination .svg file, layers as comma-separated layers, and save_first as saving the board first. It omits the default layer set (F.Cu,B.Cu,Edge.Cuts) and the save_first default of true, which schema provides separately.

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 (Export) and resource (SVG plot of selected PCB layers), which is clear and distinct from sibling exporters like export_pdf and export_gerbers. It stops short of explicitly telling the agent how it differs from those format alternatives, so it is clear but not sibling-differentiating.

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 export_svg over export_pdf, export_gerbers, or render_3d, nor any prerequisites (e.g., a board must be open). Usage is only implied by the tool's name and the word 'selected'.

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

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

With no annotations, the description carries the full burden. It usefully discloses the key side effect (mirrored in place on the opposite board side), but says nothing about permissions, selection requirements, what happens on failure, or whether the footprint's position is otherwise preserved.

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

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

Two sentences with the effect front-loaded and the parameter restated compactly. Every line earns its place; 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 mutation with an output schema present, the description covers the essential transformation without needing to explain return values. It stops short on error/precondition behavior, which is minor at this complexity.

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

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

Schema description coverage is 0%, so the description must compensate. 'reference: Footprint to flip.' clarifies that the parameter identifies the target footprint, but doesn't specify the expected format (e.g. a reference designator like 'R1'), leaving a meaningful 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 (flip/move) and resource (footprint), and the parenthetical 'front <-> back, mirrored in place' precisely distinguishes it from siblings like move_footprint and rotate_footprint. An agent can tell this is a side-swap operation without opening 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?

The action is clear but there is no explicit when-to-use guidance, prerequisites, or comparison to the many placement siblings (move_footprint, rotate_footprint, place_near_pad). Usage is only implied by the stated effect.

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

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

No annotations are provided, so the description carries the full behavioral burden. It discloses what is inspected (Java version, jars, Python), which implies a read-only diagnostic, but it does not explicitly state that it has no side effects, requires no permissions, or is safe to call at any time.

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 lists the purpose and the exact checks performed. Every clause earns its place with no redundancy or filler.

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

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

Given a zero-parameter diagnostic tool with an output schema that documents return values, the description sufficiently explains what the tool reports. It is slightly incomplete in not stating usage timing or explicitly confirming read-only behavior, but the core information needed to call it correctly is present.

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

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

The tool has zero parameters and a 100% schema description coverage for an empty object. With no parameters to document, the baseline of 4 applies; the description cannot add parameter meaning beyond what the empty schema already provides.

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 ('Report') and a precise resource ('whether autorouting can run'), then enumerates the three checks: Java version, Freerouting jars, and KiCad's Python. This scope clearly distinguishes it from siblings like install_freerouting (installation), autoroute (execution), and kicad_status (broader KiCad status).

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

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

Usage is implied by the purpose ('Report whether autorouting can run'), suggesting it should be called before autorouting or when troubleshooting. However, it does not explicitly say when to use it, when not to use it, or name alternatives such as install_freerouting if prerequisites are missing.

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

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

No annotations are provided, so the description carries the full burden. The verb 'Return' does imply a non-mutating read, which is useful, but the description says nothing about ordering, whether text/dimensions on Edge.Cuts are included, or coordinate format. It stops short of the behavioral disclosure a no-annotation tool ideally provides.

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 the layer constraint front-loaded and the parenthetical gloss doing real clarification work. No filler words.

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

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

An output schema exists, so return-value shape need not be described, and this is a parameterless read tool. The only shortfall is the absence of a document-open precondition or a pointer to the more general list_shapes sibling.

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 of 4 applies.

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

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

States a specific verb ('Return') and resource ('all graphic shapes on the Edge.Cuts layer'), and parenthetically equates it to the board outline, which is genuinely clarifying for agents that don't know KiCad layering. It does not, however, distinguish itself from the neighboring list_shapes or get_bounding_box tools, which could plausibly return overlapping 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 preconditions (e.g., an open document), and no named alternative. An agent must infer from the name that this is the outline-specific query rather than a general shape listing.

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

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

No annotations are provided, so the description carries the burden of behavioral disclosure. The verb 'Return' and the listed output fields imply a safe read-only query, but the description does not explicitly state side effects, permissions, or whether an open board is required; it is adequate but not rich.

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

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

The description is two short sentences and front-loads the main purpose. The second sentence efficiently lists the returned data without unnecessary detail.

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

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

Given a simple zero-parameter, read-only tool with an output schema, the description is complete enough to call correctly. It summarizes the purpose and return contents, and the output schema handles detailed return-value documentation.

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

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

The tool has zero parameters, so the baseline is 4. The empty input schema is self-explanatory and there are no parameter meanings for the description to clarify.

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: 'Return counts and basic metadata for the open PCB.' It also enumerates the included data (element counts, copper layer count, board file name, bounding box extents), which distinguishes it from sibling listing tools such as list_board_layers and get_bounding_box.

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 explicit when-to-use guidance and names no alternatives. It implies this is for summarizing the currently open PCB, but it does not say when to prefer it over get_bounding_box, get_board_outline, or other summary/list 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?

No annotations are provided, so the description carries the burden. It usefully discloses that boxes are 'KiCad-computed' (authoritative source) and explains the include_text effect, but omits units, coordinate system, and whether the operation has any side effects or permissions requirements.

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-line purpose is front-loaded, followed by a compact Args block. No wasted prose, though the Args formatting is slightly redundant with a schema that already names both parameters.

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?

An output schema exists, so return values needn't be explained, and both parameters are covered in the description. The main gap is the absence of any statement about units or coordinate reference for the returned boxes, but overall it is sufficient for an agent to call the tool correctly.

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

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

Schema coverage is 0%, so the description must compensate, and it does: it explains that item_ids are KIID strings sourced 'from any list_* tool' and that include_text controls inclusion of child reference/value text in footprint boxes. These add real meaning beyond the bare schema types.

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

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

States a specific verb and resource: 'Return KiCad-computed bounding boxes for the given item IDs.' An agent can distinguish this from siblings like get_footprint_geometry or get_board_summary. However, it does not explicitly contrast itself with those neighbors, 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?

Usage is only implied through the parenthetical '(from any list_* tool)', which hints at a workflow but never states when to reach for this tool over alternatives like get_footprint_geometry or check_placement. No when-not guidance 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?

With no annotations, the description carries the full behavioral burden; it does disclose the connectivity semantics (copper-connected) and that input is identified by KIID, which is meaningful context. However, it omits whether results are direct-only or transitive, whether it is read-only, and any scope/limit behavior.

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

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

Two short lines, front-loaded with the core purpose before the Args block. Efficient, with no wasted sentences, though the Args formatting is slightly verbose for a single parameter.

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?

An output schema exists, so return values need not be described. Still, for a connectivity query the traversal depth (direct vs transitive) and result scope are materially important and unstated, leaving a genuine 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 0% (the schema only says 'string'), so the description must compensate, and it does: it names the argument and clarifies it is a KIID for a source track/via/pad. That is real meaning beyond the schema, though it could note valid KIID formats.

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 (find) and resource (items copper-connected to a given item), which is distinguishable from sibling queries like get_items_by_net or list_tracks. It does not explicitly contrast with those siblings, but the connectivity-based scope 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 gives no when-to-use guidance, no alternatives (e.g., get_items_by_net for net-membership queries), and no prerequisites. The agent must infer that this is a post-selection connectivity exploration 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?

With no annotations, the description carries the full burden and does disclose a genuinely useful behavioral trait: it is best-effort and falls back to an explanatory message when the KiCad build does not expose design rules over the API. It does not state permissions or whether the values are authoritative for DRC.

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, unit of measure front-loaded in the first line, degradation behavior second. Nothing extraneous.

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?

An output schema exists, so the description need not enumerate return fields; it still contributes the unit (mm) and the fallback behavior. Adequate for a zero-parameter read tool, though a note on how these rules relate to run_drc would complete 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 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 verb and resource ('Return the board's minimum design-rule constraints in mm'), which is clearly distinct from sibling checks like run_drc or check_clearance. It does not explicitly name or contrast against those siblings, 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?

The 'best effort' framing implies this is a lightweight read-only query, but the description never says when to call it versus run_drc, check_clearance, or get_netclass_config. Usage is only implied by context, 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?

No annotations are provided, so the description carries the full behavioral burden. It implies a read operation but does not state whether it returns cached or live data, what happens if the reference is not found, or what errors may occur. For a lookup tool with zero annotation coverage, this is minimal.

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

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

The description is front-loaded with the essential action and then uses a compact per-argument list. It is appropriately sized, though the docstring-style formatting is slightly less polished than a flowing description.

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?

An output schema exists, so return-value explanation is not required. Still, with no annotations and 0% schema description coverage, the description should say more about what 'full detail' includes and what happens on invalid references, leaving it only minimally complete.

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

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

Schema description coverage is 0%, so the description must compensate. It explains 'reference' with an example ('U1') and says 'include_pads' includes pads, which is slightly beyond the raw property titles. However, it does not explain the default behavior (true) or the format/shape of returned pads, so it only partially fills the 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 opens with a clear verb+resource: 'Return full detail for a single footprint by reference designator.' It distinguishes a detail-getter from the sibling list_footprints and get_footprint_geometry, though it does not explicitly name those neighbors.

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 or when-not-to-use guidance. With siblings like list_footprints and get_footprint_geometry present, the description should say when to use this detail-retrieval tool instead of listing footprints or fetching only geometry, but it offers no such routing.

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

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

No annotations are provided, so the description carries the full behavioral burden. It lists the data returned but never states that it is a read-only/non-mutating call, nor anything about permissions, cost, or failure modes; the only behavioral hint is the implicit 'get'.

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

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

Front-loaded with the return contents, then usage, then the arg; every sentence is functional. The 'Args:' block is slightly formal but not wasteful.

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

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

For a single-parameter read tool with an output schema present, the description supplies purpose, the one arg's meaning, and a usage trigger. The only omission is any behavioral/permission context, which for a non-annotated tool is a modest 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 0%, so the description must supply parameter meaning, and it does: it defines 'reference' as a reference designator and gives a concrete example ('U1'). That is more than the bare title in the schema.

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

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

States a specific resource (one footprint) and enumerates the exact contents returned: position, rotation, side, courtyard box, and every pad with number/net/position/size. It is clearly a geometry-read tool, though it never explicitly distinguishes itself from sibling get_footprint or list_footprints.

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?

'Use this before placing or routing around a part' gives a concrete workflow context for when to call it. It stops short of naming alternatives (get_footprint, get_bounding_box) or stating when not to use it, so it is clear context without exclusions.

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

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

No annotations are provided, so the description carries the burden. It discloses the output shape ('counts by type + IDs'), and 'Summarise' implies a read-only operation, but it says nothing about permissions, rate limits, or behavior on an unknown/nonexistent net.

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

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

Front-loaded single sentence plus an args block, with essentially no waste. Well sized for the operation.

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?

An output schema exists, so return values needn't be explained; the description still summarizes them. For a simple one-param read query, this is largely complete, missing only usage routing and edge-case behavior.

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

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

Schema coverage is 0% and the single param only has the title 'Net Name'. The description compensates partially by giving an example value ('GND'), which clarifies the expected format, but adds no rules for case-sensitivity or matching semantics.

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 ('Summarise') and resource ('every board item belonging to a net') with a clear output note (counts by type + IDs). This is distinguishable from list_nets or get_connected_items in spirit, though no sibling is explicitly named, 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 statement of when to use this tool versus alternatives like get_connected_items or list_tracks. Usage must be inferred entirely from the name and description, which is a clear 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?

No annotations are provided, so the description carries the burden. It discloses one useful behavioral detail: '.exe' is assumed on Windows, implying platform-specific path resolution. It says nothing about whether the binary is guaranteed to exist, whether installation is required, or any error behavior.

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

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

One sentence plus a compact Args block; the core purpose is front-loaded and every line earns its place. 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 trivial path-lookup utility with an output schema present, the description covers what the tool does and the one non-obvious parameter behavior. It is nearly complete; only a note on failure/absence of the binary would improve 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?

With one parameter and 0% schema description coverage, the description has to compensate, and it does: it defines binary_name as a 'short binary name' and explains the implicit '.exe' suffix behavior on Windows. The schema supplies the default value ('kicad-cli'), so the combination is adequate.

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: returns the full path to a bundled KiCad binary, with a concrete example ('kicad-cli'). It does not, however, differentiate itself from siblings like kicad_status or run_kicad_cli, which an agent might 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?

There is no indication of when to call this versus alternatives, nor any prerequisites or workflow context. The agent must infer that this is a utility for locating the CLI executable before running 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?

No annotations are provided, so the description carries the behavioral burden, and it does disclose a meaningful trait: it reads from the project file and functions without a running KiCad instance. It doesn't cover permissions, error behavior, or file-not-found cases, but for a read-only config read the added context is solid.

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

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

Front-loads the core action in the first clause, then the discriminating detail in the next sentence. The Args block is not redundant because the schema carries no parameter descriptions, so 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?

An output schema exists, so return values need no explanation, and the description covers purpose, selection rationale, and the one parameter's semantics. Nothing critical is missing for a simple read tool, though edge cases (bad path, missing project) are unaddressed.

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

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

Schema coverage is 0%, so the description must compensate, and it does: it explains project_path accepts a .kicad_pro file or its folder and clarifies what the empty default resolves to ('project of the open board'). This adds real meaning beyond the bare schema, though the accepted path resolution details remain thin.

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 (Read) and resource (net classes and net-to-class patterns) plus the exact source (the project file). It explicitly distinguishes itself from sibling list_netclasses by naming that tool and its different data source, so an agent can separate the two without opening either 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?

Gives an explicit condition for choosing this tool: 'works with KiCad closed,' contrasted against list_netclasses which 'reads the live values from a running KiCad.' The when-to-use and the alternative are both named directly.

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

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

No annotations are provided, so the description bears the full burden. It discloses the return content (project name and path), which implies a harmless read, but it never explicitly states that the call has no side effects or state requirements. For a zero-argument read tool the risk is minimal, so this is adequate but not rich.

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, front-loaded with the verb and the two things returned, with zero 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?

An output schema exists, so return details need not be spelled out, and there are no parameters to document. For a trivial read tool this is essentially complete, only missing an explicit note that it is a side-effect-free read of the active project.

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 clarify. The baseline for a parameterless tool applies.

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

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

The description states a specific verb (Return) and specific resources (the open project's name and path), so an agent immediately knows what it gets back. No sibling in the list covers the same ground, though the description never explicitly distinguishes itself from tools like get_kicad_binary_path or get_title_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 statement of when to use this tool versus alternatives, no prerequisites, and no exclusions. For a simple read tool this is tolerable, but the description leaves usage entirely to inference.

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

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

With no annotations, the description carries the full burden, and it does disclose two useful traits: the operation is a read ("Return") and it requires an open schematic plus KiCad 11+. It says nothing about failure behavior on older versions or when no document is open, leaving real gaps for a no-annotation 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 the action and scope stated first and the version caveat parenthetically appended; no wasted words.

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

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

The tool is simple (no parameters, no nested objects) and an output schema exists, so return values need not be described. The only shortfall is the absence of any note about behavior when no schematic is open or the KiCad version predates the feature.

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 baseline there is nothing for the description to clarify beyond what the empty schema already conveys.

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

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

The description names a specific verb and resource ("Return the sheet hierarchy of the open schematic") and scopes it to the currently open document, which clearly separates it from siblings such as get_schematic_summary or list_symbols. It does not, however, explicitly name or contrast with those siblings.

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

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

Usage is implied by "the open schematic" — the agent infers a document must already be open — and the "KiCad 11+ feature" note acts as a version prerequisite. There is no statement of when to prefer this over get_schematic_summary or what to do when the feature is unavailable.

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

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

No annotations are provided, so the description carries the burden; "Return" implies a non-mutating read, which is the key behavioral trait for a summary tool. It nonetheless omits whether the document must be open/active, what happens if none is open, and the shape of the result, leaving gaps for a zero-annotation 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 listing exactly what is counted, with no filler or redundancy.

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

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

An output schema exists, so the description need not enumerate return values, and for a zero-param summary tool the scope is adequately conveyed. The only remaining gap is the precondition that a schematic must be open, which is only weakly implied.

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 baseline is 4. There is no input to clarify, and the description correctly adds nothing spurious about inputs.

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 ("Return counts") and resource (symbols, labels, text, lines, sheets in the open schematic). This is clearly distinct from sibling list_symbols/list_labels/list_schematic_text, which enumerate items rather than summarize counts, though the distinction is implied rather than stated.

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 versus alternatives like list_symbols or get_schematic_hierarchy, and no prerequisites or exclusions are given. The phrase "in the open schematic" implies scope but not usage conditions.

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

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

With no annotations, the description carries the full behavioral burden. 'Return' implies a non-mutating read, but this is never stated explicitly, and there is no mention of what happens when nothing is selected. It does at least disclose the returned shape (id + type), which is modest added value given an output schema 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?

A single front-loaded sentence with no filler; the scope ('currently selected') and the return fields are stated in the fewest words possible.

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?

An output schema exists, so return values need no further explanation, and a zero-parameter read tool is inherently simple. The remaining gap is the absence of any edge-case note (e.g. empty selection) or linkage to the selection-manipulation 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?

The tool takes zero parameters and the schema is an empty object at 100% coverage, so the baseline of 4 applies. There is nothing for the description to clarify on the parameter front.

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 ('Return') and resource ('the items currently selected in the PCB editor'), so the agent can immediately tell what the call does. It does not, however, distinguish itself from closely related siblings such as select_items and clear_selection, which is what 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 when-to-use statement and no reference to alternatives like select_items or clear_selection, even though these tools read or manipulate the same selection state. The agent must infer usage purely from the tool 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?

With no annotations, the description carries the burden, but 'Return' plus the sibling set make the read-only nature sufficiently evident. It discloses the returned shape (layer order, type, thickness, material) which is useful context, though an output schema already exists to cover that.

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

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

A single sentence with the verb and resource front-loaded and no filler. Every clause earns its place by naming what the layers contain.

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 parameterless read tool with a full output schema and no annotations, the description covers what is returned and needs no return-value prose. The only gap is routing guidance against closely related layer/summary 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 there is nothing to document and no schema gap to compensate for; the baseline for a parameterless tool 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?

Specific verb ('Return') and resource ('board stackup'), with the returned content enumerated: ordered layers with type, thickness and material. That distinguishes it from the nearby list_board_layers, though the description never names that sibling 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 when-to-use guidance at all. The description does not say when a stackup read is appropriate versus list_board_layers or get_board_summary, both of which overlap in scope, so the agent must infer the choice.

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

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

With no annotations, the description carries the full behavioral burden. It implies a safe read operation through 'Return' and adds semantic context about ${VAR} substitution, but it does not disclose potential prerequisites, side effects, or limitations. For a simple zero-parameter getter with an output schema, this is adequate but leaves clear 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?

The description is a single front-loaded sentence with zero waste. Every word earns its place by naming the verb, resource, and a useful semantic detail about ${VAR} substitutions.

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