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

Annotations already declare readOnlyHint=true, idempotentHint=true, destructiveHint=false and openWorldHint=false, so the safety profile is covered by structured data. The description adds that the tool computes cumulative worst-case Zmin/Zmax, sensitivity derivatives and yield, which is meaningful behavior beyond the annotations, but it says nothing about precision limits, model assumptions, or failure cases.

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 dense sentence that front-loads the purpose and standards before the tolerance and return-value detail. Every clause carries information, though the length makes it slightly heavy for one sentence.

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

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

With no output schema, describing the produced quantities (Zmin, Zmax, dZ/dW, dZ/dH, yield) is exactly the burden the description must carry, and it does so along with the governing models and the variation assumptions. An agent can invoke this correctly without opening other artifacts.

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 100%, so the baseline is 3, but the description adds real information the schema does not: copper thickness is varied at a fixed +-15% and Er at a fixed +-5%, neither of which exists as a settable parameter, while width and height tolerances map to width_tolerance_pct and height_tolerance_pct. That tells the agent which knobs are adjustable versus hard-coded.

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 ('Analyze PCB characteristic impedance manufacturing tolerance window and sensitivities') and names the governing standards (IPC-2141A, Polar SI9000), which clearly separates it from nominal-impedance siblings like calculate_trace_impedance or calculate_pcb_stackup_impedance. It stops short of naming those siblings explicitly, so the 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?

There is no when-to-use guidance, no prerequisites, and no mention of alternatives such as calculate_trace_impedance or calculate_differential_skew. The only usage signal is the implied context that this is a tolerance/variation study, which an agent must infer from the wording.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true, destructiveHint=false, and openWorldHint=false, so the safety profile is fully covered. The description adds the analytical scope (dropout headroom, thermal dissipation) but says nothing about failure modes, required regulator/chip data, or how partial or missing module data is handled. Some added value, but thin beyond what annotations provide.

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

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

A single dense sentence with no filler; the analytical outputs are front-loaded after the primary verb. It is slightly run-on with no sentence breaks separating the four analysis dimensions, which caps it below a 5.

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

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

For a read-only analysis tool with no output schema, the description conveys the main result categories (current budgets in mA, dropout headroom, junction temperature), which is enough to set expectations. It stops short of describing result structure or handling of incomplete module/netlist input, leaving a small 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 100%, and every parameter (modules, netlist, ambient_temp_c with its default and unit) is documented in the schema itself. The description hints at ambient temperature via the junction-temperature calculation but adds no format, unit, or structural detail beyond the schema, so the baseline 3 applies.

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

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

States a specific verb ('Analyze') plus a concrete resource ('system-level power distribution architecture') and enumerates the exact quantities computed: load current budgets in mA, regulator dropout headroom, and LDO thermal/junction-temperature estimates. No sibling tool in the list performs power-tree analysis, so these enumerated outputs implicitly separate it from the many calculate_* trace/thermal/clearance utilities.

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

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

The description gives no when-to-use guidance, no prerequisites, and no alternatives. The dependency on synthesize_circuit is only visible in the input schema's parameter descriptions, not in the description itself, so an agent gets no routing or sequencing 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?

Annotations already declare readOnly, idempotent, and non-destructive, so safety is covered. The description adds real behavioral value beyond that: it flags expired components and emits concrete baking schedules (125°C/24h or 40°C/192h), telling the agent what output to expect and why it matters (popcorning prevention).

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

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

A single front-loaded sentence with the action and target first, then standards and output details. It is dense but every clause (package list, standards, baking examples, defect rationale) carries information; only the popcorning tail 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?

No output schema exists, so the description carries the burden of implying returns, which it does well by naming flagged components and baking schedules. Combined with a complete parameter schema and reconciled annotations, an agent has enough to call it correctly, though the output shape is only implied.

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

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

Schema description coverage is 100%, so the schema already documents modules, ambient_rh_pct, ambient_temp_c, and exposed_hours_default with defaults. The description adds no parameter-level detail (e.g. how msl_level or exposed_hours interact), so baseline 3 is appropriate.

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 (Audit) and resource (SMD plastic packages for MSL and open-bag floor life), enumerating covered package types and standards. No sibling tool addresses moisture sensitivity, so an agent can unambiguously separate it from the fab/assembly/DFM auditors in the list.

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 conveys what the tool produces (flags expired components, generates baking schedules), which implies its usage context, but never states when to invoke it versus alternatives or any prerequisite (e.g. 'run after validating the package'). With no sibling naming the condition, guidance stays implicit.

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

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

Annotations already declare readOnly, idempotent, and non-destructive behavior, so the safety profile is covered. The description adds domain context — checks are evaluated against vendor-published process limits and the negative outcome targeted is CAM EQ rejection — but does not describe the result shape (pass/fail per rule, margins) or what happens for unspecified defaults. Useful context, but not rich behavioral 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 dense sentence that front-loads the verb and resource, then lists fabs and checks before ending on the business justification. Every clause carries information and nothing is repeated from the schema, though the parenthetical vendor list and check enumeration make it long for one sentence.

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

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

With no output schema, the description should establish scope; it does so by naming the rules audited and the fab profiles available. All 7 parameters are optional with documented defaults, and the description implies defaults are applied when omitted. The main gap is the absence of any indication of what the audit returns, but overall this is sufficient for an agent 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 100% and each of the 7 parameters carries its own unit-labeled description with defaults, so the schema does the heavy lifting. The description adds marginal value by naming derived quantities (annular ring, aspect ratio) not present as inputs, but supplies no syntax, range, or interaction guidance beyond the schema. Baseline 3 is appropriate.

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 precise verb (audit), the resource (PCB layout physical design rules), and the reference set (fab house capabilities with named vendors JLCPCB standard/advanced, PCBWay, OSH Park), then enumerates the exact checks performed (trace width, clearance, via drill, annular ring, aspect ratio, slot width). This distinguishes it from generic siblings like calculate_ipc2221_clearance and audit_ipc6012_class_compliance, which target standards rather than vendor process limits.

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 stated goal — verifying against published fab process limits 'to prevent CAM engineering query (EQ) rejections' — conveys the scenario that motivates using it. However, it never explicitly contrasts with the standards-based sibling audits (IPC-2221 clearance, IPC-6012 class), so an agent must infer which audit applies. Implied usage rather than explicit when/when-not guidance.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true, destructiveHint=false, and openWorldHint=false, covering the safety profile. The description adds meaningful context by enumerating the specific checks performed and citing standards (IEC 61000-4-2), so an agent knows what findings to expect. It does not, however, describe output format or severity reporting.

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

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

A single sentence with the action verb front-loaded, then a dense but purposeful enumeration of checked domains. Every clause earns its place, though the packed single-sentence structure could be slightly more scannable.

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

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

For a complex multi-domain audit with no output schema, the description compensates well by listing the verification domains, and annotations cover safety. The remaining gap is that it never indicates the shape of the result (violation list vs. pass/fail report).

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?

Only one parameter exists and schema description coverage is 100%, with the schema documenting the 'netlist' object's 'components' and 'connections' structure. The description adds no format or structural detail beyond what the schema already conveys, so the baseline of 3 applies.

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

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

States a specific verb ('Execute... compliance audit') and resource ('schematic netlist'), then enumerates the exact check domains (fiducials, ICT coverage, TVS surge, reverse polarity, SMT costs). This clearly distinguishes it from the narrower validate_netlist, run_erc, and calculate_ict_testpoints siblings.

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

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

Usage is implied by the DFX audit framing, but there is no explicit when-to-use guidance, no mention of when it should be preferred over validate_netlist, run_erc, or analyze_power_tree, and no stated prerequisites. The agent must infer the selection criteria.

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

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

Annotations already declare readOnlyHint, idempotentHint, and destructiveHint=false, so the safety profile is covered. The description adds substantive behavioral context by naming the specific design parameters evaluated and key Class 3 thresholds (zero breakout, avg copper >= 25μm), though it omits how results are reported.

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

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

A single front-loaded sentence that packs the purpose and evaluated criteria without filler. It is dense but every clause earns its place; minor run-on quality keeps it from a 5.

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

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

Given 9 optional parameters, full schema coverage, and rich annotations, the description is complete enough to call correctly. It clearly enumerates what gets audited, though it does not describe the return format, which is a minor gap for an audit tool with no output schema.

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

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

Schema coverage is 100%, so the baseline is 3. The description adds meaning beyond the schema by tying parameters to acceptance thresholds, e.g., 'zero-breakout constraints for Class 3' and 'avg >= 25μm for Class 3', which clarify how inputs are evaluated.

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 specific verb 'Audit' and resource 'PCB physical and metallurgical design parameters against IPC-6012E and IPC-A-600J Class 1/2/3 acceptance criteria', distinguishing it from sibling audits like calculate_ipc2221_clearance and audit_fab_capabilities. An agent can tell exactly what standard and class scope it covers.

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 clear context: use for IPC-6012E/IPC-A-600J class compliance auditing of PCB design parameters. It does not explicitly name when to choose it over sibling audits or when not to use it, so exclusions are 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?

Annotations already declare readOnlyHint, idempotentHint, destructiveHint=false and closed-world, so the safety profile is covered. The description adds that the audit produces bottleneck identification and LCSC-cross-referenced drop-in mappings, but says nothing about cost, latency, or the shape of the returned findings.

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

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

