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

Annotations already cover the safety profile (readOnly, idempotent, non-destructive), so the description is free to add deep methodological context: corner enumeration validity via monotonicity, why naive RSS of percentages is invalid, the TI SNVA112 citation, and the inclusion of TCR/life drift/supply/ratio tolerance. This is exactly the value-add context annotations cannot 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?

It is a single dense paragraph but front-loads the core purpose and then justifies the two methods. Every clause is technical and earns its place for a domain expert, though the parenthetical heavy phrasing slightly reduces scannability.

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

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

With an output schema present, return values needn't be explained, and the description fully covers methodology and what is included. The main remaining gap is its silence on the specific sibling to choose instead, which is only partially mitigated by the strong method explanation.

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

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

Schema coverage is 100%, so all nine parameters are documented in the schema, making 3 the baseline. The description does mention the contribution categories (TCR, sqrt-of-time drift, supply, matched-pair ratio) which loosely maps to parameters, but adds no syntax or format detail 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 states a specific computational target (worst-case and statistical tolerance band of a resistor divider) and even explains why each method is valid. It clearly distinguishes its output from a naive nominal answer, but never names a sibling tool (e.g., analyze_resistor_error_budget or solve_feedback_divider) to route the agent away from 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?

Usage is only implied: 'nominal is not a specification' signals when you'd want it, but there is no explicit when-to-use/when-not or named alternative. Given the presence of close siblings like analyze_resistor_error_budget, this leaves the agent to infer routing.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true, destructiveHint=false, so the safety profile is covered. The description does add real analytic context beyond that — the acceptance windows, the factors that drive the black-pad susceptibility score, and the gold >0.25 μm embrittlement flag — but says nothing about how results are reported or whether the output is advisory versus a hard pass/fail gate. With no output schema, a description at this level of detail could do more on the reporting side.

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, but it is front-loaded with the tool's identity and then enumerates thresholds and scoring inputs in a logical order. Semicolon-heavy and slightly run-on, though every clause carries information; little could be cut without losing thresholds.

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 read-only analytic tool with no output schema, the description covers the domain standards, the numeric windows, the risk factors scored, and the embrittlement flag — enough for correct invocation. The gap is the return shape: 'scores' and 'flags' are named but the agent cannot anticipate the result structure, and with no output schema that burden falls here.

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% with defaults on six of seven parameters, so the baseline is 3. The description exceeds that by giving the acceptance windows for four of those parameters (gold 0.05~0.20 μm, nickel 3.0~6.0 μm, phosphorus 7~10 wt%, palladium 0.10~0.30 μm), which tells the agent what values are in-spec rather than just what units to supply.

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 — 'ENIG/ENEPIG plating thickness and black-pad risk auditor' — plus the governing standards (IPC-4552A, IPC-4556). No sibling tool in the list covers surface-finish/black-pad analysis, so the agent can route to it unambiguously.

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 purpose implies the usage context (qualifying ENIG/ENEPIG plating and screening black-pad risk), but there is no explicit when-to-use, when-not-to-use, or named alternative among siblings. The agent must infer that this applies to finish qualification rather than, say, fab capability auditing.

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 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 this a safe, idempotent, closed-world read, so the description's value is domain behavior — and it delivers: it discloses the actual comparison thresholds (1.56 μg/cm², 1.20 Class 3), the per-species halide limits (chloride 0.70, bromide 0.54), and that risk is derived from bias voltage and conductor pitch. It does not describe the shape or scale of the returned risk score, which keeps it below 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 front-loaded sentence that opens with the verb and standards before enumerating outputs; every clause carries information. It is dense with parenthetical thresholds, which costs some readability but wastes no 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?

Covers a 6-parameter tool with a nested species object and no output schema well: inputs, standards, and computed judgments are all accounted for. The remaining gap is that without an output schema the description should say what the analysis returns (pass/fail, risk score range), which it leaves implicit.

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

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

