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

With no annotations, the description carries the full behavioral burden. It discloses the 45-degree geometry convention and that a dict with success status is returned, but omits mutation-relevant behavior: coordinate system origin, permissions, whether the entry can be undone/removed, and what happens if the position overlaps an existing wire.

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

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

Front-loaded with the action, followed by a compact conceptual note, then args/returns/example. The prose is useful rather than padding, but the conceptual paragraph could be trimmed slightly since the example already demonstrates usage.

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

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

An output schema exists, so return values need not be explained in depth, and the two parameters are thoroughly documented. The remaining gap is behavioral/mutation context (safety, reversibility, failure conditions) that no annotation covers for a write operation.

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

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

Schema description coverage is 0%, yet the description fully compensates: it documents 'position' as an (x, y) tuple in mm and 'rotation' as degrees with the allowed values (0, 90, 180, 270) plus the default of 0, which the schema itself does not express.

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

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

Specific verb+resource ('Add a bus entry to the schematic') with a clear conceptual explanation that bus entries connect individual wires to bus wires. This implicitly differentiates it from the sibling add_wire and add_bus_wire tools by describing the object's role, 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?

The description explains what a bus entry is and notes typical placement ('typically placed at a 45-degree angle'), which implies when it is appropriate to use. However, there is no explicit when-to-use vs add_wire/add_bus_wire guidance and no stated prerequisites (e.g., a bus wire must already exist at that location).

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 the return shape at a high level and that ctx is for progress reporting, but says nothing about prerequisites (e.g. must a schematic be loaded), whether the change is persisted or in-memory only, idempotency, or error behavior for malformed bus notation.

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 before Args/Returns/Examples, and the Args block is tight and informative. The two worked examples earn their place by showing valid bus-notation syntax, though the Returns line is vague and adds little.

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, and parameters are well covered. The remaining gap is behavioral: for a mutating tool with no annotations it never states prerequisites or side effects, leaving the agent without enough to call it safely in 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 coverage is 0%, so the description must compensate and largely does: it documents all four parameters, including the allowed rotation values (0/90/180/270) and the size default of 1.27 mm with a KiCAD-standard rationale. This is meaningful added meaning beyond the bare undescriptioned 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 ('Add a bus label to the schematic') and explains what a bus label is with concrete notation examples like 'DATA[0..7]'. It does not explicitly contrast itself with the sibling add_label for single-bit signals, so an agent must infer the distinction from the name.

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

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

The description implies usage by defining bus labels as multi-bit signal identifiers with range-notation examples, which guides when this tool applies. However, it never states when NOT to use it or names add_label as the alternative for scalar signals, so routing between the two label tools 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?

With no annotations, the description carries the full burden. It discloses return shape (success status + wire info) and the visual/styling semantics of a bus wire, but omits persistence behavior (whether the schematic must be saved), permissions, or undo semantics for what is 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?

Front-loaded one-line summary, then purpose, then Args/Returns/Example. Slightly long but every section earns its place, and the worked 8-bit bus example is genuinely useful.

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 the Returns note is redundant but harmless. For a mutation tool with zero annotations, the description should at least state whether changes are persisted to the schematic or require a subsequent save; 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: it does so by giving the (x, y) tuple form and the mm unit for both start and end, plus noting ctx is an optional MCP context for progress reporting.

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

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

Specific verb + resource ('Add a bus wire between two points') with scope clarified by contrasting bus wires against regular wires, which cleanly separates it from the sibling add_wire.

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 explains what a bus wire represents (multi-bit data/address buses, thicker styling), which implies when it applies, but never explicitly says when to prefer this over add_wire or how it pairs with add_bus_entry/add_bus_label.

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 that a missing reference is auto-generated (R1, C1, U1), that a missing position triggers auto-placement, that rotation defaults to 0, and that failures return ErrorOutput. It stops short of covering permissions, whether an open schematic is required, or side effects on existing design data.

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

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

The opening sentence is front-loaded and the Args/Returns/Examples structure is scannable. The two worked examples are useful for a call-shape-sensitive tool, though the Returns line partially duplicates the existing output schema and could be trimmed.

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

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

For a six-parameter mutation tool with an output schema available, the description covers intent, every parameter, defaults, auto-behavior, and failure mode, so an agent can call it correctly. The main remaining gap is environmental preconditions (schematic must be open) and any permission requirements, which are absent with no annotations to fall back on.

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

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