A single front-loaded sentence that leads with the verb and resource before attaching qualifiers. The parenthetical and trailing clause make it somewhat dense but nothing is redundant filler.

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

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

With one high-coverage parameter but a nested object and no output schema, the description carries real weight, and it does describe the analytical outputs (bottlenecks, second-source mapping with cross-references). It stops short of describing the report structure an agent would receive back.

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?

Only one parameter with 100% schema description coverage, so the schema already documents the modules argument and its provenance. The description adds no format or structure detail beyond what the schema states, making the baseline 3 correct here.

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

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

States a specific verb (Audit) and a clearly bounded resource (BOM component multi-sourcing resilience), then narrows scope with single-source bottlenecks and pin-compatible second-source mapping. It is easy to separate from siblings like calculate_bom_cost or synthesize_circuit, though it never names a sibling explicitly.

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

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

The ISO 9001 audit framing and the schema note that modules come from synthesize_circuit output imply the workflow position, but there is no explicit when-to-use, when-not-to-use, or alternative named. The agent can infer context but is given no routing rule.

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

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

Annotations already establish this as a safe, deterministic, idempotent read-only computation, so the heavy behavioral burden is lifted. The description adds the standards basis (IPC-7095 Section 5.2), which is useful context, but says nothing about the return shape or units of the computed results despite there being no output schema.

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

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

A single dense sentence with no filler, and the core resource and computed quantities are front-loaded. It is slightly packed but every clause carries substantive meaning.

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

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

For a read-only parameterized calculation with all six parameters fully documented in the schema and safety covered by annotations, this is nearly complete for correct invocation. The only omission is any indication of what the computed output contains, which would have helped since no output schema exists.

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 100%, so every parameter is already documented in the schema and the baseline is 3. The description's mentions of fanout geometry, trace widths, and clearances loosely map to via/ball/trace parameters but add no syntax or default nuance beyond what the schema already states.

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 (Calculate) and resource (BGA escape routing) and then enumerates exactly what is computed: diagonal dogbone via fanout geometry, escape-channel trace widths/clearances, and minimum signal-layer requirements. This is precise enough to distinguish it from every sibling calculate_* tool, none of which cover BGA escape fanout.

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 domain phrasing ('escape channel', 'IPC-7095 Section 5.2') strongly implies when the tool applies, so usage is inferable, but there is no explicit when-to-use statement, no preconditions, and no named alternative among the many calculate_* siblings. It sits at minimum-viable guidance.

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

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

Annotations already declare this a safe, read-only, idempotent operation, so the safety burden is off the description. The description adds genuine domain behavior beyond the annotations: the Basic-vs-Extended library rule, the exact +¥20/type feeder surcharge, and that the tool proactively suggests cost optimizations. It still omits how results are produced (live JLCPCB lookup given openWorldHint=true) and the return shape.

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

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

Two tight sentences with the core purpose front-loaded and no filler. Slightly dense in the second sentence but every clause carries information.

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

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

For a single-parameter, read-only calculator with no output schema, the description covers the cost model, fee tiers, and the advisory output adequately. It could still note whether external JLCPCB data is queried at call time, which would matter for latency and freshness.

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?

Only one parameter (queries) and schema description coverage is 100%, with examples for accepted forms ('STM32F103C8T6', 'SP3485', '0603 10k'). The description adds nothing about the parameter, so the high-coverage baseline of 3 is correct.

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 ('Calculate PCBA component cost breakdown') plus the additional scope of JLCPCB SMT surcharges, which distinguishes it from the generic calculate_fab_cost sibling. It does not explicitly name that sibling or contrast its scope, so it falls short of a 5.

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

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

Usage is implied by the SMT/JLCPCB cost framing but never stated: there is no 'use this when you need X, not Y' and no mention of calculate_fab_cost, calculate_smt_feeder_matrix, or export_manufacturing_bom as alternatives. An agent can guess the context but must infer the boundary with sibling cost tools.

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

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

Annotations already cover the safety profile (readOnlyHint=true, idempotentHint=true, destructiveHint=false), so the description only needs to add context beyond that. It usefully discloses the computed quantities, the pass/fail threshold (current density <= 35.0 A/mm²), and the physical failure it guards against (delamination/blistering), giving the agent a clear model of what the call produces without stating a return format.

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 dense sentence that front-loads the verb and the primary outputs before the standards and threshold clauses. It earns its length by conveying several distinct facts, though the trailing compliance/threshold clauses make it long enough to be worth splitting.

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

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

For an 8-parameter computation with no output schema, the description names the outputs it returns (IR-drop, Joule heating, bottleneck current density) and the acceptance criterion, which is what an agent most needs. It stops short of describing result structure or units, but with annotations covering safety and the schema covering inputs, the remaining gap is minor.

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 100%, so every parameter is already documented in the schema with units and defaults. The description mentions bottleneck density but adds no syntax, units, or constraints beyond what the schema provides, so baseline 3 is correct.

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 ('Calculate') plus three concrete outputs (DC IR-drop, Joule heating dissipation, bottleneck current density) applied to a clearly scoped resource ('polygon copper pours and power busbars'). This scope distinguishes it from the sibling calculate_ipc2152_trace_current, which handles traces rather than pours/busbars, so an agent can route correctly without opening either schema.

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

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

The description anchors usage to standards (IPC-2152 Section 5.0, IEC 60092-352) and to a heavy-load/heavy-copper context, which implies when it applies. However, it never states when NOT to use it or names the sibling alternative (calculate_ipc2152_trace_current) for narrow-trace cases, so routing between the two 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?

Annotations already declare readOnly/idempotent/non-destructive, so the safety profile is covered. The description adds real behavioral context beyond that: the specific acceptance threshold (IPC-TM-650 2.4.22 <= 0.75%) and that the generated patterns are non-functional dummy copper per IPC-2221B 10.1.1 — useful for an agent judging what a 'risk' result means. It stops short of noting whether generation is purely a computed report or writes artifacts.

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 whose main verb and resource come first, with standards citations embedded rather than filler. It is somewhat dense and stacks three distinct outputs into one clause, which costs a little readability, but nothing is wasted.

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

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

With no output schema, the description should help an agent anticipate the return value, and it does name the three outputs conceptually (balance, warpage risk, pattern geometry). However it never indicates the form of those outputs (numeric balance, pass/fail verdict, coordinate lists) or units, leaving a gap for a compound computational tool with six inputs.

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

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

Schema description coverage is 100% and every parameter (board dimensions, pitch, keepout margin, optional top/bottom copper areas) is documented in the schema with defaults. The description adds no parameter-level meaning beyond what the schema states, so the baseline 3 applies.

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

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

Names a specific verb (Calculate) with a precise resource (layer copper density balance between top/bottom layers) and adds two concrete sub-capabilities: reflow warpage risk assessment against an IPC-TM-650 threshold, and generation of non-functional thieving dot/grid patterns. It is unmistakable against the many other calculate_* siblings (clearance, stackup impedance, trace current) because it names copper balance and thieving 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 context of use is implied by the domain (copper balance for warpage mitigation during PCB design), but there is no statement of when to reach for this tool versus adjacent ones such as calculate_pcb_panel_rails, or any prerequisite (e.g., must be run after routing is complete or knowing copper areas). Adequate but leaves the selection decision 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?

Annotations already declare readOnlyHint=true, idempotentHint=true, destructiveHint=false and closed-world, so the safety profile is covered. The description adds meaningful context by naming the governing standards (IPC-2221B Table 6-1, IEC 62368-1) and the artifacts produced, but does not describe return format, units of output, or assumptions/limits beyond what annotations and schema carry.

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 dense sentence, front-loaded with the evaluation purpose before the slot-planning action. Every clause maps to a real capability (compliance check, slot geometry, effective creepage path), though the length borders on over-packed for a single sentence.

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

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

For a 7-parameter, no-output-schema calculation tool, the description covers what is computed and, via 'slot width, length, endpoints, and expanded effective creepage path', hints at the returned geometry. It stops short of specifying output units or failure/compliance reporting, which is a minor gap given the absent output schema.

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

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

Schema description coverage is 100%, with defaults and units documented per property, so the schema already carries parameter meaning. The description reinforces the slot-related parameters ('slot width, length, endpoints') but adds no syntax, units, or constraint detail beyond the schema. Baseline 3 is appropriate.

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 specific verbs and resources: 'evaluate high-voltage electrical creepage compliance... and plan an air isolation milled slot'. An agent can tell this computes creepage plus slot geometry rather than mere clearance. However it never names or contrasts with the nearby sibling calculate_ipc2221_clearance, which an agent could easily confuse it with.

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

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

The clause 'when surface distance is insufficient' gives an implied condition for the slot-planning portion of the tool, but there is no explicit when-to-use framing for the evaluation step and no routing to alternatives such as calculate_ipc2221_clearance or evaluate_material_cti_creepage. Usage is inferable but not stated.

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

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

Annotations already declare readOnlyHint, idempotentHint and destructiveHint=false, so the safety profile is covered. The description adds that the tool also computes serpentine bump count and tuning geometry, which is useful scope context, but it does not say whether sizing/fabrication constraints apply or how results are reported.

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

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

A single sentence that front-loads the primary action and tolerances before the secondary geometry output. It is dense and somewhat overstuffed with protocol budgets, but no sentence is wasted.

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

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

