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 a report is produced and that schematic_parity changes what is inspected, which is useful. But it omits whether the tool mutates anything, what occurs when outdir is empty, whether failures raise errors or are reported in the output, and any exit/severity semantics.

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

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

Three short sentences, front-loaded with the core action and the target file. 'Returns the report' is mildly redundant given an output schema exists, but nothing is bloated or disordered.

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 detailed. Still, for a 3-parameter tool with zero annotation coverage and zero schema descriptions, the definition leaves outdir unexplained and says nothing about side effects or failure handling, leaving real 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 and largely does not. It explains schematic_parity's behavior and implies pcb is the target file, but outdir is never mentioned and no path/format expectations (absolute vs relative, default output location) are given for pcb.

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 (Run) plus the named resource (KiCad Design Rules Checker) and the exact input artifact (.kicad_pcb file). The mention of schematic_parity against the sibling .kicad_sch clarifies what this tool is not (it is not the schematic-side kicad_erc). An agent can distinguish it from siblings 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?

Usage is implied: run this to check a PCB for design-rule violations. However, it never states when to prefer this over kicad_erc, when parity checking is warranted, or any prerequisite (e.g. board must exist / be readable). The flag semantics are explained but routing guidance is absent.

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. 'Run ... Checker ... Returns the report' implies a read-only diagnostic, which is useful, but it says nothing about the outdir parameter writing files, permissions, or whether the check has side effects. Partial disclosure 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?

Two short, front-loaded sentences with no filler; the purpose leads and the return behavior follows. The second sentence is slightly redundant given an output schema exists, but the definition is tight overall.

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 return value need not be explained in depth. For a simple two-parameter check tool the purpose is covered, but the unexplained outdir parameter and the absence of any read-only/side-effect statement leave a real gap.

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

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

Schema description coverage is 0%, so the description must compensate and does not. It never explains that 'schematic' is the path to the target file or what 'outdir' controls (an output directory), leaving both parameters undocumented.

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

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

States a specific verb (Run) and resource (KiCad Electrical Rules Checker on a .kicad_sch file), and names the artifact it operates on. It implicitly distinguishes itself from kicad_drc by specifying the schematic file type, but does not explicitly contrast the two sibling checkers.

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 explicit pointer to kicad_drc as the alternative for PCB checks. The .kicad_sch target implies scope but the agent must infer that DRC is the sibling for layout files.

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 does disclose real side effects: gerbers/drill write files into outdir, other targets write <stem><ext> into outdir, and pcb svg is forced to --mode-single --fit-page-to-board --exclude-drawing-sheet. It stops short of stating failure modes, permission needs, or whether existing output files are overwritten.

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 and the file-type-to-target mapping before the optional flag details. Dense and mostly every sentence earns its place, though the embedded CLI flag strings are slightly inside-baseball for an agent that only needs to pick a target.

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 terse 'Returns the export command result' is acceptable. The gaps are minor: undocumented path/outdir defaults and no statement of what happens on invalid target/file-type combinations, which matters given the target list is conditional.

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: layers is explained as an optional comma-separated list with an example and a stated default for gerbers, and outdir's directory-vs-stem semantics are spelled out per target. path is only implicitly characterized (the input file whose extension selects the target) and outdir's empty-string default is never explained.

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 (KiCad file via kicad-cli), then enumerates exactly which targets apply to .kicad_sch versus .kicad_pcb. This is far more discriminating than any sibling (kicad_drc, kicad_erc, kicad_version), so an agent can route to it without ambiguity.

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 clear context: the valid target set is conditioned on the input file extension, which is exactly the decision an agent must make. It does not, however, name when not to use it or point at alternatives (e.g., kicad_drc/kicad_erc for validation rather than export).

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 add real context beyond the schema: matches follow the 'Library:FootprintName' format and the response returns at most `limit` lib_ids. However, it omits whether the call is read-only (safe assumption but undeclared), which libraries are searched, and what an empty query does.

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 tight sentences, front-loaded with the core action. Every clause carries information (search scope, match format, return cap) with no 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?

