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

With no annotations, the description carries the full burden. It does disclose a key side effect: 'Sets the new project as the active session workspace.' It also specifies the exact file/directory structure. However, it doesn't mention failure conditions (e.g., if parent_dir doesn't exist or project already exists), permissions, or reversibility. For a mutation tool, this is a partial disclosure—better than a bare 'Creates a project' but not exhaustive.

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

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

Two sentences, zero wasted words. The first sentence front-loads the action, target path, and key outputs; the second discloses the side effect. Perfectly concise and well-structured.

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 scaffolding tool with only 2 parameters and no output schema, the description is quite complete. It specifies the exact artifacts created and the session side effect. It doesn't describe return values or error handling, but those are not essential for a creation tool's basic invocation. The description covers everything an agent needs to know to call it correctly and understand the outcome.

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

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

Schema description coverage is 100%, so the schema fully documents both parameters (name, parent_dir). The description references them in the path template but doesn't add new semantic detail beyond what the schema provides (e.g., validation rules for name are in schema). Baseline 3 applies because the schema already 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 states a specific verb ('scaffold') and a specific resource ('a new KiCad project'), and details the exact directory structure and file contents (.kicad_pro, .kicad_sch, libs/, manufacturing/). It clearly distinguishes from siblings like load_project (loading vs creating) and detect_kicad (detection). No ambiguity.

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

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

The context is clear: use this to create a new project. It doesn't explicitly name alternatives or exclusions, but the scope is obvious given the sibling list (all other operations assume an existing project). It could have stated 'use load_project to open existing projects', but the description's focus on scaffolding suffices for a creation tool.

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

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

With no annotations, the description carries the full burden, and it does so well. It discloses detection-only behavior, the failure branch returning an install_hint, platform-specific guidance, and explicitly states it never runs installs itself.

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 with no filler. The core action is front-loaded, return values are stated compactly, and the critical non-installing boundary is called out without extra prose.

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

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

Even without an output schema, the description explains what the tool returns, the failure mode with install_hint, and the platform-specific nature of guidance. This is complete for a zero-parameter detection utility.

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

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

The tool takes zero parameters, so the baseline is 4. There is nothing for the description to add about parameter meaning; the schema already covers everything.

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 ('Detect'), a clear resource ('local KiCad install'), and the key return values (version, path, minimum version check). No sibling tool overlaps with environment detection, so it is easily differentiated.

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

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

The description implies it is a prerequisite/environment check, but it never explicitly says when to run it relative to other tools or names alternatives. Since none of the siblings perform a similar function, the lack of explicit routing is a minor gap.

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

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

No annotations are provided, so the description carries the full burden. It discloses that the tool generates a handoff message (not a file), that it references a .kicad_pcb path, and that it is the recommended terminal step. It could add more about what the message contains or side effects, but the core behavior is transparent.

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

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

The description is two sentences, front-loads the core purpose, and every sentence earns its place. The first sentence states what it does; the second explains why it is the recommended terminal tool. No wasted words.

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

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