No output schema exists, so the description carries the return-value burden; it gestures at 'bumps count and geometry' but gives no format or units. The required parameter and all optional parameters are documented in the schema, and the key gap is the unaddressed overlap with calculate_serpentine_tuning_geometry.

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 100%, so every parameter including the enum protocol list and defaults is already documented in the schema. The description alludes to the P-minus-N length delta but adds no syntax, units, or interpretation guidance beyond what the schema provides.

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

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

States a specific verb+resource (calculating intra-pair propagation delay skew) and names the target protocols with concrete tolerance budgets, which is far more informative than the bare name. However it never distinguishes itself from the close sibling calculate_serpentine_tuning_geometry, whose scope it explicitly overlaps.

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

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

Usage is implied by the protocol budgets (USB2.0 HS ≤10ps etc.) and the required trace_length_delta_mm input, so an agent can infer this is a post-layout skew check. But there is no explicit when-to-use, no exclusions, and no routing to the overlapping serpentine_tuning_geometry sibling.

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

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

Annotations already declare read-only, idempotent, non-destructive, closed-world behavior, so the safety profile is covered. The description adds real value beyond that by disclosing the pricing model ('fab-house published tiered pricing') and the 'Estimate only' caveat, signaling this is an approximation rather than a binding quote.

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 dense sentence front-loads the purpose and pricing basis, followed by the terse 'Estimate only.' caveat. It is tightly sized, though the enumerated parameter list partially duplicates the fully-covered 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?

With annotations covering safety and the schema covering all inputs, the description supplies the remaining context (estimate source and approximation caveat). Minor gaps remain: no output schema and no mention of currency or return format, but these are not critical for a read-only calculator.

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 100%, so all eight parameters (including pricing multipliers for finish, color, and lead time) are already documented. The description recaps the same inputs (layers, quantity, color, finish, thickness, lead time) at a higher level without adding syntax or meaning beyond the schema; baseline 3 applies.

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

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

States a specific verb ('Estimate') and resource ('PCB fabrication cost') and immediately scopes the pricing basis to fab-house published tiers. This clearly distinguishes it from sibling cost tools such as calculate_bom_cost, without needing to open either schema.

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

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

The description implies usage (published tiered pricing) and adds the caveat 'Estimate only', but never states when to use this tool versus alternatives like calculate_bom_cost, nor any prerequisites. The guidance is inferable but not explicit.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true, destructiveHint=false and openWorldHint=false, so the safety profile is covered. The description adds meaningful domain context beyond that: the governing standards (IPC-2221B Section 12, JEDEC J-STD-020), the geometric rationale (L-shape asymmetry for 180° rotation disambiguation), and the two output fiducial classes. It does not describe the returned structure, but with no output schema and clear annotations this is still strong.

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

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

A single dense sentence with the generation action front-loaded and no filler. It is somewhat packed with clause-level detail, but every clause (shape, rotation rule, local fiducials, standards) earns its place.

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

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

For a read-only deterministic layout generator with full schema coverage and no output schema, the description supplies the standards, the two fiducial classes, and the geometric invariant an agent needs. Only a note on what the tool returns would make it fully complete.

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

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

Schema description coverage is 100%, so every parameter (width, height, edge clearance, fine-pitch components, pitch threshold) is already documented in the schema. The description contextualizes fine-pitch components and local fiducial triggers but adds no syntax, units, or format meaning beyond what the schema provides, so the baseline 3 applies.

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

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

Precise verb+resource ('Generate ... fiducial layout') with concrete specifics: asymmetric 3-point global fiducials (L-shape, rotation-unambiguous) plus 2-point local fiducials for fine-pitch parts. It is the only fiducial tool among the siblings, and the description makes its scope unmistakable without opening the schema.

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

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

The description implies when the tool applies (you need an optical fiducial layout for a PCB, with local fiducials when fine-pitch parts exist), but there are no explicit when/when-not statements or named alternatives. There is no direct sibling to route against, so implied usage is adequate but not strong.

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

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

Annotations already declare readOnlyHint, idempotentHint, and destructiveHint=false, so the agent knows this is a safe, repeatable computation and the description does not contradict that. The description adds domain behavior beyond the annotations: B.Cu Φ1.0mm testpad geometry, probe tip categories (crown, spear, serrated), and compliance with IPC-9252 and IPC-2221B. It stops short of describing what the analysis returns or what happens when coverage targets fail to be met.

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 dense sentence with the primary action ('allocate automated bed-of-nails ICT testpoints') positioned early and supporting detail trailing. It is slightly overloaded by stacking four distinct activities plus two standards into one clause, but there is no filler text.

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

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

For a multi-step analysis tool with no output schema, the description does name the artifacts produced (allocated testpoints, assigned probe tips, fault coverage percentage) and the governing standards, which is enough for correct invocation. It could still be stronger by clarifying the return shape and any coverage thresholds, but it is substantially complete for a 5-parameter analysis call.

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

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

Schema description coverage is 100%, so all five parameters (including the required connections and the board/pitch/pad geometry defaults) are already documented in the schema. The description adds no parameter-specific detail such as units, valid ranges, or interaction between min_probe_pitch_mm and min_pad_diameter_mm. Baseline 3 applies when the schema does the heavy lifting.

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 concrete verbs and resources: analyze netlist testability, allocate bed-of-nails ICT testpoints, assign probe tip types, and verify fault coverage. It is highly specific about the domain. However, it makes no attempt to differentiate itself from related siblings such as audit_industrial_dfx, export_ipc_d356 (the IPC-D-356 ICT data export), or validate_netlist, so an agent must infer the boundary from the name alone.

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

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

There is no when-to-use guidance, no stated prerequisites, and no named alternative. The schema hints that connections come from synthesize_circuit output, but the description itself gives no ordering or routing advice (e.g., run before export_ipc_d356 or after validate_netlist).

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

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

Annotations already declare readOnlyHint, idempotentHint, non-destructive, and closed-world, which fully covers the safety profile of a pure calculator. The description adds the IPC-2152 standard as the computational basis, but says nothing about the numerical method, boundary behavior, or validity range that would add real 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?

A single sentence with no filler, front-loading both the action and the two output modes before the parameter list. It is dense but every clause carries information, though the parenthetical unit annotations are slightly redundant with the schema.

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

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

For a stateless calculator with full schema descriptions and a mode enum that captures the two return shapes, the definition is nearly sufficient. The absence of any statement about return format is acceptable since the schema's mode descriptions describe what each path yields, though an explicit note on output units would round it out.

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 100%, so each of the six parameters is already documented in the schema with defaults, units, and the mode-dependent requirement. The description merely restates three of them (copper weight, temperature rise, layer position), adding no syntax or format detail beyond the schema, so the baseline 3 applies.

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

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

States a specific verb (calculate) and resource (IPC-2152 conductor current / PCB trace width), and names the governing standard and the two solve directions. It is clearly distinguishable from impedance or clearance calculators by the IPC-2152 reference, though it never names the nearest sibling (calculate_trace_impedance) 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 phrase 'for given copper weight (oz), temperature rise (ΔT °C), and layer position' implies the required input context, but there is no explicit when-to-use vs when-not guidance and no mention of alternatives such as calculate_trace_impedance or calculate_ipc2221_clearance.

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

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

Annotations already declare this as a safe, read-only, idempotent, non-open-world computation, so the safety profile is fully covered. The description adds the governing standard and the fact it is a table lookup, but says nothing about the units or format of the computed clearance, which matters for a pure calculation tool with no output schema.

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

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

A single front-loaded sentence that leads with the action and result ('Calculate minimum electrical clearance') and then qualifies with the standard and inputs. Dense but every clause carries information; no filler or repetition.

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 calculation tool with no output schema, the agent still does not know the unit or magnitude of the returned clearance (mils vs mm) or whether the result is a single value or a table, and there is no guidance on the voltage range covered by the table.

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 100%, and the description's enumeration of B1/B2/B4/A6 meanings is a verbatim duplication of the schema's own parameter descriptions. It adds no syntax, range, or tolerance guidance beyond the structured fields, so the baseline of 3 applies.

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

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

States a specific verb (Calculate) and a precise resource (minimum electrical clearance / conductor spacing) and anchors it to a named standard and table (IPC-2221B Table 6-1). An agent knows exactly what comes out and on what basis, and can distinguish it from the creepage/CTI siblings.

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

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

The description implies the usage context by naming the two required inputs (peak voltage, conductor classification), but it never says when to prefer this over the related siblings, e.g. calculate_creepage_isolation_slot or evaluate_material_cti_creepage. No exclusions or prerequisites are given, so usage must be inferred.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true, and destructiveHint=false, so the safety profile is covered. The description adds that the result is deterministic, standards-derived geometry and names what is returned, which is useful, but says nothing about failure modes for unknown package names or how 'custom' inputs are treated.

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 dense sentence that front-loads the verb and output set with no filler. It is slightly overloaded with parenthetical geometry abbreviations, but nothing is wasted.

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

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

With no output schema, the description usefully enumerates the returned geometry quantities, which an agent otherwise could not infer. It is largely sufficient for a 7-param, 1-required calculation tool, though it omits how optional lead dimension parameters combine and what happens for unrecognized packages.

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 100%, so every parameter including 'density' and 'package' is already documented in the schema. The description restates the density levels and 'or custom' but adds no new syntax or interaction detail, matching the baseline for high coverage.

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

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