Schema coverage is 0%, so the description must compensate and it does: each parameter gets a plain-language meaning plus concrete format examples (lib_id 'Device:R', value '10k'/'100nF', position as (x, y) in mm, rotation limited to 0/90/180/270, footprint 'Resistor_SMD:R_0603_1608Metric'). This adds real meaning the schema alone does not convey.

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 component to the current schematic') and immediately clarifies that it creates a new component. This distinguishes it from siblings such as update_component, remove_component, and list_components without the agent needing to open 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?

Usage is implied by 'Add a component to the current schematic,' and the argument docs make the intended call shape obvious, but there is no explicit when-to-use guidance, no prerequisites (e.g., a schematic must be loaded first), and no routing to alternatives like update_component for existing parts. A reasonable agent can infer the case, but the description does not spell it 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?

No annotations are provided, so the description carries the full burden. It usefully discloses the diameter=0 default behavior and that a success-status dictionary is returned, but says nothing about whether the operation fails on duplicate junctions, whether it is idempotent, or what permissions/context are required.

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, then structured Args/Returns/Examples. The two examples are concrete and earn their place, though the Args and Returns sections partially duplicate the schema and output 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 two-parameter mutation tool with an output schema available, the description supplies purpose, parameter units/defaults, and return shape. It is largely complete, with the main gap being error/edge-case behavior, which the absent annotations do not cover.

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 largely does: position is documented as an (x, y) tuple in mm, diameter as mm with 0 meaning KiCAD default, and ctx as an optional MCP context. Units and the default sentinel add meaning the bare 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 wire junction at the specified position') and explains what a junction represents ('T-connections where three or more wires meet'), which conceptually distinguishes it from siblings like add_wire and connect_components.

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

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

Provides a real usage condition — 'required in KiCAD when a wire branches into multiple paths' — which tells the agent when a junction is needed. It does not, however, explicitly contrast with alternatives such as add_wire or connect_components, which would be needed for a 5.

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

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

No annotations are provided, so the description carries the full burden. It mentions a return value and shows examples, but does not state prerequisites (e.g., a loaded schematic), mutation side effects, whether changes require saving, or any constraints on duplicate labels. This is a significant gap 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 a clear purpose sentence, then structured into Args, Returns, and Examples. It is slightly long but every section adds value; the examples are helpful and not excessive.

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 that there are no annotations, an output schema exists, and four parameters have 0% schema coverage, the description is nearly complete: it documents all parameters, indicates return format, and provides usage examples. It falls short only on sibling routing and prerequisites, which would make it fully self-contained.

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

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

Schema description coverage is 0%, so the description must compensate. It documents every parameter with meaning, units, defaults, and allowed values: text as label net name, position as (x,y) in mm, rotation in degrees with allowed 0/90/180/270, and size in mm with the KiCAD standard default of 1.27. This is exactly what an agent needs.

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

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

The description states a clear verb ('Add') and resource ('net label to the schematic') and explains what net labels are used for. It does not, however, distinguish this tool from siblings like add_bus_label, manage_labels, or manage_global_labels, so sibling differentiation is absent.

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 the conceptual purpose of net labels ('name electrical nets and establish connections between non-physically connected wires'), which implies when to use one. But it gives no explicit when-to-use guidance or alternatives (e.g., when to use a global label instead), leaving the agent to infer.

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 says a wire is created and returns a dictionary with success status, but says nothing about permissions, whether the operation is reversible, error behavior for overlapping/duplicate wires, or side effects on existing nets. 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 tool intent is front-loaded, which is good, but the first two sentences are redundant restatements ('Add a wire between two points' / 'Creates a wire connection between start and end points'), and the two near-identical examples add little. The Args/Returns structure is orderly but partly wastes space.

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

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

An output schema exists, so return values are covered, and both parameters are explained. But with no annotations and no usage guidance relative to overlapping siblings like add_bus_wire and connect_components, the definition is only minimally complete for an agent choosing between tools.

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

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

Schema description coverage is 0% – the schema only shows two 2-element numeric arrays with no meaning. The description compensates well by naming both parameters, giving their format as an (x, y) tuple, and specifying units in mm, which the schema does not convey.

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 wire between two points', 'Creates a wire connection between start and end points') and clarifies the domain purpose ('connect component pins and establish electrical nets'). However, it never distinguishes itself from close siblings like add_bus_wire or connect_components, leaving the agent to infer the boundary.

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

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