Schema coverage is 100%, so the baseline is 3; the description earns above that by explaining what the parameters actually feed — that bias_voltage_v and min_conductor_gap_mm drive the dendrite/CAF model, that target_class selects the applicable limit, and that species results are for halide carryover checks. It adds interpretive meaning rather than restating defaults.

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 and resource (post-clean ionic contamination / ROSE + ion chromatography compliance analysis) and enumerates the three concrete things it produces: class-limit comparison, per-species halide flagging, and dendrite/CAF risk scoring. No sibling tool in the list touches contamination or cleanliness, and the IPC standard citations cement the domain uniquely.

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 phrasing 'Post-clean ... compliance analyzer' and the standards cited, so an agent can infer it belongs after a cleaning step and before conformance sign-off. However, it never states when to prefer it, what prerequisites (ROSE measurement must already exist) are needed, or what to do when only species data is available without a ROSE reading.

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 readOnlyHint, idempotentHint, destructiveHint=false and closed-world, so the safety profile is covered. The description adds real behavioral context by revealing the underlying model (voltage-bias retention affects actual capacitance) and what the result contrasts against. It does not, however, disclose model fidelity or accuracy limits, which matters for an engineering estimate.

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

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

Three sentences, purpose front-loaded, no filler. The middle sentence is an illustrative example rather than a directive, so it is slightly longer than strictly necessary, but it earns its place by conveying the magnitude of the derating effect.

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

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

With an output schema present, the return-value sentence is partly redundant, and all eight parameters are schema-documented, so an agent has what it needs to call the tool. The remaining gap is guidance on precision/assumptions of the derating model, which is a minor omission for this scope.

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

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

Schema description coverage is 100% across eight parameters, so the schema already defines r_ohm, marked_c_uf, rated_v, applied_v, dielectric and the rest. The description only indirectly implies the bias and dielectric inputs through its example and adds no syntax, units, or defaulting guidance 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?

The opening clause names a specific computational resource (RC filter cutoff) with an explicit scope qualifier: it uses the capacitance the part actually has, not the marked value. The contrast with 'the nominal calculation' makes it distinguishable from the sibling that only returns retention (calculate_effective_capacitance) or generic parametric solvers.

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 X5R-under-bias anecdote implies the use case (when DC bias derating materially shifts cutoff), but it never states 'use this when... / use X instead when...' and names no sibling tool. The agent must infer the selection rule from the narrative rather than being told it.

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

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

Annotations already declare readOnlyHint, idempotentHint, and non-destructive, so safety is covered. The description adds real behavioral value beyond that: it reports both an RSS band and a linear worst-case band, names the dominant term, and discloses that life drift scales with sqrt of the time ratio rather than linearly — a non-obvious modeling choice an agent would otherwise mis-assume.

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

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

Front-loaded with the computation and its inputs in the first sentence, then outputs, then a modeling caveat. The thick-film TCR anecdote is longer than strictly necessary but earns its place by motivating the dominant-term output; only minor trimming would improve it.

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, a 100%-covered seven-parameter schema, and an output schema, the description supplies exactly the remaining context: which four terms feed the model, what the two output bands mean, how drift is scaled, and which term dominates. Nothing needed to invoke or interpret the tool is missing.

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

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

Schema coverage is 100%, so baseline is 3. The description earns a bump by clarifying the relationship the schema only names individually: life_drift_pct is scaled by sqrt(life_hours_required/life_hours_specified) as a random walk, and TCR contribution is tied to temperature excursion — semantics not captured by the flat per-field descriptions.

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

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

States a specific computation — the end-of-life resistance band for a single resistor from a four-term error model — and enumerates the four terms (value tolerance, TCR, life drift, ratio tolerance). This is clearly separable from siblings like analyze_divider_tolerance or analyze_impedance_tolerance, which operate on networks/impedance rather than a single resistor's error stack.

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

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