Specific verb (calculate) + precise resource (IPC-7351B surface mount land pattern geometry) plus enumerated outputs (pad width X, pad length Y, pad center distance C, courtyard bounds). It is clearly distinguishable from siblings such as calculate_ipc2152_trace_current and calculate_ipc2221_clearance.

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 is computed and the density-level options but never states when to use this tool versus the many other calculate_* siblings, nor any prerequisites. No exclusions, no 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?

Annotations already declare readOnly, idempotent, non-destructive, and closed-world, so the safety profile is covered. The description adds only the implication that this is a pure equation solver, with nothing about determinism guarantees, input validation failures, or what happens on infeasible targets (e.g., no E96 solution).

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

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

A single front-loaded sentence with no filler; the enumerated computation types are the most useful content and appear immediately. Nothing is wasted.

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

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

There is no output schema, so the description carries some burden for return values, yet it says nothing about what a solve returns (nearest E96 pair, computed junction temperature, R/C values, etc.). Schema coverage of the nested params object is strong, so the main gap is the missing result-shape hint.

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 100% and the schema itself enumerates the per-type argument names (v_in, v_out_target, cutoff_freq_hz, etc.), so the baseline is 3. The description adds no unit conventions, value ranges, or defaults beyond what the schema already documents.

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 ("Solve") plus a precise resource ("discrete parametric circuit equations") and enumerates the four supported calculation families, which map exactly to the type enum. It does not explicitly contrast itself with domain-adjacent siblings such as calculate_trace_impedance, but the listed subtypes are distinctive enough for an agent to tell it apart.

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 list of four calculation kinds implies when to reach for the tool, but there is no explicit when-to-use/when-not guidance, no prerequisites, and no named alternative among the many calculate_* siblings. Usage is inferable rather than stated.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true, destructiveHint=false and openWorldHint=false, so the safety profile is fully covered and the description does not contradict it. Beyond that, the description usefully discloses the governing standards (IPC-2221B §8.4, IPC-SMEMA-9851) and specifics of what is generated (NPTH Φ3.2mm tooling holes, Φ1.0/3.0mm fiducials, V-Cut or mouse-bite features), adding real context over the annotations.

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

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

A single sentence, front-loaded with the core action and then ordered by feature group and standards, with no filler. It is dense and clause-heavy, which makes it slightly tiring to parse, but every element contributes information and nothing is redundant.

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

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

For a deterministic computation with 100% schema coverage and no output schema, the description supplies the domain framing and the standards that determine the result, which is what an agent needs to invoke it correctly. It could go slightly further by hinting at the shape of the returned panel geometry, since no output schema exists to carry that burden.

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 100%, so every parameter is already documented in the schema, including defaults and the SMEMA 3.0mm minimum for rail_width_mm. The description adds no parameter-level syntax or format detail beyond echoing the V-Cut/mouse-bite distinction already present in depaneling_method. Baseline 3 is appropriate when the schema does the heavy lifting.

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: 'Calculate SMT automated assembly panel frame with breakaway process rails,' then enumerates exactly which features the calculation covers (clamp clearances, SMEMA tooling holes, fiducials, de-paneling). An agent knows precisely what this tool computes. It does not, however, explicitly differentiate itself from near-siblings like optimize_panel_grid or calculate_fiducial_layout, which also touch panel geometry.

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 never states when to use this tool versus alternatives such as optimize_panel_grid (which also arranges panel grids) or calculate_fiducial_layout (which also handles fiducials). There are no prerequisites, no exclusions, and no routing guidance to a sibling tool.

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

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

Annotations already declare readOnlyHint, idempotentHint, and destructiveHint=false, so the safety profile needs no coverage here. The description usefully adds that the underlying model is IPC-2141A and enumerates the supported target impedances, but says nothing about accuracy limits, frequency dependence, or what a solved width looks like.

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

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

A single front-loaded sentence that leads with the lookup action before the solve action. It is dense with parenthetical model numbers and per-interface values, but every element is substantive and nothing is redundant.

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

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

With no output schema, the description is the only place the return payload could be characterized, yet it never says whether the result is a stackup matrix, a computed trace width, or both. For a two-mode tool (preset lookup plus custom solve) that ambiguity leaves an agent guessing at the response shape.

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

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

Schema description coverage is 100% and the enum for stackup_id is fully documented in the schema, so the baseline is 3. The description contributes only marginal extra meaning by tying the impedance targets (50/90/100/120Ω) to the custom-solve parameter, without explaining units, ranges, or whether the custom value overrides the preset list.

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 (lookup/solve) and resources (4-layer and 6-layer stackup matrices, controlled-impedance trace widths), and names the concrete stackup models JLC04161H/JLC06161H. It does not explicitly distinguish itself from the closely-related siblings calculate_trace_impedance and analyze_impedance_tolerance, so an agent still has to infer which one applies.

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

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

The description implies when it applies (standard industrial stackups, common interface impedances such as USB/Ethernet/CAN), but gives no explicit when-to-use or when-not-to-use guidance and never names the alternative tools for impedance work. Usage is inferable from the impedance targets listed rather than stated as a routing rule.

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

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

The annotations already declare a safe, read-only, idempotent operation. The description adds useful behavioral context beyond annotations: it evaluates standard tolerances, estimates insertion and retention forces, and targets specific failure modes (inner-layer tear, vibration disconnects). It does not contradict any annotation.

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

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

It is a single dense sentence that front-loads the core action ('Evaluate') and packs in standards, tolerances, and outcomes without filler. Slightly long but every clause contributes specific information.

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

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

For a calculation tool with three fully described parameters, no output schema, and read-only annotations, the description supplies the key domain standards, tolerance ranges, and failure-prevention goals. It is nearly complete, though it could briefly mention the shape of the returned compliance result.

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

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

Schema description coverage is 100%, so the baseline would be 3. The description adds meaningful parameter context by specifying the standard finished hole diameter range (0.94mm–1.09mm) and minimum copper plating thickness (≥25μm), which enriches interpretation of the corresponding schema parameters.

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

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

The description names the specific analysis (press-fit compliant pin finished hole diameter tolerances and copper barrel plating thickness), cites the governing standards (IPC-9797, IEC 60352-5), and states the computed outputs (insertion and retention forces to prevent inner-layer tear or vibration disconnects). This clearly distinguishes it from all sibling calculation tools.

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 a clear technical context (automotive and industrial solderless press-fit applications) and purpose (preventing failures), which implies when to use it. However, it does not name alternative tools or specify when-not to use it, leaving the agent to infer its place among the many sibling calculation tools.

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

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

Annotations already declare the safety profile (readOnly, idempotent, non-destructive, closed-world), so the bar is lower. The description adds meaningful behavioral context by disclosing the design constraints it enforces (self-coupling suppression S >= 3W, H >= 3W) and the standard it follows, though it says nothing about the shape or structure of the 'vertex paths' it produces.

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 dense sentence that front-loads the verb and the core resource before the constraint and standard clauses. No filler, though the technical density borders on over-compressed for a niche 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?

There is no output schema, so the description carries more weight, and it partially compensates by stating that it generates vertex paths and what constraints are enforced. It omits the coordinate frame of the returned path relative to the start/end inputs, which would be useful, but for a calculation tool it is largely complete.

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

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

Schema description coverage is 100%, so all six parameters are already documented in the schema with units, defaults, and roles. The description adds no further parameter meaning beyond the schema, making the baseline 3 appropriate.

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 (calculate) plus a precise resource (high-speed differential pair serpentine delay tuning meander geometry) and cites the governing standard IPC-2141A Section 5.3. It distinguishes itself from the related sibling calculate_differential_skew by focusing on geometry rather than skew, though it does not name that sibling explicitly.

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

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

Usage is implied by the phrase 'high-speed differential pair serpentine delay tuning,' which signals the context in which the tool applies. However, there is no explicit when-to-use/when-not guidance and no routing to alternatives such as calculate_differential_skew or calculate_trace_impedance, so the agent must infer fit.

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

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

Annotations already declare readOnlyHint, idempotentHint, non-destructive and closed-world, so the safety profile is covered. The description adds genuine behavioral context beyond that: the governing EIA-481 carrier-tape standard, OpenPnP/Juki machine matrices, and the concrete constraint domains (feeder pitches, nozzle numbers) the optimization respects.

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

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

A single front-loaded sentence with the action first and the constraint set in parentheses; it is dense but every clause (standards, widths, nozzle IDs, machine matrices) carries information. Slightly over-packed but no filler.

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

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

Given no output schema, the description should ideally state what the optimization returns (slot table, nozzle assignment) and note the synthesize_circuit input dependency, neither of which it does. The annotated safety profile is covered, so the remaining gap is the return contract and input prerequisite.

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?

Only one parameter exists and schema description coverage is 100%, so the schema already documents 'modules' as coming from synthesize_circuit output. The description adds nothing about the input shape, so baseline 3 applies.

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

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

The description names a specific verb ('Optimize') and two concrete resources (feeder slot allocation, nozzle tooling selection) with the valid widths and nozzle IDs spelled out. It is clearly separable from siblings like calculate_smt_placement_clearance or export_openpnp_job, though it does not explicitly name 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?