There is no explicit when-to-use guidance or exclusion criteria. Given siblings such as connect_components and add_bus_wire that overlap semantically, the description should say when a plain wire is appropriate versus those alternatives, but it offers nothing.

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

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

With no annotations, the description carries the full burden. It does disclose useful behavior: automatic pin-position calculation, Manhattan routing producing direct or L-shaped paths, junction defaulting to True, and label insertion. However, it omits whether this mutates the schematic, what happens on conflicts with existing wires, or any error/permission 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?

The one-line summary is front-loaded, and the Args/Returns/Examples structure is easy to scan. It is long, and the Args section partly duplicates parameter names already visible in the schema, but given 0% schema coverage that repetition is largely justified.

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?

Parameters are fully documented, routing modes explained, and return contents enumerated (though an output schema exists, so the Returns block is redundant rather than essential). The notable missing piece is usage guidance relative to the many sibling wire/label/junction tools.

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

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

Schema description coverage is 0%, so the description must compensate and largely does: it documents all seven parameters, gives the corner_direction enum values with their heuristic meanings (schema declares no enum), and states the add_junction default. Minor gap: no format constraints on pin identifiers beyond examples.

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 verb and resource ('Connect two component pins') and adds the key differentiator of automatic orthogonal routing. It is clear what the tool does, though it never explicitly contrasts itself with the sibling add_wire or add_junction tools that also create wiring artifacts.

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 through examples but never states when to prefer this high-level connector over add_wire/add_junction, nor any prerequisites (e.g., components must already exist, pins must be unconnected). No exclusions or alternative-routing guidance 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 bears the full behavioral burden. It reveals only that it returns a dictionary with a success status, which the output schema already covers. It omits whether an existing schematic of the same name is overwritten or errors, what permissions are needed, and any side effects — all material for a mutation 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 purpose is front-loaded in the first sentence, which is good. But the Args/Returns/Examples doctest boilerplate is largely redundant — the Returns block restates the output schema and the example adds no information an agent needs to invoke the tool.

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

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

For a simple one-parameter tool with an output schema, the return-value explanation is unnecessary and the schema already defines the single input. What is missing is error/failure semantics and the relationship to sibling management tools, so it is adequate but incomplete.

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

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

Coverage is 0% and there is a single parameter, so the description must carry meaning. 'name: Project name for the schematic' adds only a thin gloss beyond the schema's bare string type; it does not clarify naming constraints, uniqueness, or path semantics. Minimal but non-zero compensation.

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

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

States a specific verb and resource: 'Create a new blank KiCAD schematic.' The word 'blank' usefully hints it differs from load_schematic, and the action is unambiguous. However, it does not explicitly name or differentiate itself from the other schematic-level siblings (load_schematic, save_schematic) that an agent must choose between.

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 preconditions, and no mention of the alternative tools. An agent is left to infer that this is the entry point for a new project versus load_schematic for an existing one. There is nothing about overwrite behavior or when creating would fail.

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 discloses the AND-combination rule and states the return shape (success status + matching list), which is meaningful. But it says nothing about permissions, result limits, ordering, or whether an empty match is an error—relevant behavioral context for a query tool is absent.

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 core definition is front-loaded and the examples are genuinely instructive rather than filler. The Args/Returns docstring formatting is slightly verbose for a tool description, but every section carries information, so it is appropriately sized.

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

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

An output schema exists, so return values need not be re-documented; the description's job is otherwise done—all four params are explained and the AND semantics are stated. The only gap is the absence of any guidance relative to sibling tools like list_components, minor given the complete parameter 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?

Schema description coverage is 0%, so the description must compensate and it does: each parameter is documented with its matching mode (lib_id/value exact match, value_pattern substring match, footprint exact match) plus concrete examples like "Device:R" and "10k". This adds real semantic value beyond the bare nullable strings 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+resource ('Filter components') and immediately clarifies the matching semantics (all criteria must match, AND logic). It is clearly a filtered lookup, distinguishable in intent from list_components, but it never names or contrasts with that sibling, so it falls short of full 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?

The examples implicitly show when to use the tool (by lib_id, by value, by substring), giving useful context. However, there is no explicit when-not guidance and no reference to alternatives such as list_components, so an agent must infer the boundary between filtering and 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 full burden, and it does disclose meaningful behavior: wildcard semantics, case-insensitive matching by default, and the return shape including error information. It doesn't specify error conditions or whether lookup requires the schematic to be loaded first, 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?