An output schema exists, so return-value explanation is not needed, and the description covers scope, match format, and result cap. It is nearly complete, lacking only edge-case behavior such as an empty query default and which library set is searched.

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 the query matching format ('Library:FootprintName') and clarifies that `limit` caps the number of returned lib_ids. Both of the two parameters gain meaning beyond their bare names, though exact limit bounds and empty-string behavior remain unstated.

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 (Search) and resource (KiCad footprint libraries), which clearly separates it from sibling tools like kicad_pcb_add_footprint or kicad_list_symbols. It does not explicitly name a sibling to differentiate against, so it falls just 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?

There is no when-to-use, when-not-to-use, or alternative-tool guidance. The only routing hint is implicit in the name and the word 'Search'; an agent gets no instruction on when this is preferable to other listing 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 the result shape ('returns up to `limit` lib_ids'), which is useful, but says nothing about read-only nature, permissions, or whether results are exhaustive or truncated beyond the limit. Modest but not rich behavioral 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?

Three short sentences, front-loaded with the core purpose and result shape. No filler, though the phrasing is slightly terse and the second sentence is a fragment.

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 spelled out, and the description covers both parameters and the search semantics. The main gap is the absence of usage routing against siblings, which for a simple two-param read tool is acceptable.

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

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

Schema coverage is 0%, so the description must compensate, and it does: it explains that `query` matches 'Library:SymbolName' paths and that `limit` caps the number of returned lib_ids. Both parameters gain meaning beyond their bare types, though the default limit behavior is unstated.

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 (search/list) and resource (KiCad symbol libraries), and distinguishes itself from the sibling kicad_list_footprints by virtue of the resource noun. It does not explicitly contrast with alternatives, 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 statement of when to use this versus sibling tools like kicad_list_footprints or kicad_sch_add_symbol. The path-matching note hints at how to query, but there is no when/when-not guidance or prerequisite 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 behavioral burden. It mentions returning paths but does not disclose overwrite behavior, permission requirements, whether the directory must exist, or what happens if project files already exist. For a file-creating mutation, 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?

Two short sentences with no wasted words. The creation action is front-loaded and the return behavior follows immediately.

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 paths need not be detailed further. However, with no annotations and 0% parameter description coverage, the description should explain the directory parameter and basic file-creation behavior. It is minimally viable but leaves 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 should compensate. It implicitly shows that 'name' drives the filenames, but it says nothing about the 'directory' parameter, its default (empty string), or how it affects file placement. Coverage is therefore only partial.

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 (Create), resource (new KiCad project), and the generated file types (.kicad_pro/.kicad_sch/.kicad_pcb). It clearly distinguishes this from sibling tools, which are read, DRC/ERC, export, and schematic/PCB editing operations.

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

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

The description states only what the tool does. It gives no guidance on when to use it versus alternatives, no prerequisites, and no conditions for calling it. An agent gets no routing help from this text.

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 full behavioral burden but only implies mutation through 'Add'. It does not disclose side effects, file modification, permission requirements, library-id validation, or 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?

A single front-loaded sentence with no filler or repetition. Its brevity is efficient, though partly a symptom of under-specification rather than deliberate conciseness.

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

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

An output schema exists, so return values need not be explained. However, for a mutation tool with 8 parameters and no annotations, the description omits essential calling context such as prerequisites, coordinate semantics, and required parameter meaning.

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

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

Schema description coverage is 0% for 8 parameters. The description only clarifies the lib_id format via example; required parameters like path and reference, plus x, y, layer, value, and rotation, remain undocumented.

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

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

States a specific verb (Add), resource (footprint to a PCB), and scope (by library id) with a concrete example. The resource vocabulary distinguishes it from siblings such as kicad_sch_add_symbol and kicad_pcb_add_track without ambiguity.

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, and no prerequisites such as requiring an open project or existing PCB file. It simply states the action.

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 and largely fails it. 'Add' implies a mutation, but it doesn't say whether changes are written to disk, what units width uses, whether the track must connect to pads, or what happens when net/layer/width default. Only the points format is described.

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

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