There is no statement of when to use this tool, what triggers it in a workflow, or which alternatives exist. The implicit dependency on synthesize_circuit output is only inferable from the schema description, not the tool description.

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

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

Annotations already declare the safe read-only, idempotent, non-destructive profile, so the bar is lower. The description goes beyond them by disclosing the actual decision rules (tall = H >= 4.0mm, 2.0mm horizontal keepout) and what the tool produces (layered placement priority sequences ordered lowest-to-tallest) with cited standards, which is genuine 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?

A single dense sentence with three parallel clauses, front-loaded on the core action and free of filler. Slightly overloaded for one sentence, but nothing is wasted.

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

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

With 5 parameters, one required nested object, and no output schema, the description does the important work of explaining what the tool returns (priority sequences, keepout evaluation). The main gap is that it never identifies the required modules input's provenance or what happens when no collisions are found.

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 100%, so every parameter (board dimensions, clearance envelope, tall-component threshold) is already documented in the schema, making 3 the baseline. The description restates the 4.0mm and 2.0mm defaults but adds no units, ranges, or interaction semantics beyond that.

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 set (analyze / evaluate / generate) against a precisely scoped resource: SMT nozzle collision clearance between tall and low components. It is instantly distinguishable from nearby siblings such as calculate_smt_feeder_matrix, calculate_stencil_aperture_ratios, or export_openpnp_job.

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 never states when to run this versus alternatives, nor does it state prerequisites such as needing positioned modules from synthesize_circuit before calling. Usage is only inferable from the domain context, and there are no exclusions or ordering guidance anywhere in the 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?

Annotations already declare readOnlyHint=true, idempotentHint=true, destructiveHint=false and openWorldHint=false, so the safety profile is covered. The description adds real domain context beyond that (IPC-7525A basis, the 1.0~2.5 acceptance window, the two defect classes it flags), but it never describes what the result looks like or how the per-aperture findings are reported, and no output schema exists to fill that 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?

A single dense sentence with no filler; purpose, governing standard, acceptance criterion and outputs are all front-loaded. Slightly hard to parse as one run-on, but every clause carries information.

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

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

For a read-only calculation tool the safety side is complete via annotations, and the method and tolerance window are stated. However, the description refers to comparison 'against target joint volume' while the apertures schema exposes only ref, shape, width_mm and length_mm, leaving unexplained where the target joint volume comes from, and with no output schema there is no description of the returned per-aperture results.

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 100% with defaults documented for foil_thickness_um, target_standoff_mm and transfer_efficiency, so that is the baseline 3. The description adds no parameter-level detail, such as units or ranges for the standoff/foil inputs, beyond what the schema already states.

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 (assess) and resource (per-aperture deposited solder paste volume vs. target joint volume) and anchors it to IPC-7525A transfer analysis, so the function is unmistakable. It does not explicitly name or contrast itself with the closest sibling, calculate_stencil_aperture_ratios, so it stops short of a 5.

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

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

Usage is only implied: the mention of an accepted ratio window (1.0 ~ 2.5) and defect flagging tells the agent this is a stencil-design validation step, but there is no explicit when-to-use statement, no prerequisite, and no named alternative among the many calculate_* siblings.

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

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

Annotations already declare readOnlyHint, idempotentHint, and non-destructive, so safety is covered. The description adds useful domain context (the IPC-7525 criteria and what a failure means), but with no output schema it never says what the response contains or how deficiencies are reported.

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 dense sentence with the standard and thresholds front-loaded and zero filler; every clause carries meaning.

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

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

For a read-only calculation tool with full schema coverage, the description supplies the standard, thresholds, and the purpose of the result. The main gap is that no output schema exists and the description does not describe the returned structure, keeping it below a 5.

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 100%, including the aperture object shape and all three numeric defaults, so the schema carries the parameter burden. The description restates the default thresholds but adds no format or unit guidance beyond what the schema already provides.

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

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

States a specific verb (Evaluate), the exact resource (SMT stencil aperture area ratio and aspect ratio compliance), and the governing standard (IPC-7525). It also names the outcome (identifying paste-release-deficient apertures), which distinguishes it from neighbors like calculate_solder_paste_volume.

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: checking aperture designs against the >=0.66 area-ratio and >=1.5 aspect-ratio rules to find paste-release problems. It gives no explicit when-not guidance or named alternative tool, so it stops short of a 5.

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

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

The annotations already declare readOnlyHint=true, idempotentHint=true, destructiveHint=false and openWorldHint=false, so the safety profile is fully covered without the description. The description adds useful domain context (IPC-2221B 9.1.5 / IPC-A-600J Class 3 compliance, the failure modes being mitigated) but says nothing about output format, units returned, or any limits on input size.

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

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

A single front-loaded sentence that leads with the verb and resource and then justifies it with the problem solved and the standards met. Slightly dense with compliance citations that could be trimmed, but nothing is redundant.

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

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

With full annotation coverage and 100% schema coverage, the remaining burden on the description is light. It conveys purpose, motivation and standards alignment; the only gap is that with no output schema it never hints at what the calculation returns (geometry, coordinates, recommended fillet radii).

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 100%, with the vias list item keys, the teardrop_style enum ('curved'/'linear') and the default trace width all documented in the schema. The description adds no parameter-level meaning beyond that, so the baseline 3 is appropriate.

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 pairs a specific verb (Calculate) with a precise resource (tangent teardrop fillets) and the target objects (PCB vias, circular pads, testpoints). An agent can immediately tell what geometry is produced, but it never distinguishes this from the closely-related sibling calculate_via_protection_plan, leaving the boundary 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 context is implied by the stated goals ('prevent drill breakout, eliminate mechanical/thermal crack stress'), which tells the agent this is a reinforcement/DFM step. However, there is no explicit when-to-use, no when-not, and no mention of alternatives such as calculate_via_protection_plan, so the agent must guess which via-reinforcement tool applies.

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

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

Annotations already declare readOnly/idempotent/non-destructive, so safety is covered. The description usefully adds the computational method (IPC-2141 / Wheeler, 'exact' solve), but says nothing about assumptions, validity ranges, or what is returned. Adequate but thin beyond the structured fields.

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 dense sentences with no waste: purpose and method first, then the design use cases. Every clause earns its place and nothing is buried.

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

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

With no output schema, the description compensates by stating the tool solves for trace width W and spacing S for a target impedance, giving the agent a sense of the return. It stops short of documenting output units, validity limits, or solver failures.

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 100%, including enum and defaults for mode, target_z, gap, Er, dielectric height and copper thickness, so the schema carries the parameter burden. The description adds only a high-level mapping to target impedances already exemplified in the schema – baseline 3 is appropriate.

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 (calculate) and resource (characteristic/differential impedance for PCB microstrip traces), and names the governing method (IPC-2141 / Wheeler). However, it never distinguishes itself from close siblings such as calculate_pcb_stackup_impedance or analyze_impedance_tolerance, so the agent must infer the boundary.

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

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

The examples (50Ω RF, 90Ω USB, 120Ω RS485/CAN) imply the design-time scenario, and the description notes it solves for width/spacing from a target impedance. But there is no explicit when-not-to-use or named alternative among the many impedance-related siblings, leaving routing 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?

Annotations already declare readOnlyHint=true, idempotentHint=true, destructiveHint=false and openWorldHint=false, so the safety profile is covered. The description adds useful behavioral content by revealing the deterministic selection logic, but says nothing about error cases, how the plan is computed, or the shape of the result.

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

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

A single front-loaded sentence that states the purpose before enumerating the mapping rules via a colon-separated list. Dense but every clause carries domain signal; only the very long enumeration keeps it from being 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?

For a one-parameter, fully-documented input with annotations but no output schema, the description covers the selection logic and implicitly the output content (the chosen protection types). It does not describe the returned plan's format or structure, leaving a real gap for an agent.

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 parameter with 100% schema description coverage, so the schema already documents the {id, in_pad, land_type, in_bga_pitch, vippo_filled} via list. The description does not add field-level meaning beyond the schema, making the baseline 3 appropriate.

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 (Select) and a well-scoped resource (IPC-4761 via protection types I–VII) mapped to via assembly context. An agent can distinguish it from calculation siblings like calculate_via_stitching_array. It stops short of explicitly naming a sibling to avoid, so 4 rather than 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?

Provides rich domain rules (Type VII mandatory for BGA via-in-pad, Type V for thermal pads, etc.), which imply when each selection applies, but never states when to invoke this tool versus alternatives or what preconditions must hold. Usage is implied rather than declared.

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

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

Annotations already declare readOnlyHint, idempotentHint, non-destructive, and closed-world, so the safety profile is fully covered by structured data. The description adds domain context (standards, 'thermal resistance reduction metrics') but does not describe the actual computed result shape, and there is no output schema to compensate.

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 dense sentence with the verb front-loaded, standards and modes packed efficiently, and zero filler. Nothing is repeated from the schema or annotations.

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

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