Purpose is front-loaded in the first line, followed by structured Args/Returns/Examples sections. The examples are useful but somewhat verbose, and the Returns section partially duplicates the output 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-value explanation is not strictly required, and the description still covers parameters, wildcard/case behavior, and errors. The main gap is the absence of routing guidance relative to sibling lookup tools.

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

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

Schema description coverage is 0%, so the description must compensate, and it documents all three parameters with examples, defaults, and semantics (wildcard syntax, case-sensitivity toggle). It adds real meaning beyond the bare schema, though 'reference' is only lightly elaborated.

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 ('Find pin numbers matching a name pattern') with clear scope. It implicitly distinguishes itself from the sibling find_pins_by_type by emphasizing name-pattern matching, but it never names that sibling explicitly, so differentiation is left partly to inference.

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

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

Usage is implied rather than stated: wildcard patterns and case-insensitive default give a sense of how to call it, but there is no explicit when-to-use guidance and no mention of when to prefer find_pins_by_type or get_component_pins instead.

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

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

No annotations are provided, so the description carries the full burden. It does disclose the return shape ('pin_numbers list and metadata, or error information') and notes the optional ctx for progress reporting, which is useful. However it says nothing about permissions, whether it errors on unknown references, or read-only semantics beyond implication.

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 one-line purpose, then Args/Returns/Examples in a scannable order. The Args block partially restates the schema, but the enum list earns its space, and the two doctest examples are compact. Slightly longer than strictly needed.

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, yet the description adds a brief summary anyway. Between the enum list, the parameter descriptions, and the examples, an agent has everything required to call it correctly; only permission/error-condition 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 schema declares pin_type as a bare string with no enum, so the description's full enumeration of all twelve valid electrical types is essential to correct invocation. It also clarifies reference as a component designator with examples ('R1', 'U2'). This is exactly the compensation a low-coverage schema requires.

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 ('Find pin numbers') plus the discriminating scope ('by electrical type'), which separates it from the sibling find_pins_by_name. It stops short of naming that sibling explicitly, so sibling differentiation is inferred 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 description makes the use case clear (retrieve all pins matching an electrical type, with examples for 'input' and 'power_in'), but it never states when to prefer this over find_pins_by_name or get_component_pins, nor any exclusions. Usage is implied by the examples rather than prescribed.

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 does real work: it discloses the return type (ComponentPinsOutput), error behavior (ErrorOutput on failure), and the non-obvious coordinate semantics ('absolute schematic coordinates accounting for component rotation'). It stops short of an explicit read-only/no-side-effects statement, but 'Get' plus the error/return detail covers most of the 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?

Front-loaded with the purpose, then Args/Returns/Examples in a clear hierarchy. It is somewhat verbose for a single-parameter tool, and the Returns section partially repeats what the output schema already conveys, but no sentence is truly 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-value explanation is not required, yet the description still supplies coordinate and error semantics that help correct invocation. For a simple read tool with one parameter, it is essentially complete, missing only explicit sibling routing.

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 defines 'reference' as a component reference designator and supplies concrete examples ('R1', 'U2', 'IC1'). This meaningfully exceeds 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 ('Get comprehensive pin information for a component') and clarifies scope ('all pins for the specified component'), which implicitly contrasts with find_pins_by_name / find_pins_by_type. However, it never names those siblings explicitly, so an agent must infer the distinction.

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 by the purpose ('get all pins for a component'). There is no explicit when-to-use or when-not-to-use guidance, and no reference to the sibling pin-search tools that would route an agent correctly.

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 disclosure burden. 'Get' implies a read-only operation and the Returns block plus example convey the shape of the result, but nothing is said about behavior when no schematic is loaded, field-level contents of the metadata, 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?

Purpose is front-loaded in one sentence, followed by a short return note and a runnable example. The example is useful but partially redundant with the stated return type.

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

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

For a zero-parameter read tool with an output schema present, the description need not enumerate return fields. The stated purpose is sufficient, though a note on the 'schematic must be loaded' prerequisite 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, which sets a baseline of 4. There is nothing for the description to clarify about argument semantics, so no compensation is needed.

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

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

Names a specific verb (get) and resource (schematic info) scoped to the 'currently loaded schematic', which implicitly separates it from load_schematic/create_schematic. It does not explicitly name any sibling, so it falls just short of a 5.

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

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