Usage is implied rather than stated: the tool is scoped 'for one resistor' and mentions 'matched networks' for ratio tolerance, and the ±0.1% thick-film example signals the diagnostic intent. However, no sibling alternative is named and there is no explicit when-to-use/when-not guidance relative to analyze_divider_tolerance or analyze_impedance_tolerance.

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/non-open-world, so the bar is lower. The description adds real substance beyond that: the methodology (F=ma inertial loading), the corner high-strain heuristic, stiffener-aware frequency estimation, and that it emits mitigation prescriptions (underfill, center-migration, boss-fastening). It does not describe the result structure, but it is an assessor with no output schema, so this is a solid contribution.

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, but it is front-loaded with the standard and test condition, then enumerates computations and outputs in a logical order. Every clause carries information; it is packed rather than padded, though the density makes it slightly hard to scan.

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

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

For a 6-parameter analytical tool with no output schema, the description does well: it names the standard, the loading model, and the categories of output (flags, frequency estimate, mitigation prescriptions), which compensates for the missing output schema. Minor gaps remain around result formatting and whether to supply the components array, but nothing essential is missing.

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

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

Schema coverage is 100% and every parameter is documented in the schema, so the baseline of 3 applies. The description adds only light semantic context — that a border-ring stiffener affects the frequency model and that the standard drives the shock defaults — without elaborating on the components array fields or coordinate semantics beyond what the schema 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?

States a specific verb (assess) plus the precise resource and standard: JEDEC JESD22-B111 board-level drop shock, with the exact test condition (1500 G / 0.5 ms half-sine, 30 drops). It enumerates the actual computations (inertial joint loads, corner-strain flagging, natural frequency, mitigations), making it clearly distinct from siblings like estimate_solder_joint_thermal_fatigue.

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 JEDEC reference and drop-shock framing imply the scenario (board-level drop qualification), but the description never says when to pick this versus related reliability tools such as estimate_solder_joint_thermal_fatigue or predict_assembly_mtbf, nor any exclusions. Usage is inferable rather than 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 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 establish that this is read-only, idempotent, non-destructive, and closed-world. The description adds useful domain behavior: it checks pad-width symmetry, targets 0201–0805 passives, and flags direct solid-plane connections lacking thermal relief spokes. It does not describe output severity or result format, but the core audit behavior is clear.

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

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

The description is a single front-loaded sentence with no obvious filler, and the standards citation plus failure-mode naming are useful. It is dense but appropriately sized for a specialized audit tool.

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

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

For a specialized read-only audit tool with complete schema descriptions and clear annotations, the description gives enough domain context to understand the check. The main remaining gap is that no output schema exists and the return structure/severity detail is not specified.

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 context by tying the components to passive packages and pad-width symmetry, but it does not define acceptable pad_type values or explain precisely how default_trace_width_mm affects the audit.

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 audit purpose: SMT passive tombstoning risk, thermal relief symmetry, and unbalanced wetting torque. It is clearly distinguishable from sibling calculation and export tools by naming the exact failure mode and package scope.

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 strongly implied by 'risk auditor' and the described checks, so an agent can infer this is for SMT tombstoning review. However, it does not explicitly say when to use this versus related tools such as land-pattern or solder-paste calculations, nor does it state exclusions.

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

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

Annotations already declare 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 read-only, idempotent, non-destructive behavior, so the description does not need to restate safety. It adds useful context by naming the generated artifacts and the 'zero JVM dependencies' property, but it does not describe failure behavior, whether any files are written, or how the engine choice affects outcomes beyond what the schema already says.

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 front-loaded sentences cover the action and the outputs with little waste. The 'zero JVM dependencies' clause is slightly promotional rather than operational, which keeps it from a 5.

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

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

For a compute-heavy tool with no output schema, the description usefully enumerates the returned outputs (SES data, completion rate, track length, via count, layer utilization). The rich schema covers all parameters, so the main remaining gap is workflow context about prerequisites and when this tool should be selected over related siblings.

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

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

Schema description coverage is 100% and includes detailed defaults and engine tradeoffs, so parameter meaning is already fully documented. The description adds no parameter-specific guidance beyond the schema, which is the correct baseline when the schema carries that burden.

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

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