For a read-only calculation tool with 7 well-documented optional parameters, the description covers purpose and mode selection but offers no information about the returned output (no output schema exists) beyond the vague phrase 'thermal resistance reduction metrics'. Adequate but with a clear gap around results.

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 100%, so the schema already documents all 7 parameters with defaults and units. The description only adds standards context (lambda/10 pitch relating loosely to grid_pitch_mm) and does not explain parameter interactions beyond the schema. Baseline 3 is appropriate.

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 ('Calculate') and a precisely scoped resource: thermal via matrix arrays under QFN/power exposed pads or RF ground shielding fences, citing IPC-7093 §7.2 and IPC-2141A. This is clearly distinguishable from nearby siblings like calculate_via_protection_plan or calculate_pcb_stackup_impedance.

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 names two concrete usage contexts – thermal management under exposed pads and RF shielding fences with <= lambda/10 pitch – which maps directly to the is_rf_shielding_fence flag. It gives clear context but stops short of explicit 'when not to use' guidance or naming an alternative tool.

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

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

Annotations already declare this a safe, idempotent, read-only operation, lowering the bar. The description adds genuine behavioral content — the actual audit criteria (tombstoning, bridging, shadow keepouts) — but says nothing about what the audit returns or how results are reported, and no output schema exists to fill that 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?

A single front-loaded sentence with dense but relevant technical content and zero filler. Slightly long, but every clause (standards, package-specific rules, keepout) earns its place.

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

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

For a read-only audit with nested module input, the description conveys what is being checked and against which standards thoroughly. The one gap is that with no output schema, it never hints at return values, but the domain rules are complete enough to invoke 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 100% for both parameters, so the schema already documents 'modules' and 'flow_direction'. The description references flow direction contextually (perpendicular/parallel to flow) but adds no syntax, format, or constraint detail beyond what the schema supplies — baseline 3.

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 (audit) and resource (bottom-side SMD wave soldering orientation angles and hydrodynamic shadowing), plus the governing standards (IPC-7351B, SMTA). The embedded rules — chip passives perpendicular, SOIC parallel, 3xH keepout — make it unmistakable against siblings like calculate_smt_placement_clearance.

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 domain of applicability obvious (bottom-side SMD wave soldering) but never states when to use this vs. alternatives such as calculate_smt_placement_clearance, nor any prerequisites. Usage is implied by the subject matter rather than explicitly guided.

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

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

Annotations already cover safety (readOnly, idempotent, non-destructive, closed-world), so the bar is lower, and the description adds real value by enumerating what the diff reports (added/removed components and nets, pin moves, change count, ECO severity). It does not specify the severity thresholds or the fail/degenerate case for mismatched inputs, 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?

A single dense, front-loaded sentence that leads with the expanded acronym and domain, then lists report contents. It is slightly list-heavy but every clause earns its place; no filler.

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

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

With no output schema, the description usefully enumerates the return contents and severity scale, and all params are described in the schema. It is nearly complete, lacking only severity determination logic and expected input shape.

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

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

Schema coverage is 100%, so all four params (old/new modules and connections) are already documented as Revision A/B. The description adds no additional format or ordering nuance beyond the schema, so baseline 3 applies.

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

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

States a specific verb (diff/compare) and resource (two netlist revisions) plus expanded outputs, and is clearly distinguishable from siblings like validate_netlist or export_kicad_netlist. An agent can identify what it does without opening the schema.

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

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

The phrase 'for PLM change management' and 'ECO' imply the scenario, but there is no explicit when-to-use vs when-not, no prerequisites, and no alternates (e.g., validate_netlist). Usage is implied rather than stated.

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

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

Annotations already declare readOnlyHint, idempotentHint, and destructiveHint=false, so the safety profile is covered by structured data. The description adds that it computes safety margins and recommends high-CTI laminates, which is useful output context, but it says nothing about edge cases, invalid-input handling, or how the recommendation is derived. Adds some value without rich behavioral 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?

Front-loaded with verb and resource, and every clause (standards, material groups, output actions) contributes. It is a single dense run-on sentence, which slightly hurts scanability but does not waste words.

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

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

For a read-only calculation tool with no output schema, the description conveys the standards basis, input dimensions, and the shape of the result (safety margins, laminate recommendations), so an agent knows what comes back. Minor gaps remain around the exact return fields and how it differs from the overlapping clearance sibling.

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

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

Schema description coverage is 100% and every parameter (including defaults) is documented in the schema, so the baseline is 3. The description does add interpretive meaning for substrate_cti_v by mapping Group I to >=600V and enumerating Pollution Degrees 1/2/3, but it restates most of what the schema already carries.

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 (Evaluate) and a well-defined resource: substrate CTI Material Group plus required safety creepage, tied to named standards (IEC 62368-1 Table 25, IPC-2221B). The scope is clear enough to distinguish it from a generic clearance calculator, but it never names the closely related siblings (calculate_ipc2221_clearance, calculate_creepage_isolation_slot), so an agent must infer the boundary.

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

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

The domain and standards are given, which implies usage (sizing creepage from a substrate's CTI rating), but there is no explicit when-to-use, when-not-to-use, or routing to alternatives. Given heavy overlap with calculate_ipc2221_clearance in the sibling list, the absence of any disambiguation is a real gap.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true, and destructiveHint=false, so the safety profile is covered. The description adds detail about rendered content (polarity marks, mirrored view, title block) but says nothing about behavior beyond output content—no error handling, determinism, or size/complexity limits.

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 dense sentence with the verb front-loaded and no filler. It is long but every clause enumerates real output features rather than restating the name.

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

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

No output schema exists, so the description usefully enumerates what the SVG contains (outlines, refDes, polarity marks, title block). Combined with 100% schema coverage on the six parameters, an agent has enough to call it correctly; only the modules dependency and failure behavior are left implicit.

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

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

Schema description coverage is 100%, so the baseline is 3. The description echoes a few parameters (mirrored bottom view, revision/title block) but adds no format or syntax detail beyond what the schema already documents.

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 (Generate) and resource (scaled PCBA assembly drawing SVG), plus the governing standards ASME Y14.5 / IPC-2221B Sec 11. It is immediately distinguishable from sibling exporters like export_gerber_bundle, export_ipc2581, or export_kicad_schematic, which produce entirely different 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?

Usage is implied by the artifact type (you call this when you need an assembly drawing SVG), but there is no explicit when/when-not guidance and no named alternative. The dependency on synthesize_circuit output appears only in the schema, not the description.

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

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

Annotations already establish readOnly, idempotent, non-destructive, and closed-world behavior, so the safety profile is covered. The description usefully adds format specifics (IPC-NC-349, metric tool headers), but says nothing about whether output is returned inline, written to disk, or overwritten, which is the key behavior for a 'generate file' tool.

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

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

A single front-loaded sentence that leads with verb and artifact and then layers technical specifics. It is dense but contains little filler; the trailing 'for automated CNC drilling machines' is the only mildly redundant clause.

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

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

For a tool with a nested required parameter and no output schema, the description should clarify return shape or file-destination behavior, and it does not. It covers the artifact format adequately but leaves the agent guessing about output handling and the exact role of optional inputs like 'connections'.

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 100%, so all five parameters (including the nested 'modules' object and optional 'connections') are already documented in-schema. The description adds no per-parameter meaning beyond the output format, so the baseline of 3 applies.

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

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

The description states a specific verb (Generate) and a precise resource (IPC-NC-349 Excellon CNC drill file, .drl) with format-level detail like metric tool headers (T01C...). It implicitly distinguishes itself from sibling exporters like export_gerber_bundle by being the drill-specific step, though it never names or contrasts 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?

There is no explicit when-to-use, when-not-to-use, or naming of alternatives. The phrase 'completing the 5-layer PCB manufacturing bundle' hints that it belongs in a downstream export sequence, but the agent receives no guidance on ordering, prerequisites, or which sibling exporter handles which artifact.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true, destructiveHint=false and closed-world, so the safety profile is covered. The description adds useful context about output format and the concrete files produced, but never discloses where the bundle goes (written to disk vs returned inline) or any size/permission constraints, which matters for an export tool whose annotation set implies no 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?

One dense sentence with zero filler, and the core deliverable (formatted Gerber layer bundle) is front-loaded ahead of the supplier context. Slightly overloaded by the parenthetical extension list, but nothing is wasted.

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

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

Covers inputs implicitly and the layer set explicitly, but for a 4-parameter tool with nested objects and no output schema, the description omits the return shape (file paths, zip, or raw content) and the units/behavior implications of board dimensions. Adequate but 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?

Schema description coverage is 100%, so modules, netlist, board_width_mm and board_height_mm are already fully documented, including defaults and the synthesize_circuit provenance. The description adds no parameter-level detail beyond the schema, so the baseline 3 applies.

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

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

Specific verb ('Generate') plus precise resource (native fabrication-ready Gerber RS-274X layer bundle) with the exact layer/file set enumerated (.gm1, .gtl, .gts, .gto). An agent can distinguish this from the many sibling exporters (export_excellon_drill, export_ipc2581, export_kicad_netlist, export_specctra_dsn) without opening any schema.

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

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

No when-to-use, prerequisites, or alternatives are stated. 'Eliminating GUI EDA dependency' is a benefit claim, not guidance about when to select this over export_excellon_drill or export_ipc2581, which produce the complementary drill/assembly data a fab bundle usually needs alongside Gerbers.

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

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

Annotations already declare readOnly, idempotent, non-destructive, closed-world behavior, so the safety profile is covered. The description usefully adds the packaged contents (single-file XML replacing a multi-file handoff bundle), but says nothing about where the file is written, how output is retrieved, or prerequisites such as needing synthesize_circuit output first.

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; every clause carries information (format, contents, audience, alternative). It is dense and long but not padded.

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

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

No output schema exists, and the description compensates by thoroughly describing what the produced artifact contains. Combined with the annotations' safety profile and the fully documented input schema, an agent has enough to select and invoke it correctly.

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

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

Schema description coverage is 100%, so the schema already documents all six parameters, and the baseline is 3. The description loosely maps its content list (stackup, BOM, nets) onto modules/connections/stackup_layers but adds no syntax, format, or constraint detail beyond the schema.

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

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

States a specific verb (Export) and resource (IPC-2581B single-file intelligent fabrication data package in XML), then enumerates its contents (stackup, BOM, placed components, nets with pin membership, board profile). This clearly separates it from the other export_* siblings, notably export_gerber_bundle and export_excellon_drill.

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

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

The phrase 'replacing the legacy Gerber+Excellon+TXT handoff bundle' implicitly routes the agent away from the gerber/excellon siblings toward this one, and naming Siemens X / Altium / Zuken / EMS houses gives downstream context. It stops short of an explicit 'use instead of export_gerber_bundle when X' statement, so no exclusions are spelled out.

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

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

Annotations already declare readOnlyHint, idempotentHint, and destructiveHint=false, so the safety profile is covered. The description adds that output is a universal ASCII format targeted at specific test hardware, but says nothing about where the file is written, what is returned, or whether required inputs must come from a prior synthesis step — all of which the annotations do not cover.

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 naming the artifact, format, and audience with no filler. Every clause earns its place and nothing is redundant.

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

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

With five parameters, nested object inputs, and no output schema, the definition should clarify the return artifact (file path, string contents, or written file) and the required upstream synthesize_circuit inputs. The description delivers the format context but leaves the return contract and workflow prerequisites unstated.

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

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

Schema description coverage is 100% (including the origin note for modules/netlist and defaults for job_name and board dimensions), so the schema carries parameter meaning. The description adds no parameter-level detail beyond restating the file type, making the baseline 3 appropriate.

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 (Generate) and a precise resource (IPC-D-356A ASCII bare-board electrical test netlist file), plus the consuming equipment. The format naming implicitly separates it from sibling exporters like export_ipc2581 and export_kicad_netlist, but no sibling is ever named directly, so an agent must infer the boundary from format knowledge alone.

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

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

Naming flying-probe testers (AEMG, ATG, MicroCraft) and bed-of-nails fixtures implies the downstream use case, but there is no explicit when-to-use statement, no exclusion against the many other export_* siblings, and no prerequisite such as 'requires netlist from synthesize_circuit'.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true, destructiveHint=false and openWorldHint=false, so the safety and repeatability profile is covered without help from the description. The description adds useful format/version-compatibility context but says nothing about where the file is written, whether an existing .net is overwritten, or what is returned.

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 naming the artifact and its compatibility; nothing is padded or redundant.

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

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

With a nested-object required parameter and no output schema, the description should say what the export produces (file path, content, or written-to-disk side effect) and what shape the input netlist must take. Those gaps are modest for a two-parameter exporter but leave an agent guessing about the result of the call.

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

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

Schema description coverage is 100%, so the schema already documents both 'title' and 'netlist' (including the nested-object nature of netlist). The description contributes no additional parameter meaning, which is the expected baseline when the schema does the heavy lifting.

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) plus a specific resource and format (KiCad S-Expression netlist, .net), and even pins version compatibility with Pcbnew 6-10. The file-type specificity inherently separates it from export_kicad_schematic, export_specctra_dsn and export_ipc2581, though it never names a sibling explicitly to draw the contrast.

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

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