There is no statement of when to use this versus list_components, get_component_pins, or other read tools. The phrase 'currently loaded schematic' hints at a prerequisite but never states it or names any alternative.

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. It usefully discloses the return content (position, rotation, footprint, properties), which is genuinely helpful context, but says nothing about scope limits, pagination, or behavior on an empty/unsaved schematic.

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

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

The lead sentence is well front-loaded, but the payload is padded: the Returns prose duplicates the existing output schema, and the Examples block demonstrates return shape rather than any parameter usage for a zero-argument tool.

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

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

For a no-parameter list tool with an output schema present and no annotations, the definition is essentially complete — the agent knows what it returns. Only the routing guidance against sibling listing/filtering 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?

The tool takes zero parameters, so the baseline is 4. The Args section only documents an implicit 'ctx' MCP context that isn't part of the schema, adding nothing for the caller to reason about.

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: 'List all components in the current schematic.' The word 'all' implies no filtering, which implicitly distinguishes it from the sibling filter_components, but that sibling is never named, so differentiation relies on inference.

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

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

No when-to-use guidance or alternatives are provided. Given siblings like filter_components, get_component_pins, and get_schematic_info, an agent gets no help deciding when this unfiltered listing is the right call versus a filtered or more targeted query.

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 says what happens on success but discloses nothing about whether loading replaces any currently open schematic, whether it mutates on-disk state, what permissions or file-access requirements exist, or how errors are surfaced.

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, and the Args/Returns/Examples blocks are compact and well-structured. The example is somewhat redundant but not wasteful given the low 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-value explanation is not required, and the description's mention of project_name in the example is a useful hint. However, for a state-changing load operation with no annotations, the description omits error behavior and any interaction with previously loaded data.

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 schema types file_path only as a string, so the description meaningfully adds that it must be an absolute path to a .kicad_sch file. That is the key detail an agent needs to construct the call correctly.

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 (load) and resource (existing KiCAD schematic file), which an agent can distinguish from create_schematic and save_schematic. It stops short of explicitly contrasting with those siblings, 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?

There is no statement of when to use this tool versus create_schematic or save_schematic, nor any prerequisite or ordering guidance. The usage context (load before manipulating components) must be inferred from the surrounding sibling set.

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 labels itself as a dispatcher but never discloses that 'remove' is destructive, whether changes are persisted or need a save call, what permissions are required, or what happens on invalid actions. For a multi-action tool containing a delete operation, 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?

Front-loaded with the action list, then a compact Args block, then a one-line Returns. The per-parameter lines are short and earn their place given 0% schema coverage; the only mild waste is the redundant restating of 'action' after it was already enumerated.

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 brief Returns line is sufficient and no return-format detail is owed. Given 7 parameters at 0% schema coverage and no annotations, the description does a fair job on argument applicability but is incomplete on the destructive nature of 'remove', error behavior, and persistence, which an agent needs before choosing this tool over the single-action siblings.

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

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

Schema description coverage is 0%, so the description is the only source of parameter meaning, and it delivers: it names each parameter, gives its semantic role, and states which action requires it. It still omits type-level detail (e.g. that position is a 2-number pair, that action is an unconstrained string with five valid values), but it substantially compensates for the empty 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 and enumerates the five supported actions (add, list, get_pins, update, remove), so the agent knows exactly what the tool covers. However, it gives no differentiation from the many siblings that perform the same single actions (add_component, list_components, update_component, remove_component, get_component_pins), leaving the agent to guess which entry point 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?

The per-parameter annotations of which arguments are required or optional per action implicitly document how each action is invoked (e.g. lib_id/value required for 'add', reference required for others). There is no explicit when-to-use guidance and no mention of the single-action alternatives that exist as siblings, so the guidance is only implied.

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

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

No annotations are provided, so the description carries the full burden. It discloses the return shape ('Dictionary with label data or error') and which fields pair with which action, but says nothing about side effects of removal, reversibility, or required permissions for a mutation 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 purpose sentence is front-loaded and the Args/Returns block is compact and scannable. Slightly redundant to re-document ctx and to restate a return value that an output schema already covers, but no wasted 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?

For a 6-parameter mutation tool with no annotations, the description covers parameters and return type adequately, and the output schema handles return detail. It still omits permission requirements, side effects, and sibling disambiguation, which are the main gaps for correct invocation.

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

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