The description states a specific verb and resource: 'Execute automated native PCB layout and multi-layer track routing on circuit specifications'. It also names the output artifacts (Specctra SES data, physical metrics), which helps separate it from sibling export/analysis tools. It stops short of explicitly naming which sibling to use instead, so it doesn't reach a 5.

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

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

There is no explicit when-to-use, when-not-to-use, or alternative-tool guidance. The reader can infer it is the autorouting step, but the description never says to run it after validate_netlist/synthesize_circuit or how it relates to run_pcb_drc or export_specctra_dsn.

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, so the safety profile is covered. The description adds genuinely useful context beyond that: no network, no keys, stdlib-only, deterministic offline math, and that the manifest is SHA-256 tamper-evident over the manufacturing artifacts. It does not mention currency, pricing-accuracy caveats, or how the cross-vendor recommendation is decided.

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 purpose (cost budget + submission manifest) and then the differentiators (offline, no keys, stdlib-only, environments). No filler or restatement of the tool name.

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

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

For a 10-parameter tool with a nested artifacts object and no output schema, the description covers inputs and execution environment well but says nothing about the returned structure — what the budget object contains, currency/units, or what the manifest looks like. The agent knows what it will compute but not what it will receive.

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% with defaults and enum-like value lists on every field, so the schema carries most of the load. The description still adds framing by enumerating the cost dimensions (layers, quantity, area, finish, SMT, shipping, lead priority) that correspond to parameters, and it flags the artifacts object as the manifest input — meaningful for the one nested parameter.

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

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

States concrete verbs and resources: offline cost math over public price ladders (layers, qty, area, finish, SMT, shipping, lead), cross-vendor recommendation for JLCPCB/PCBWay, and a SHA-256 tamper-evident manifest over artifacts. An agent can tell it produces a budget plus an order-staging manifest. It stops short of naming the obvious sibling, calculate_fab_cost, so the boundary with that tool 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?

Gives an implied context — 'for CI order staging', offline/no-network on a laptop or Docker runner — which tells the agent this is a pre-submission estimation step. But it never states when to prefer it over calculate_fab_cost or the export_*/validate_* siblings in the same family, and there are no explicit exclusions.

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

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

Annotations already establish read-only, idempotent, non-destructive behavior. The description adds useful domain behavior beyond annotations: continuity thresholds, class-dependent isolation voltages, and automatic derating to 100V on fine-pitch or sensitive RF nets to prevent arc-over damage.

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

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

The description is a single dense but front-loaded sentence with no filler. The parenthetical thresholds and derating rule earn their place, though the sentence is somewhat long and could be easier to scan if split.

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 planning tool with full schema descriptions and no output schema, the description covers the core domain rules needed to call it correctly. It does not describe the returned recipe shape or how omitted optional nets affect defaults, which keeps it from 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%, so the schema already explains the parameters. The description adds meaningful domain semantics by tying thresholds to signal versus power nets, voltages to target class, and derating to fine-pitch clearance and sensitive RF nets.

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 and resource: 'Plan IPC-9252B bare-board electrical test recipes' for flying probe or bed-of-nails universal grid. It is clearly not a generic PCB calculation, but it does not explicitly distinguish itself from related siblings such as calculate_ict_testpoints.

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 planning context and the tester_type/target_class parameters, but there is no explicit when-to-use, when-not-to-use, or alternative-tool guidance. An agent can infer the domain but must decide on its own versus sibling PCB test/audit 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 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 cover safety (readOnly, idempotent, non-destructive, closed-world), and the description adds substantial model behavior: four multiplicative loss mechanisms, which one dominates (DC bias, 35-65% at rated voltage, worse in small cases), the fact that tolerance is applied at the pessimistic end, and that the response exposes a per-factor breakdown plus a confidence label. This is exactly the kind of domain-specific behavior an agent needs and cannot get from schema or 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?

Front-loaded with the core insight (marked ≠ in-circuit) and structured from model → return shape → optional measured path. Slightly padded by rhetorical framing ('the marked value is not the value in circuit', 'see which mechanism hurt most'), but no sentence is truly wasted.

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

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