There is no statement of when to choose this exporter over the other export_* siblings, no prerequisite (e.g. a validated netlist, like validate_netlist), and no condition under which it should be avoided. Usage must be inferred purely from the output format name.

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

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

Annotations already establish readOnly/idempotent/non-destructive behavior, so the bar is lower, yet the description adds real value by spelling out what the emitted artifact contains (sheet layout, component symbols, pin references, LCSC attributes). It still does not mention where the file is written or whether it overwrites an existing .kicad_sch.

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

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

A single front-loaded sentence with the verb and format up front and zero filler. Every clause (format version, file extension, contents) carries information.

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

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

With no output schema, the description helpfully characterizes the returned/generated artifact, and the required 'modules' input is documented in the schema. It stops short of stating the workflow dependency or output destination needed to call it fully 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 100%, so the schema already documents 'title', 'modules' and 'connections'. The description adds no per-parameter meaning (e.g. what the nested modules object must contain) beyond what the schema states, so the baseline 3 applies.

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

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

Specific verb ('Export') plus a precisely scoped resource ('KiCad 8/9 S-Expression schematic file (.kicad_sch)'), with the output's contents enumerated. The KiCad-schematic focus clearly separates it from the sibling export_kicad_netlist without needing the schema opened.

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: the phrase 'directly viewable and editable in KiCad Eeschema' tells the agent why one would call it, but there is no explicit when-to-use statement, no prerequisite (e.g. that modules should come from synthesize_circuit), and no contrast with export_kicad_netlist or export_ipc2581.

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

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

Annotations already cover the safety profile (readOnlyHint, idempotentHint, destructiveHint=false, openWorldHint=false), so the bar is lower. The description usefully discloses the output content (grouped parts, aggregated designators, Basic/Extended classification), but says nothing about whether the CSV is returned inline or written to disk, which is the key behavioral unknown for an 'export' tool.

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

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

A single dense sentence with zero filler; the output format and its three transformations are front-loaded with nothing trailing.

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?

Wait – no output schema exists, so the description must carry the return-value burden, and it does name the artifact and its structure (grouped BOM CSV with classification).

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 parameter with 100% schema coverage, so the schema already documents the netlist. The description adds no input-side semantics: it does not state that the netlist must be validated, nor what netlist shape is acceptable (raw dictionary vs synthesis result).

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 ('Generate ... JLCPCB SMT BOM CSV') plus the three processing behaviors (part grouping, designator aggregation, Basic/Extended classification). An agent can distinguish it from calculate_bom_cost, generate_interactive_bom, and export_assembly_drawing_svg without opening any schema.

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

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

No when-to-use guidance and no alternatives named. It never says whether the netlist must first pass validate_netlist, or when an agent should pick this over generate_interactive_bom or calculate_bom_cost.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true, destructiveHint=false, and openWorldHint=false, so the safety profile is fully covered. The description adds that the output is 'production' grade and targets automated robotic assembly, but says nothing about where/whether the CSV is written or what returns. Read-only generation of file content is consistent with the annotations, so no contradiction.

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

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

A single sentence with the verb and artifact front-loaded and no wasted clauses. The parenthetical column list is dense but earns its place by clarifying expected output; only minor cost is a slightly run-on structure.

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

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

With no output schema, the description compensates by enumerating the CSV columns, and the schema documents the required modules source and board dimensions. Missing only usage sequencing and any note on how the job relates to the feeder/pick-and-place pipeline.

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 100%, so all three parameters (modules, board_width_mm, board_height_mm) are already documented with defaults. The description's field list (part, designator, X/Y, rotation, nozzle ID, feeder slot) describes output content rather than adding meaning to the inputs, so baseline 3 applies.

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

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

Specific verb ('Generate') plus a precisely named resource (OpenPnP/industrial SMT pick-and-place job CSV), with the exact emitted columns enumerated so the agent knows what artifact results. The format specificity cleanly separates it from siblings like export_manufacturing_bom, export_kicad_netlist, and generate_assembly_process_plan.

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 or when-not-to-use guidance is stated. It never mentions the upstream dependency on synthesize_circuit/validate_netlist, nor how it relates to the adjacent calculate_smt_feeder_matrix or generate_assembly_process_plan tools, leaving the agent to infer sequencing.

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

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

Annotations already cover read-only, idempotent, non-destructive, and closed-world traits, so the bar is low. The description adds a genuinely non-obvious behavior - 'Includes heuristic component auto-placement' - which tells the agent this does more than serialize data. It still omits file destination/output handling, so not 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?

Two focused sentences, front-loaded with the deliverable and its consumers, with zero filler. Every clause carries information about format, version, purpose, or behavior.

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

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

With no output schema, an agent would benefit from knowing what is returned (file path? inline data?) and where the interchange file lands. The description plus annotations otherwise cover the operation well, so the gap is minor rather than fatal.

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 100%, so the schema fully documents clearance, board dimensions, and trace width; baseline 3 applies. The description adds no parameter syntax or format detail beyond what the schema provides, though the DSN version is noted.

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 (Generate) and resource (Specctra DSN v15.0 auto-router interchange file), with version and intended downstream consumers. The format name distinguishes it from siblings like export_kicad_netlist, export_gerber_bundle, or export_ipc_d356 without needing to open their schemas.

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?

Names the target tools (Freerouting, Cadence Specctra, Altium, KiCad) for auto-routing, which implies the use context, but gives no explicit when-to-use / when-not guidance or routing between this exporter and the many other export_* siblings. Usage is only inferable.

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

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

Annotations already declare readOnly/idempotent/non-destructive, and the description adds real substance by naming the classification standard (IPC-A-610G Section 7) and the concrete output sequence (SPI -> ... -> packing). It does not state error modes or how components map to stages, but the behavioral payload is well above the annotation baseline.

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

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