Schema description coverage is 0%, so the description must compensate, and it does: it documents all six parameters and, crucially, states which are required per action ('text ... required for add', 'label_uuid ... required for remove'). This conditional-requirement detail is exactly what the flat schema cannot express.

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 the resource (global labels) and the two operations (add, remove), which is more than a tautology. However, it gives no differentiation from close siblings like manage_labels, add_label, or manage_hierarchical_labels, leaving the agent to infer which label tool to pick.

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

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

There is no when-to-use or when-not-to-use guidance and no mention of alternatives, despite several overlapping label tools in the sibling list. The Args block explains parameters but not selection 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 implies mutation via 'add, remove' but never states whether removal is destructive or reversible, whether it cascades to connected pins, or what permissions are required. It does note the return shape ('Dictionary with label data or error'), which is a small plus, but the behavioral profile of a mutation tool is largely undisclosed.

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 purpose and then structured into Args/Returns sections. The two explanatory sentences about hierarchical labels earn their place by clarifying the concept, and there is little 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 return values need not be re-explained, and parameter documentation is thorough. However, for a mutation tool with zero annotation coverage, the description omits side-effect and safety context, leaving the agent under-informed about the consequences of the remove action.

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, documenting all seven parameters including which are required for which action (text/position for 'add', label_uuid for 'remove'), the shape enum values, the size default, and rotation/size units. It adds real 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 clear verb (manage, with add/remove) and resource (hierarchical labels), and goes further by explaining what hierarchical labels do — connect child schematics to parent sheet pins for signal routing. It does not explicitly distinguish itself from close siblings like manage_labels, manage_global_labels, or add_label, 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?

The only usage guidance is the action list ('add', 'remove'). There is no statement of when to use hierarchical labels versus manage_labels or manage_global_labels, no prerequisites, and no exclusions. The agent must infer selection from the resource name alone.

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

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

No annotations are provided, so the description carries the full burden yet only names the operations. For the destructive 'remove' action it doesn't say whether removal is reversible, whether prior state is returned, or what permissions are needed. It does at least disclose a return shape ('Dictionary with label data or error'), which is modest added context.

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 Args/Returns structure is front-loaded and scannable, with the purpose stated first. It is efficiently sized, though the ctx parameter line is marginal and little is trimmed elsewhere.

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

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

With an output schema present and a returns note, plus full per-parameter documentation, the calling mechanics are adequately covered. The gap is behavioral: no indication of mutation side effects, reversibility, or how this differs from the sibling label-management tools.

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

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

Schema description coverage is 0%, so the description must compensate, and it does: it maps each parameter (action, text, position, rotation, label_uuid, ctx) and states which are required per action ('required for add'/'required for remove'). The only gap is the absent enum constraint on 'action' and no format detail on position/rotation beyond 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?

The description states a clear verb+resource with the two operations enumerated: 'Manage labels (add, remove).' An agent can tell it manages label lifecycle. However, it does not distinguish itself from the many label siblings (add_label, manage_global_labels, manage_hierarchical_labels), leaving the '(add, remove)' scope ambiguous versus plain add_label.

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, and no routing to alternatives such as add_label or manage_global_labels. The only conditional detail is which params are required per action, which is parameter help rather than usage 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 behavioral burden, yet for a mutation tool (add/remove) it discloses nothing about permissions, reversibility, or side effects on the schematic. The only behavioral hint is the boilerplate 'Dictionary with power data or error' return note.

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?

Well-structured with the purpose front-loaded, then Args and Returns blocks. Slightly boilerplate ('ctx: MCP context (optional)') but no meaningful waste for a 5-parameter tool.

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

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

An output schema exists so return values needn't be re-explained, and the parameters are documented. However, an action-dispatch mutation tool with no annotations lacks the when-to-use and behavioral context an agent needs to invoke it confidently.

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

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

Schema description coverage is 0%, so the description must compensate, and it largely does: it maps each parameter's role and the action-dependent requirements (power_net/position for 'add', power_symbol_uuid for 'remove', symbol_variant optional). It stops short of format details like position coordinate semantics or valid variant values.

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

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