A single front-loaded sentence with zero filler that earns its place by documenting the points format. It is efficient, though brevity here shades into under-specification rather than tightness.

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

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

An output schema exists so return values needn't be explained, but for a five-parameter mutation tool with 0% schema coverage and no annotations, the description is far too thin — units, defaults, persistence, and net/layer meaning are all 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 coverage is 0%, so the description must compensate; it explains only the points array structure. The four remaining parameters (path, net, layer, width) get no semantics — critically, no unit for width and no meaning for net's integer default of 0, which an agent cannot guess.

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

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

States a specific verb and resource ('Add a polyline of track segments') and clarifies what 'points' means as [[x,y], ...]. It does not distinguish itself from the schematic counterpart kicad_sch_add_wire or clarify the PCB vs schematic context beyond the tool name, but the core action is unambiguous.

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

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

No indication of when to use this versus kicad_sch_add_wire, kicad_pcb_assign_net, or kicad_pcb_add_footprint, and no prerequisites (e.g., must a footprint/net exist first, must the file be loaded). Usage is left 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 behavioral burden. It signals mutation and one special value, but says nothing about persistence (file written to disk?), permissions, error cases, or what happens to existing net assignments on rename.

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 front-loaded sentence with zero waste. However, terseness here is partly under-specification rather than true economy.

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, but a mutating three-required-parameter tool with no annotations and 0% schema coverage needs far more than a single clause to be callable 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% and all three parameters are required, yet the description explains none of them. Only 'net_number' gets partial meaning via the net-0 note; 'path' and 'net_name' format/constraints are left entirely to inference.

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 pair ('declare or rename') plus resource ('a net in the PCB netlist'), with a useful scope note about net 0. No sibling is a close substitute, so the lack of explicit differentiation costs little.

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 adding tracks/footprints that imply nets, nor any prerequisite (must the board be open, does the path point to a .kicad_pcb?). The net-0 note is a usage hint but not 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?

No annotations are provided, so the description carries the full burden. It does disclose the return type (raw S-expression content), which is useful behavioral context, but says nothing about error behavior, encoding, or large-file handling.

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 well-formed sentence with the core purpose front-loaded and 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?

For a simple read tool with an output schema documenting return values, the description is nearly sufficient, but the undocumented 'path' parameter leaves a real gap for correct invocation.

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

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

One required parameter with 0% schema description coverage, so the description must compensate for the empty schema. It does not explain whether 'path' is absolute, project-relative, or what extensions are required beyond the two listed.

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 (KiCad .kicad_sch or .kicad_pcb file) and names the return format (S-expression content). It is clearly distinguishable from write-oriented siblings like kicad_sch_add_symbol, though it does not explicitly reference them.

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

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

No guidance on when to use this tool versus alternatives, nor any prerequisites (e.g., file must exist, project context). Usage is only implied by the verb.

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 behavioral burden. It implies a mutation ('add'), but does not disclose whether it writes to disk, requires specific permissions, is idempotent, or has any other side effects beyond creating a label. The presence of an output schema covers return values, but operational behavior remains 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 a single, front-loaded sentence with no wasted words and no repetition of structured metadata. It is structurally sound, though its extreme brevity means it does little beyond naming the action.

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 mutation tool with four required parameters, no annotations, and 0% schema description coverage, a single sentence is insufficient. The path parameter is unexplained, there is no usage context, and behavioral aspects such as file modification are absent. The output schema reduces the need to explain return values, but the description remains significantly 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?

Schema description coverage is 0% for all four required parameters. The description loosely implies 'text' via 'net label' and 'x'/'y' via 'position,' but 'path' is entirely unmentioned. No additional syntax, format, or unit information is provided to compensate for the missing 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?