One dense sentence, front-loaded with the core action before the classification and routing detail. The parenthetical 10-stage chain is long but is genuinely informative rather than padding; no redundant sentences.

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

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

With no output schema, the description properly compensates by spelling out the return structure: per-component stage classification plus the 10-stage EMS route. What's missing is whether per-component classification is returned alongside the route and how nested module data is consumed.

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?

Only one parameter exists and schema description coverage is 100%, where the schema already explains modules as a component dict from synthesize_circuit. The description adds no format or structural detail about that dict, so the baseline 3 applies.

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

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

States a specific verb (Generate) and a precise resource (mixed-assembly process route plan), then enumerates the exact classification buckets and the 10-stage routing produced. No sibling in the list competes with this output type (siblings are calculators/exporters), so 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?

Usage is only implied: the schema notes modules come 'from synthesize_circuit output', which hints at the upstream step, but the description itself never says when to invoke this versus the adjacent audit/calculation tools or what prerequisites must hold. Adequate but leaves routing 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?

Annotations already declare readOnlyHint=true, idempotentHint=true, destructiveHint=false, openWorldHint=false, so the safety profile is fully covered. The description usefully adds that the output is lightweight and self-contained in a single file, but it never clarifies how the artifact is delivered (written to disk vs. returned inline) or that it depends on upstream synthesis output — a notable omission given readOnlyHint on a 'generate' tool.

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

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

A single, front-loaded sentence that opens with the verb and artifact, then lists the distinguishing features. No filler sentences and nothing redundant; every clause carries information.

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

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

For a tool with no output schema, the description explains what the generated artifact contains, which partly compensates for the missing return definition. It still leaves open how the HTML is surfaced to the caller, the dependency on synthesize_circuit output, and any sizing/scale caveats around board dimensions.

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 100%, so the schema already documents title, modules, board_width_mm and board_height_mm with defaults. The description adds no parameter-level meaning beyond that, so the baseline of 3 applies.

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

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

States a specific verb (generate) and a precise resource (single-file Interactive HTML BOM / iBOM), and enumerates the artifact's contents (grouping table, SVG board map, hover/click inspection). An agent knows exactly what artifact this produces. It does not, however, name a sibling it differs from (e.g. export_assembly_drawing_svg or export_manufacturing_bom), so the 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?

There is no when-to-use guidance, no statement of prerequisites (that `modules` must come from synthesize_circuit), and no comparison against the many other export/render siblings. Usage is only implied by the description's wording; nothing tells the agent when this tool is the right choice over the alternatives.

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

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

Annotations already declare readOnlyHint, idempotentHint, destructiveHint=false and openWorldHint=false, so the safety profile is covered. The description adds genuinely useful context beyond that — the result set is fixed and finite (exactly 10) and each entry is pre-validated — but says nothing about the item shape or ordering.

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

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

A single front-loaded sentence with no filler; the fixed-size and pre-validated qualifiers are packed in without redundancy.

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

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

For a trivial read-only discovery tool with full annotation coverage and no output schema, the description is nearly sufficient. The main omission is what a CircuitBlock entry contains, which would help an agent chain this into synthesize_circuit, but that gap is minor at this complexity level.

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

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

The tool takes zero parameters and the description introduces no invented arguments, so there is nothing to mis-document. Baseline of 4 applies for a no-parameter tool.

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

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

States a specific verb (List) plus resource (CircuitBlocks) and qualifies scope with 'all 10 pre-validated' in the hardware DSL catalog, so the agent knows exactly what comes back. It does not, however, distinguish itself from similarly named discovery siblings like list_supported_chips or search_lcsc_parts.

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: as a parameterless catalog listing, it is naturally a discovery step before synthesis or validation. There is no explicit statement of when to prefer it over search_lcsc_parts or list_supported_chips, and no prerequisites are mentioned.

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

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

Annotations already declare readOnlyHint, idempotentHint, non-destructive and closed-world, so an agent knows this is a safe, side-effect-free enumeration. The description adds the content scope (chips plus third-party pinout allocation rules) but says nothing about how results are ordered, paginated, or whether custom vs. built-in entries are distinguished.

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 no filler; the resource scope and examples occupy exactly the space they need and nothing is repeated from the schema or annotations.

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

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

For a trivial zero-param enumeration with full annotation coverage, the description conveys what is returned at a scope level and needs no parameter or return-format detail. It could be slightly more complete by noting whether results include custom-registered chips from register_custom_chip, but nothing blocks 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?

Zero parameters, so the schema cannot carry parameter meaning and the baseline is 4. The description correctly implies this is an unfiltered full listing, aligning with the empty input 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 ("List") and resource ("registered MCU chips and third-party pinout allocation rules"), with concrete chip examples that make the domain unambiguous. It implicitly contrasts with the sibling register_custom_chip by emphasizing registered/allocated entries, but never names it, so sibling differentiation is inferential rather than explicit.

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

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

There is no explicit when-to-use statement naming alternatives such as register_custom_chip or validate_netlist. However, "all registered" strongly implies the discovery use case: call this to see which chips and pinout rules already exist before registering or validating. That is implied usage, not stated guidance.

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

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

Annotations already declare readOnlyHint, idempotentHint, and non-destructive, so the safety profile is covered. The description adds useful process context — the 300x300mm fab limit framing and that results are ranked by material utilization — but says nothing about cost, pagination, or how many combinations may be returned.

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 dense sentence with no filler; the enumeration step is front-loaded ahead of the filtering and ranking steps. It is slightly long but every clause carries information.

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

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

With no output schema, the description carries the return-value burden and does so adequately by stating that feasible layouts are ranked by material utilization percentage. Defaults and the fab-limit constraint are present, so an agent has what it needs to call the tool.

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

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

Schema description coverage is 100%, so all five parameters are self-documented and the baseline is 3. The description broadens meaning by naming what is enumerated (grid_x x grid_y, rail sides, V-cut vs mouse-bites), but V-cut vs mouse-bites has no corresponding input parameter, so it clarifies outputs rather than inputs.

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

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

States a specific verb chain and resource: enumerate panel grid combinations, filter by max panel size, rank by material utilization. An agent immediately knows this is a panelization exploration tool, which is distinct from sibling calculate_pcb_panel_rails, though the description never explicitly names or contrasts that sibling.

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

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

Usage is implied by the described behavior (explore feasible panel layouts before committing to one), but there is no explicit when-to-use statement, no prerequisites, and no routing to the closely related calculate_pcb_panel_rails sibling. The agent must infer the 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?

Annotations already declare readOnlyHint=true, idempotent and non-destructive, so the safety profile is covered. The description still adds meaningful runtime context beyond the annotations: it discloses the GT pinning strategy, center-of-gantry placement rule, and per-batch run-out forecasting under IPC-9851, which tells the agent what the optimization actually 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?

A single dense sentence that front-loads the verb and resource before the algorithm detail. Every clause carries information, though the brand enumeration (Panasonic NPM / Fuji NXT / ASM SIPLACE) is slightly padded.

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

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

No output schema exists, but the description compensates partially by naming what the optimization produces: pinned common reels, high-frequency placement, and run-out exhaustion forecasts. It does not describe the return structure or pagination/serialization, leaving a modest gap for a nested-input computation tool.

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

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

Schema description coverage is 100%, so the schema already documents all four parameters, including defaults and the nested modules object. The description only weakly echoes batch_size ('per batch size'), adding no syntax or format detail beyond the schema, so the baseline of 3 applies.

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

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

States a specific verb+resource: optimizing SMT pick-and-place feeder trolley allocation on an 80-slot cart, and even names the machine platforms and the algorithms used. An agent can tell it apart from generic siblings, but it never addresses the very close sibling calculate_smt_feeder_matrix, so the boundary between the two is left implicit.

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: the description makes clear this is for SMT line feeder-cart setup, but it gives no when-to-use/when-not, no prerequisites (e.g. that 'modules' must come from synthesis or a netlist), and no pointer to an alternative such as calculate_smt_feeder_matrix.

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

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

Annotations already declare this is a non-read-only, idempotent, non-destructive, closed-world write, so the safety profile is covered. The description usefully adds that the operation can 'dynamically override' an existing definition, which aligns with idempotentHint. It omits persistence scope (session vs durable), effect on existing designs, and any validation 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 sentence with zero filler and the core action front-loaded. It is efficient, though extremely terse relative to the tool's ten-parameter, nested-object complexity.

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

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

For a mutation tool with 10 parameters, nested objects, and no output schema, the description is thin: it does not say whether the registration persists, whether overriding replaces the whole definition or merges, or how it interacts with downstream tools. The rich schema compensates for parameter coverage, but behavioral context is left largely to the annotations.

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

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

Schema description coverage is 100% across all 10 parameters with concrete examples (chip_id 'CH32V003F4P6', pin_numbers map, peripheral_routes), so the schema carries the parameter burden. The description adds no parameter-level detail beyond what is already documented, which is the expected baseline here.

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

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

States a specific verb (register/override) and a specific resource (third-party MCU pinout and peripheral multiplexing rules), which is enough to separate it from read-only siblings like list_supported_chips. However, it never names or contrasts with any sibling explicitly, so the 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?

There is no explicit when-to-use guidance, no prerequisites, and no mention of alternatives such as list_supported_chips or validate_netlist. The phrase 'third-party' and 'dynamically override' weakly imply the case of an unsupported chip, but the agent must guess the trigger condition.

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