The description states a specific verb+resource ('Manage power symbols') and enumerates the supported actions (add, list, remove), which is scannable and unambiguous. It does not, however, distinguish this tool from the many sibling manage_* tools beyond the 'power symbols' resource.

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 per-action required-parameter notes (power_net/position for 'add', power_symbol_uuid for 'remove'). There is no explicit statement of when to use this tool versus alternatives like manage_components or add_component, nor any 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 full behavioral burden. It notes the return shape (success status + results) and an optional ctx for progress reporting, but discloses nothing about side effects such as overwriting an existing file on "save", required permissions, or reversibility.

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, then cleanly separates Args from Returns. No filler sentences; each line carries information, though the docstring layout is a bit mechanical.

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 detail is not strictly needed. The remaining gap is the dispatcher-versus-dedicated-tool routing and the mutation semantics of save/load, which an agent needs but the description omits.

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 documents each of the three parameters, their requiredness (name for create, file_path for load/save), and the enumerated action values, which the schema leaves as a bare string. It also references a ctx arg that the schema omits, a minor mismatch but not harmful.

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?

"Manage" is a vague umbrella verb, but the parenthetical (create, read, save, load) enumerates the concrete operations, so the agent learns what it actually does. However, it does not differentiate itself from the dedicated siblings create_schematic, load_schematic, and save_schematic, which overlap entirely with this dispatcher's actions.

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 manage_schematic versus the sibling tools create_schematic/load_schematic/save_schematic, nor any exclusions or prerequisites. The agent is left to infer the routing policy 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?

No annotations are provided, so the description carries the full behavioral burden. It notes that mutations exist (add/remove/add_pin/remove_pin) but never says what remove destroys, whether renames are reversible, what permissions are needed, or how errors are surfaced, leaving a significant gap for a mutation-capable 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?

Purpose is front-loaded, followed by well-organized Args and Returns sections with no filler. The length is justified by 13 params and six actions, though the arg list is somewhat dense.

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, and the action-conditional param map is present. What is missing is any account of what each action actually does to the schematic or how failures are reported, which matters given the tool's breadth and lack of annotations.

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

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

With 0% schema description coverage, the description does the heavy lifting by mapping each of the 13 params to the actions that require it (e.g., parent_uuid for set_context, pin_uuid for remove_pin). It falls short only on value semantics like valid pin_type or edge values.

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

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

The description names a specific resource (hierarchical sheets) and enumerates six concrete operations, which distinguishes it from the many manage_* siblings (manage_schematic, manage_components). However 'manage' remains a generic verb and the description never contrasts itself with related tools like manage_hierarchical_labels.

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 action list and the per-action required-param notes; there is no explicit statement of when to choose this tool over siblings or any when-not guidance. An agent can infer what each action does but not when it is the right call.

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 add genuine value by mapping which args are required for which action, but for a mutating tool it says nothing about what 'remove' destroys, whether updates are reversible, or what permissions are needed.

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 a single sentence, followed by a scannable Args block with no filler. The Returns line is redundant given an output schema exists, but the overall structure is tight.

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 per-action parameter requirements are well covered and return values are delegated to the output schema. However, as a mutation dispatcher with zero annotation coverage, it omits effect semantics (destruction, reversibility, auth) that an agent would need before invoking 'remove'.

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: each of the 7 parameters gets a gloss plus required/optional status conditioned on the action, which the schema does not express. It falls short of 5 because units remain ambiguous (size is only 'Size tuple', font_size only 'Font size').

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 ('Manage') and resource ('text boxes') and enumerates the three sub-operations add/update/remove. It is distinguishable from siblings like manage_labels or manage_components, though it never explicitly contrasts with them.

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

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

The action enum implies three modes but there is no explicit when-to-use guidance, no prerequisites, and no routing advice relative to sibling tools such as add_label or manage_schematic. The agent must infer the dispatch behavior from the parameter list alone.

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

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

No annotations are provided, so the description carries the full behavioral burden. It says nothing about side effects, reversibility of wire removal, permissions, or how removal interacts with connected components. The 'Returns: Dictionary with wire data or error' line is the only behavioral hint.

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 leading sentence is well front-loaded and the Args block is scannable. The 'Returns' section is redundant given an output schema exists, and the docstring-style formatting adds length without proportionate value.

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

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

For a 4-parameter mutation tool with no annotations, the definition covers parameter roles adequately and an output schema covers returns. But it lacks any behavioral disclosure about the destructive 'remove' operation and any routing against the many wire-related siblings, leaving meaningful 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?

With 0% schema description coverage the description must compensate, and it does list every parameter with its role and conditional requirement ('required for add'/'required for remove'), which the schema does not convey. However, it omits format details such as start/end being [x, y] coordinate pairs, so it only partially compensates.

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

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