The description states a specific verb and resource: 'Add a net label to a schematic.' This distinguishes it from siblings like kicad_sch_add_wire and kicad_sch_add_symbol by the resource being acted upon, though it does not explicitly name or contrast those alternatives.

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

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

There is no guidance on when to use this tool versus alternatives, nor any prerequisites such as needing an existing schematic path or open project. The usage is only implied by the verb 'add'.

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 exist, so the description carries the full burden. It does disclose a genuinely non-obvious trait — schematic mm units and the inverted KiCad Y axis — which is real added value. However, for a write/mutation tool it says nothing about persistence (file write via 'path'), duplicate reference handling, or failure modes.

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 tight sentences, front-loaded with the primary action, and no filler. It is efficient, though the brevity comes at the cost of the parameter coverage noted elsewhere.

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

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

With 7 parameters, 0% schema coverage, no annotations, and only 3 parameters touched by the description, this is under-specified for a mutation tool. The output schema spares it from explaining return values, but the missing param and side-effect context leaves real 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% across 7 parameters, so the description must compensate and only partially does: it explains x/y units and axis orientation and the lib_id format. The semantics of required 'path' and 'reference', plus 'value' and 'rotation', are left entirely undocumented.

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

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

States a concrete verb and resource ('Add a symbol instance to a schematic') and pins the identifier format with an example ('Device:R'). It is clearly distinct from sibling tools like kicad_sch_add_wire or kicad_pcb_add_footprint, though it never names an alternative 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, when-not-to-use, or alternative routing is given. The agent must infer that this is the drawing/schematic-population step and not, say, kicad_list_symbols or kicad_pcb_add_footprint.

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 discloses the coordinate system (mm, Y-down). It does not say whether the file at 'path' is modified in place, whether this is destructive/irreversible, what happens on overlapping wires, or any permission requirement.

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

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

A single efficient sentence with the core action front-loaded and the coordinate caveat appended. It is appropriately terse, though that terseness is partly the source of the documentation gaps.

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. But for a 5-required-parameter mutation tool with zero annotation coverage and zero schema descriptions, the definition omits the path semantics, preconditions, and side effects an agent needs to call it correctly.

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

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

Schema description coverage is 0% across 5 required parameters. The description clarifies that x1/y1/x2/y2 are mm coordinates with Y pointing down, which is genuinely useful, but it never explains 'path' (file path? project path?) or which pair is the segment start versus end.

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 segment to a schematic'), which is clear on its own. It does not, however, differentiate itself from siblings like kicad_sch_add_label or kicad_sch_add_symbol, so a 4 rather than a 5.

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

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

There is no statement of when to use this tool versus alternatives, no preconditions (e.g., the schematic must already exist or be open), and no exclusions. The parenthetical only describes coordinate conventions.

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 non-destructive read by saying 'Return', but does not confirm read-only behavior, state whether kicad-cli must be installed/reachable, or note any failure mode when the binary is missing. For a zero-parameter read tool the safety stakes are low, so this is an acceptable but not rich disclosure.

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

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

A single front-loaded sentence with no filler. It states the outcome immediately and every word earns its place.

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

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

An output schema exists, so the description need not enumerate return values, and for a zero-param version probe the purpose statement is nearly sufficient. The remaining gap is the absence of any usage context, which keeps it just short of 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 tool takes zero parameters, so the baseline is 4. The description does not attempt to invent parameter meaning, and there is nothing for it to compensate for.

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

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

The description gives a specific verb ('Return') and resource ('installed kicad-cli version and detected file format versions'), which is clearly distinct from every sibling, all of which perform DRC/ERC checks or mutate schematic/PCB files. The only softness is 'detected file format versions', which doesn't say what the format versions are detected from, leaving scope slightly ambiguous.

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

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

There is no statement of when to call this tool, when not to, or which sibling to prefer for overlapping needs. An agent can infer it is a diagnostic/environment probe, but the description never says so explicitly and offers no exclusions or prerequisites.

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