For a simple tool with one optional parameter and no output schema, the description is nearly complete. It explains the purpose, the default parameter behavior, and the rationale for being the terminal step. It could mention what the handoff message includes beyond the path and import steps, but that is minor given the tool's simplicity.

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 the single optional parameter. The description adds context by explaining the default behavior ('Defaults to the active project's board file'), which is valuable beyond the schema. With full coverage and one simple param, this is strong.

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 clearly states the tool's purpose: produce the final handoff message with the path to the generated .kicad_pcb and step-by-step import instructions for easyeda.com. It uses a specific verb ('produce') and resource ('handoff message'), and distinguishes itself from siblings by explaining it is the recommended terminal tool.

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 explicitly says this is the recommended terminal tool and explains why: EasyEDA handles final routing and JLCPCB ordering more reliably than a headless auto-router. This gives clear guidance on when to use it versus alternatives, and the context signals show it is the final step in the workflow.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It discloses that it writes files to the libs/ directory, that it downloads from EasyEDA, and that it writes a placeholder if geometry is unavailable, with a warning about the placeholder not matching the real part. It does not mention whether the operation is reversible or any permission requirements, but for a download/install tool, these disclosures are adequate.

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 moderately long but every sentence contributes: it states the purpose, the source of geometry, the fallback behavior, and the importance of warnings. The key information is front-loaded, with the caveat about placeholders placed at the end. It is well-structured and not padded with redundant text.

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

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

Given that there is no output schema, the description explains what the response will contain (warnings) and explicitly warns about placeholder mismatches. It covers the failure mode (EasyEDA unreachable or no geometry) and directs the user to read warnings. It does not describe the exact return format or success indicators, but for a tool of this complexity, it is sufficiently complete.

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

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

The input schema provides 100% description coverage for both parameters (lcsc and libs_dir), including examples and defaults. The description adds marginal value by reinforcing that lcsc is a C-number and that libs_dir overrides the default directory, but this is already in the schema. The description does not compensate for any missing schema details, so a baseline of 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 states a specific verb (Download) and resource (symbol + footprint + 3D model for a single LCSC C-number) and explicitly mentions the install location (active project's libs/). It also distinguishes itself from siblings by focusing on a single part and sourcing from EasyEDA, making it clear what this tool does versus search or BOM resolution 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 clearly implies when to use it: when you need to fetch a specific part's library by LCSC number. It also provides guidance on reading warnings when a placeholder is written, which is important for downstream actions. It does not explicitly state when not to use it or list alternative tools, but the context is sufficient for an agent to select it appropriately.

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?

Since no annotations are provided, the description carries the full burden of behavioral disclosure. It transparently states that the tool hard-prefers basic-tier parts, attaches a cost-impact warning for extended parts, and tallies the JLCPCB assembly setup fee. This goes beyond a simple description and informs the agent of potential side effects and cost implications. However, it does not explicitly state whether the operation is read-only or has other side effects, though the resolution focus suggests a non-mutating operation.

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

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

The description is concise, two sentences long, with no filler. It front-loads the core purpose, then efficiently covers input options and the behavioral nuance of basic-tier preference and cost warnings. Every sentence contributes meaning, and the structure is clear and 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?

The description adequately covers the tool's complexity: it handles both direct C-numbers and queries, applies a package filter, prefers basic-tier parts, and manages cost warnings and setup fees. It does not explicitly describe the return format (e.g., the structure of resolved rows), but the purpose 'resolve to concrete LCSC parts' implies the output is a list of resolved parts. Given the lack of an output schema, a more explicit return structure would improve completeness, but the description is still fairly complete for an agent to understand the tool's function and behavior.

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

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

The schema description coverage is 100%, so each parameter (rows, qty, lcsc, query, package) is already documented. The description adds context by clarifying that each row may specify an LCSC C-number or a free-text query with an optional package, and notes that qty is passed through and not used for matching. This provides a high-level framing but does not add substantial new details beyond the schema. The baseline of 3 is appropriate given the complete schema 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?

The description clearly states the tool's function: resolving a list of BOM rows to concrete LCSC parts. It specifies the input options (direct C-number or free-text query with package) and the key behavior of preferring basic-tier parts. This distinguishes it from siblings like lcsc_search (which likely searches for individual parts) and session_confirm_bom (which likely confirms a BOM). The verb 'resolve' and resource 'BOM rows' are specific and actionable.

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

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

The description provides clear context on when to use the tool (to resolve BOM rows) and explains the resolution logic, but it does not explicitly contrast with alternatives like lcsc_search or state when not to use it. There is no mention of exclusions or conditional routing to other tools. The intended usage is implied but not directly contrasted.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It discloses the default tier filtering (basic-only), the option to include extended parts, and the sort order (basic-first then descending stock). This is meaningful behavioral context beyond the schema. It doesn't mention rate limits, pagination, or error behavior, but for a search tool the disclosed behaviors are the most relevant ones. A 4 is appropriate; a 5 would require more depth like result count limits or failure modes.

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

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

Three sentences with zero waste. The first sentence states the core function, the second explains the default tier behavior and how to override it, and the third describes the sort order. Every sentence earns its place, and the most important information is front-loaded.

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 search tool with 5 parameters, 100% schema coverage, and no output schema, the description is complete enough. It explains the default behavior and sort order, which are the non-obvious aspects. The absence of an output schema means the description doesn't need to explain return values, but it could have mentioned what fields are returned per result. However, the schema covers all inputs, and the description covers the key behavioral nuances, so a 4 is justified.

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 5 parameters. The description adds value by explaining the default tier behavior and sort order, which relates to basic_only and the overall result set, but it doesn't add per-parameter semantics beyond the schema. The baseline of 3 is correct when the schema does the heavy lifting, and the description's tier/sort context is a small bonus that doesn't push it to 4.

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 clearly states the tool's function: searching the LCSC/JLCPCB catalog with a free-text query. It specifies the resource (LCSC/JLCPCB catalog), the action (search), and the input type (free-text query). It also distinguishes itself from siblings like lcsc_resolve_bom by focusing on catalog search rather than BOM resolution.

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

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

The description provides clear context on when to use this tool: when searching for parts by free-text query. It explains the default behavior (basic-tier only) and how to change it (basic_only=false). It doesn't explicitly name alternatives or exclusions, but the sibling list shows lcsc_resolve_bom as a related but distinct tool, and the description's focus on catalog search implies the use case. The lack of explicit 'use this instead of X' guidance prevents 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?

With no annotations, the description carries the full burden and does well: it discloses validation of the manifest, subdirectory assurance, setting the active session workspace, and returning a manifest. Minor ambiguity remains around whether missing directories are created or merely checked.

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 with no filler: purpose comes first, followed by behavioral details and return value. Every sentence earns its place.

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

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

For a single-parameter, low-complexity tool, the description covers input acceptance, validation behavior, workspace effects, and the return value without needing an output schema. It could add error-handling details, 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 the schema already fully documents project_path including the .kicad_pro file OR directory alternative. The tool description merely paraphrases the schema, adding no new parameter-level meaning.

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: 'Load an existing KiCad project' via a .kicad_pro file or directory. This clearly distinguishes it from siblings like create_project and detect_kicad.

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 'existing KiCad project' conveys when this tool applies rather than creating a new project. It does not explicitly name alternatives or exclusions, but the usage context is clear enough for an agent to select it over create_project.

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

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

No annotations are provided, so the description carries the full behavioral disclosure burden. It fully describes the operations: running all manufacturing exports, renaming gerbers to Protel extensions and drill to .XLN, zipping everything, and the output path. It also discloses the external dependency on kicad-cli and the prerequisite state of the project, which is important behavioral context for an agent deciding to invoke it.

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, information-rich sentences with no filler. The first sentence front-loads the exact actions and output format, and the second adds the critical prerequisite and workflow position. Every clause contributes useful information.

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

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

Despite having no output schema, the description is complete for a terminal packaging tool: it specifies the input, all transformation steps, the output location and naming pattern, and the required project state. An agent has enough context to know when to call it and what it will produce.

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 input schema already documents both optional parameters with defaults. The description reinforces the 'active project' default but adds no meaning beyond what the schema provides, matching the baseline of 3.

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

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

The description states a specific verb and resource: 'Run all kicad-cli manufacturing exports on the active project's .kicad_pcb' and lists exactly what is produced (gerbers, drill, position, BOM, renamed and zipped). It also distinguishes itself from siblings by calling itself 'the terminal tool in the workflow', so an agent can clearly tell it apart from earlier steps like pcb_generate or easyeda_handoff.

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

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

It provides an explicit precondition ('Requires that placement and routing are already done in KiCad') and positions the tool as 'the terminal tool in the workflow'. It does not name specific sibling alternatives or state when-not-to-use it, but the workflow positioning and prerequisite give an agent clear guidance on when it is appropriate.

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

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

With no annotations provided, the description carries the full burden and delivers: it discloses rate limiting ('~12s between unique fetches') and indefinite SQLite caching after first fetch — the two operational traits most likely to surprise an agent. It does not cover failure modes (invalid C-number, network errors), but for a read-only fetch tool the disclosed traits are the important ones. No contradiction exists since annotations are absent.

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

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

Three sentences with zero filler. The core verb+resource is front-loaded, the standalone-use context comes second, and the operational constraints (rate limit, caching) close it out. Every sentence earns its place and nothing needs to be cut.

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 tool with no output schema and no annotations, the description covers purpose, usage timing, and both behavioral constraints (rate limit and caching). Since no output schema exists, the description arguably should hint at the return shape, and 'pin-name → pad-number map' effectively does. Minor omissions like error behavior on invalid C-numbers are the only 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%, so both parameters (lcsc, force_refresh) are already well documented in the schema, setting a baseline of 3. The description adds modest value by explaining that caching is indefinite, which gives semantic weight to force_refresh's 'bypass cache' purpose. This is a small increment but not a substantial one — the schema already says enough for correct invocation.

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

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

The first sentence names a specific verb, resource, and scope: 'Fetch the pin-name → pad-number map for an LCSC C-number from EasyEDA's component endpoint.' This is immediately distinguishable from siblings like fetch_part_library (full library) and lcsc_search (part lookup). The second sentence further clarifies its niche relative to pcb_generate (pinout inspection before nets spec construction), leaving no ambiguity about what this tool does.

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 clear context for standalone use: 'so Claude can inspect a part's pinout before constructing a nets spec.' This explains the appropriate moment to invoke the tool. It does not, however, explicitly name sibling alternatives or state when NOT to use it as opposed to lcsc_search or fetch_part_library; the differentiation is implied rather than spelled out.

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

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

With no annotations provided, the description carries the full burden and handles it well. It discloses network fetching from EasyEDA, 12-second rate-limit pauses, SQLite caching, auto-placement behavior, wire generation, board outline drawing, and output as a file. It does not mention overwrite behavior or failure modes, but the main side effects are transparent.

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?

Six information-dense sentences with the core purpose front-loaded and supporting details about latency, caching, placement, and requirements following. Every sentence earns its place, though a few details are partially redundant with the input schema descriptions.

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 tool with 5 parameters, a nested spec, and no output schema, the description is quite complete: it explains the output, external dependencies, performance characteristics, and system prerequisites. It defers the full spec schema to plugin docs and does not specify whether an existing output file is overwritten, but an agent has enough context to call this tool correctly.

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

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

Schema coverage is 100%, so the baseline is 3, but the description adds real semantic value beyond the schema. It explains that components need an LCSC C-number, that nets can reference pin names rather than pin numbers, and that pin maps are cached and can be bypassed. This meaningfully enriches the spec parameter and the fetch-related flags.

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 action ('Generate a fully-wired .kicad_pcb') from a declarative spec and names the mechanism (pcbnew API). It clearly names the output artifact and distinguishes itself from schematic-oriented siblings by describing PCB-specific behaviors such as auto-placement, pad-to-pad wiring, and board outline drawing.

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

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

The description provides clear context: use this when you have a declarative spec with LCSC C-numbers and need a ready-to-route PCB file. It also states the hard prerequisite of KiCad 8+ being installed. It does not explicitly name alternatives or say 'use sch_generate for schematics instead,' 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?

With no annotations provided, the description carries the full burden of behavioral disclosure. It adds useful context by stating the generated schematic passes basic ERC and is ready for human review and PCB layout, but it does not disclose side effects such as overwriting an existing .kicad_sch or what the tool returns after generation.

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 compact sentences with the core action front-loaded. Every clause contributes: file type, input format, component identifiers, net representation, ERC quality, and intended downstream use.

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

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

The description covers purpose and input quality well, but since there is no output schema and no annotations, the agent is left without information about return values and overwrite behavior. It is adequate for a simple generation tool but has clear gaps around invocation side effects.

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

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

Schema description coverage is 100%, so the baseline is 3. The description adds value by explaining what the netlist_spec must contain—components with LCSC C-numbers and footprints, and named nets connecting pins—whereas the schema only says 'Components + nets. See plugin docs for the schema.'

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

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

States a specific verb and resource: generate a .kicad_sch from a declarative netlist spec. It also specifies the input content (components with LCSC C-numbers and footprints, named nets), which distinguishes it from downstream siblings like pcb_generate and sch_run_erc.

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 this tool is used when a netlist spec exists and the goal is a KiCad schematic for review and PCB layout. However, it never explicitly says when to prefer sch_generate over alternatives like pcb_generate or sch_run_erc, nor does it state any exclusions or prerequisites.

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

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

No annotations are provided, so the description must carry the behavioral transparency burden. It discloses return values (error/warning counts and a report path) and the meaning of errors > 0, but does not mention side effects such as whether a report file is written to disk, any prerequisites like an opened project, or failure modes.

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

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

The description is two focused sentences with no filler. It front-loads the primary action and then supplies high-value information about outputs and interpretation.

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

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

For a simple tool with one optional parameter and no output schema, the description adequately covers purpose, return values, and how to interpret errors. It could be more complete by noting prerequisites or side effects, but the essential information for invoking and understanding the result is present.

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

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

The single parameter sch_path is fully described in the schema, including its optionality and default behavior. The description adds no additional parameter guidance beyond what the schema already provides, so the baseline score of 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 uses a specific verb and resource: "Run KiCad's Electrical Rules Check (ERC) on a schematic via kicad-cli." It clearly states what the tool does and distinguishes it from siblings like sch_generate and pcb_generate by naming a specific check phase and reporting behavior.

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 is useful (before layout, when structural problems need fixing) but does not explicitly state when to use this tool versus alternatives or when not to use it. There is clear context but no exclusions or alternative routing.

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

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

No annotations are provided, so the description carries the full burden. It discloses that this is a state-changing action ('Record') that persists approval durably, and it explicitly describes the behavioral difference from session_resume. It even explains the risk of skipping it (money spent on a board). This is transparent about the tool's effect and importance.

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 paragraph that front-loads the core purpose, then explains the workflow context and the stakes. Every sentence earns its place: the timing, the alternative tool, and the consequence of omission. No fluff, no 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 simple tool with two optional parameters and no output schema, the description is complete. It tells the agent when to call it, why it matters, and what happens if it is skipped. The agent has everything needed to decide correctly without requiring additional lookups.

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 both parameters (notes and project_path) are already documented in the input schema. The description itself does not add new parameter semantics; it only indirectly references the notes via 'carried into the resume summary', but that detail is already in the schema. Per the rubric, with full coverage the baseline is 3, and the description adds no extra meaning beyond the schema.

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

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

The description opens with a precise verb and resource: 'Record that the user has reviewed and approved the BOM.' It then anchors the action in the workflow ('immediately after they confirm at the BOM checkpoint, before pcb_generate') and distinguishes it from the sibling session_resume by explaining the consequence of skipping it. An agent can tell exactly what this tool does and when it 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 gives explicit timing ('immediately after they confirm at the BOM checkpoint, before pcb_generate') and the negative consequence of not calling it (session_resume will ask the user to approve again). It effectively states when to use it and what happens otherwise, leaving no ambiguity about its role in the workflow.

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

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

No annotations are provided, so the description must carry behavioral transparency. It describes the inspection and return values, implying read-only behavior, but doesn't explicitly state that it modifies nothing or what happens if the session file is missing. It does mention 'existing project' as a precondition, but more could be disclosed.

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

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

Two sentences with no waste. The core functionality is front-loaded, and the usage guidance is concise. Every sentence earns its place.

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

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

The tool is simple with one optional parameter and no output schema. The description covers what it does, what it returns, and when to use it. It lacks explicit error handling or edge-case behavior (e.g., missing session file), but for this complexity, it's reasonably complete.

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

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

The schema covers the single parameter with 100% coverage, describing project_path and its default behavior. The description adds no additional parameter semantics beyond that, so it meets the baseline for high schema 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?

The description clearly states the verb 'Inspect' and the resource '.kicad_jlcpcb_session.json', and specifies what is returned (current stage, checkpoints, recommended next step). It differentiates from siblings by mentioning its use for offering a resume-or-restart choice, making its purpose distinct.

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 explicit context: 'Use at the start of /pcb-new or /pcb-from-bom on an existing project.' This tells the agent when to call it. It doesn't explicitly name alternatives or exclusions, but the context implies it's for resuming existing workflows, which is clear enough.

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