The description states a specific verb and resource ('Manage wires (add, remove)') and enumerates the two operations. It does not, however, differentiate itself from the overlapping sibling 'add_wire', leaving ambiguity about why both exist.

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

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

No guidance on when to use this tool versus siblings like add_wire, connect_components, or add_bus_wire. The action parameter implies two modes, but nothing tells the agent which situations call for each or when an alternative tool is preferable.

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 at all, the description carries the full burden, and it delivers the single most important behavioral trait: the removal is cascading and 'also removes all associated wires and connections'. It also notes the optional ctx used for progress reporting. It stops short of stating idempotency, behavior when the reference does not exist, or error/reversibility semantics, so it is strong but not complete.

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 core action and its cascading consequence are front-loaded in the first two lines, followed by cleanly separated Args/Returns/Examples sections. The doctest example is mild redundancy but reinforces the call shape and result keys, so it roughly 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, yet the description still states 'Dictionary with success status'. For a destructive mutation with zero annotations, the description covers the cascade but omits failure modes (component not found), idempotency, and any permission/precondition context, leaving a meaningful gap for this operation type.

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

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

Schema description coverage is 0% and there is one required parameter, so the description must compensate — and it does, explaining that 'reference' is the component reference designator with a concrete example ('R1') and that 'ctx' is an optional MCP context for progress reporting. Both parameters are given 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+resource ('Remove a component from the schematic') and immediately specifies the targeting key (reference designator). It is clear, but it does not explicitly differentiate itself from the surrounding sibling family (update_component, list_components, manage_components), nor does it name an alternative.

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 'Removes the component with the specified reference designator', which tells the agent what input selects the target. However, there is no explicit when-to-use / when-not-to-use guidance, no prerequisite (e.g., schematic must be loaded), and no routing to alternatives such as update_component or manage_components.

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

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

With no annotations, the description carries the full behavioral burden. It discloses that saving defaults to the original location and returns a dictionary with success status, but it does not mention overwrite behavior, permissions, error cases, or whether the schematic must already be loaded.

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 and organized into Args, Returns, and Examples. The Returns line is somewhat redundant because an output schema exists, but the examples are useful and the overall text is not bloated.

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 tool with an output schema, the description covers the main invocation path and default behavior. It could be more complete about overwrite/error behavior, but given the low complexity and existing output schema, it is largely sufficient.

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

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

Schema description coverage is 0%, so the description must compensate. It fully explains the single parameter: file_path is an optional path to save to, and when omitted the tool saves to the original location, which adds meaning beyond the schema's bare anyOf/default=null definition.

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

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

The description states a specific verb and resource: 'Save the current schematic to disk.' This clearly distinguishes it from sibling operations like load_schematic, create_schematic, and manage_schematic.

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

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

It explains that file_path is optional and that omitting it saves to the original location, with examples for both cases. It does not explicitly name alternatives or when-not-to-use conditions, but the usage context is clear for a save operation.

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

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

With no annotations, the description must carry the behavioral burden. It discloses the partial-update behavior and the return contract (ComponentInfoOutput or ErrorOutput on failure), which is meaningful. However, it omits prerequisites (schematic must be loaded?), whether an unknown reference errors, and whether changes are reversible or persisted to disk.

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 statement of purpose followed by Args, Returns, and Examples. The examples are borderline redundant with the Args list but demonstrate multi-property updates, which has value. Overall tight and well-ordered.

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-param mutation tool with no annotations, the description covers parameters, partial-update semantics, and return/error behavior, plus worked examples. An output schema exists so the Returns line is not strictly required. Missing only edge-case behavior for invalid references or missing prerequisites.

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

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

Schema description coverage is 0%, so the description must compensate, and it largely does: it documents each parameter's meaning, units ('position as (x, y) tuple in mm'), the rotation constraint (0/90/180/270), and an example value. It is a raw Args list without type/nullability detail, so slightly short of full compensation.

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 ('Update component properties') and clarifies it targets 'an existing component', which distinguishes it from add_component/remove_component siblings. It does not explicitly name or differentiate against overlapping siblings like manage_components, 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 line 'Only provided parameters will be updated' is a genuinely useful usage rule (partial update semantics), but there is no explicit when-to-use/when-not-to-use guidance or routing to alternatives such as manage_components or add_component for new components.

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