For a 10-parameter, 3-required engineering calculator with an output schema, the description covers the model, the dominant failure mode, the Class I edge case, and the measured-input escalation path. Nothing an agent needs in order to call it correctly or interpret the result is missing.

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

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

Schema description coverage is 100%, so baseline would be 3, but the description adds meaning the schema does not: it explains that measured_retention_at_bias supplants the internal band estimate and changes the returned confidence field, and that Class I dielectrics bypass the loss stack entirely. That linkage between an input and an output attribute is genuine added semantics.

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

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

States a specific verb (compute effective capacitance) and a precisely bounded resource (Class II MLCC at real DC-bias/temperature/age conditions), and immediately distinguishes itself from the naive marked-value calculation. An agent can tell this apart from siblings like size_hold_up_capacitor or analyze_rc_filter_effective 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?

Gives a clear trigger (real in-circuit derating, not the reel value) and an explicit mode switch: supply measured_retention_at_bias from a Murata SimSurfing / TDK SEAT curve to get confidence='measured' instead of the band estimate. It also names the case where it degenerates (C0G/NP0 → tolerance-only). It stops short of naming sibling tools to use instead, so not 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?

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 establish a safe, idempotent, read-only computation, so the description only needs to add analysis semantics — and it does, by disclosing that results follow IPC-4562B/IPC-2141A and that the tool goes beyond numeric output to recommend a foil profile for eye-margin recovery. It does not describe output units or the shape of the recommendation, which keeps it below 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?

One dense sentence that front-loads the computed quantities, then qualifying standards, then frequency/application scope, then the recommendation behavior. No filler and nothing repeated from structured fields.

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-required-argument calculation with no output schema, the description supplies standards basis, frequency validity range, target applications, and the fact that a recommendation is returned. What is missing is any hint about output fields/units or how the max_acceptable_ksr threshold affects the recommendation.

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% with defaults and units documented per field, so the description correctly leans on the schema. However, it names 'ED, VLP, or HVLP/RTF' profiles while the foil_type schema lists only 'standard_ed', 'vlp', 'hvlp' — RTF is not an accepted value, a minor mismatch that could mislead an agent choosing a profile.

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) and three distinct outputs (skin effect depth, Hammerstad Ksr, conductor attenuation), plus a secondary output (foil profile recommendation). This is clearly separable from siblings such as calculate_trace_impedance 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?

Scope is well bounded: 1GHz–50GHz signals with named application contexts (PCIe 5.0/6.0, USB4, 112G PAM4), which tells the agent when this tool applies. It stops short of naming an alternative tool or stating when not to use it, but the applicability window is 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, 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 readOnly, idempotent, non-destructive behavior, so the safety profile is covered. The description adds meaningful engineering context (0.15–0.25mm outgassing web, 50–70% coverage envelope, >35% void limit), but says nothing about what happens when the requested coverage cannot be met with the given pad/web combination, nor what the solver actually returns.

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

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

A single front-loaded sentence that names the standard, the operation, the output form, and the failure modes it prevents. Dense with jargon 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 pure computational tool with all-defaulted parameters the description is largely self-sufficient, but with no output schema in place it leaves the return value (grid dimensions, aperture count, achieved coverage) unspecified. An agent knows why to call it but not precisely what it will get 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?

Schema coverage is 100%, so all six parameters are documented in structured data; the description merely echoes the coverage range and web width already present. It adds no guidance on the two behaviorally important booleans (is_automotive_class3, has_unfilled_thermal_vias), so the schema-does-the-work 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 and resource: an IPC-7093A/IPC-7525A solver that converts solid 100% paste openings on QFN/BTC thermal slugs into a window-pane matrix grid. The domain restriction (thermal slug only) clearly separates it from the generic sibling calculate_stencil_aperture_ratios.

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 establishes a clear situational context: apply it when a solid thermal-slug opening risks voiding, die floating, or perimeter bridging. It never names an exclusion or points to a sibling (e.g., generic aperture-ratio or paste-volume tools) for non-thermal apertures, so a small amount of routing 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 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.