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

The description is highly transparent about system behavior: it validates the proposal using a 'fresh reload and a kicad-cli outline check,' confirms the source board remains untouched, and specifies the token is 'single use.'

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?

Despite its length, the description is extremely efficient, providing critical workflow and technical constraints without any extraneous filler, delivering high information density.

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 is maximally complete for a complex, multi-step CAD process. It covers the input, the process (revision creation/validation), and the necessary next step (returning the new `pcb_path` to 'continue from that path').

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?

Since schema description coverage is 0%, the description must provide all semantic value. It successfully explains the `revision_token` is single-use and clarifies that the input `pcb_path` is the 'source_pcb' while the output is the new revision path.

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 explicitly states its purpose is to 'Apply a propose_board_outline proposal' and details that it 'writes a NEW board revision with the outline and mounting holes,' making it uniquely identifiable within the CAD workflow.

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 a step-by-step 'Order for a project' (e.g., 'import_from_schematic -> board_outline -> board_rules'), which defines the exact sequence and context in which this tool must be used relative to its 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?

Beyond destructiveHint=true and idempotentHint=false, it discloses that a NEW revision is written beside the source, the source remains untouched, returned paths are output_pcb/pcb_path while the input is source_pcb, revision_token is single use, and the grading field is not a verdict. It also explains stale gates and baseline invalidation, which are critical behavioral traits.

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

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

The description is front-loaded with the core action, and every sentence carries operational value for this complex workflow. The single dense paragraph and long inline sequence list make it harder to scan than a structured list, so it falls short of 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 destructive, multi-step workflow tool with no schema descriptions and no output schema, it supplies the needed context: sequencing, return paths, token lifetime, baseline invalidation, and which sibling certifies results. Minor omissions like exact grading values are not essential to invoke the 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 description coverage is 0%, so the description must carry parameter meaning. It explains that revision_token is single use, defines parity values and parity_reason handoff, and clarifies that pcb_path is the source board while output_pcb/pcb_path is the new revision; however, it does not fully define pcb_path format or exactly when parity_reason is required.

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: 'Apply a propose_board_rules proposal,' then specifies that it writes a new project revision, pins the rule baseline, and grades it. This clearly distinguishes confirm_board_rules from propose_board_rules and verify_board by naming the confirm action and its resulting workflow.

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 states the prerequisite proposal, gives an explicit project sequence ('Order for a project: ...'), notes the revision_token is single use, and tells the agent to re-run verify_board on output_pcb after rule changes. It also says both gates are stale until verify_board runs and that only verify_board certifies, routing the agent to the correct alternative.

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

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

Adds substantial behavior beyond annotations: source board untouched, revision_token single use, unhandled copper text invalidates a clean baseline, input_floor carries grading_status and certified: false (not a verdict), and pcb_path/source_pcb/output_pcb relationships are explained.

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

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

Front-loads the core action and keeps every sentence informative, but the dense parentheticals and multi-clause sentences make it heavier to parse than necessary for a tool definition.

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

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

With no output schema, the description carries the return-shape burden and does so: output_pcb, baseline, unhandled, input_floor with grading_status/certified, pcb_path, and source_pcb are all covered, along with the workflow position.

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

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

Schema coverage is 0%, so the description must compensate. It explains parity values and parity_reason, and the single-use nature of revision_token, though pcb_path's role is only implied through the source_pcb distinction rather than stated outright.

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: applies a proposal from propose_input_preparation, writes a NEW prepared board revision, re-pins the rule baseline, and reports input_floor. This clearly distinguishes it from its proposal sibling and from pin_rule_baseline.

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 explicit ordering constraints: runs once per board, BEFORE the pin_rule_baseline used for routing, never inside an attempt, and tells the agent to use the returned output_pcb and baseline thereafter. It also names verify_board as the only source of a verdict.

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?

Goes well past the annotations: it discloses the scratch-copy semantics (source untouched), the single-use token, the cost profile (~12 gate runs, capped at 40, minutes not seconds), and precisely what `poured` does and does not prove (no pad proven isolated, but connectivity may still be `unproven`). It also warns that both gates are stale until verify_board runs — behavior an agent could not infer from destructiveHint alone.

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

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

Front-loads the action and scratch-copy semantics, then layers preconditions separately from the meaning of `poured`. Dense but almost every clause is load-bearing; it runs slightly long, though the detail is justified for a destructive, minutes-long operation.

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 explaining pcb_path vs source_pcb and the pads connectivity field, plus the stale-gate caveat — all things an agent needs to act on the result. The one real hole is the unexplained `parity`/`parity_reason` parameters, which the description never addresses.

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

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

Schema description coverage is 0%, so the description must carry all parameter meaning. It explains baseline (dict from pin_rule_baseline, required), revision_token (single use), and pcb_path (the board passed in), but `parity` (enum required/not_applicable) and `parity_reason` are never mentioned, leaving two of five parameters undefined anywhere.

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

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

States a concrete verb chain (run router on a scratch copy, grade candidate, conditionally write a NEW revision) and the resource (board revision with the poured zone). It also explicitly bounds the scope against siblings by noting the source is untouched and that only verify_board certifies a board, so an agent can distinguish it from propose_pour_step and verify_board.

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 explicit preconditions (baseline from pin_rule_baseline is required, propose_input_preparation must have run, copper-layer text is refused) and when-not conditions (empty baseline refused, single-use token, over the run cap a pad is never accepted unproven). It also names the alternative that actually certifies a board: verify_board.

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 flag destructiveHint=true and idempotentHint=false, and the description adds substantial context beyond them: the source board is untouched, a new revision is written beside it, an unresolved footprint aborts the entire confirm with nothing written, revision_token is single use, and gate results are stale until verify_board runs.

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

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

Front-loaded with the action and consequence of failure, and nearly every clause carries information. There is mild redundancy in restating 'writes a NEW board revision beside the source (the source is untouched)' after the opening 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?

Covers failure atomicity, token lifetime, output naming (output_pcb / pcb_path vs source_pcb), pipeline ordering, and verification routing, which is what an agent needs for a destructive, non-idempotent tool with 0% schema coverage and no output schema. Only prerequisite auth/permission behavior and where the new revision file lands are unstated.

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

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

Schema description coverage is 0%, so the description must carry parameter meaning; it does explain revision_token as single-use and clarifies pcb_path semantics ('the board you passed in is source_pcb', output returned as output_pcb). What it omits is any format/token-sourcing guidance for obtaining the revision_token.

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 precise verb and resource ('Apply a propose_schematic_import proposal: writes a NEW board revision with the schematic's footprints and every pad net') and clearly positions itself against the sibling propose_schematic_import. An agent can distinguish propose vs. confirm 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?

Gives the prerequisite (must follow propose_schematic_import), the explicit pipeline order for a project (import_from_schematic -> board_outline -> board_rules -> input_preparation -> silkscreen_minimums -> pin_rule_baseline -> pour step -> routing), and routes certification elsewhere ('only verify_board certifies').

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?

Beyond the annotations (destructive=true, idempotent=false), it discloses that the source board is untouched, that a NEW revision is written beside it, that revision_token is single-use, and that both gates remain stale until verify_board runs. That is exactly the extra context annotations cannot convey.

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

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

Front-loads the action and effect, then the ordering and return-path guidance. Dense but nearly every clause carries operational information; the parenthetical about output_pcb/pcb_path/source_pcb is a bit crammed but justified.

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

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

No output schema exists, yet the description names the returned fields and tells the agent to continue from the returned path. Combined with the single-use token warning and the verify_board caveat, an agent has everything needed 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 coverage is 0%, so the description must carry the load; it does explain revision_token is single-use and clarifies pcb_path is the source board (returned separately as source_pcb). It does not state where the token comes from or its format, leaving a small gap.

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 ('Apply ... proposal'), the exact resource it consumes (propose_silkscreen_minimums) and the effect (writes a NEW board revision with raised text verified by reload). An agent can distinguish it from the sibling propose_silkscreen_minimums immediately.

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 explicit pipeline placement ('silkscreen_minimums -> pin_rule_baseline -> pour step -> routing') and names verify_board as the only certifier, which routes the agent correctly. It stops short of stating when NOT to call it (e.g. missing/expired token handling), so it is clear context without 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?

No annotations are provided, so the description carries the burden; "List" establishes a read-only, non-mutating operation and the description discloses that both availability and current load state are returned. It does not mention ordering, filtering, or any cost/pagination traits, but for a zero-argument read-only listing the surface is small.

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 resource and returned information front-loaded; every clause 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?

With no parameters and a declared output schema, the description need not explain return values. It supplies the one thing an agent needs to know — what categories exist and that load status accompanies them.

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 no parameter behavior left to compensate for and the description correctly avoids inventing any input 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 and resource ("List available KiCad tool groups") and adds the useful detail that loaded state is reported per group. It is clearly distinguishable from the load_toolset/unload_toolset siblings, though it never names them 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 only implied: an agent can infer it should list toolsets before choosing load_toolset or unload_toolset, but the description never says when to call it or what to do with the result. No exclusions or explicit alternatives are given.

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

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

Since there are no annotations, the description carries the full burden of context. It provides crucial domain knowledge by illustrating that the 'name' parameter must correspond to a known, conceptual tool group (e.g., 'schematic', 'verification'), which guides the agent's intent rather than just its data typing.

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, well-structured sentence that front-loads the main action and follows immediately with clarifying, high-value examples. It is perfectly sized for the function it performs.

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 configuration tool lacking output schema or behavioral annotations, the description is maximally complete. It successfully tells the agent what the parameter means and gives the necessary examples to ensure correct invocation.

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

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

Although the schema coverage is 100% (only one parameter), the description adds vital semantic value by listing concrete, non-obvious values for the 'name' parameter. These examples act as in-context enumerations for the single string input.

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 explicitly uses the verb 'Load' and clearly identifies the resource being modified: a 'tool group's tools' into the 'session'. Providing concrete examples like 'sourcing' and 'pcb' further distinguishes this setup function from the workflow-focused sibling 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?

While it functions as a setup step, the description does not explicitly state when this is needed relative to the larger workflow (i.e., before processing or after project creation). It is implied that this is an initialization step.

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

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

Annotations already declare readOnlyHint, idempotentHint and non-destructive, so the safety profile is free. The description earns credit for enumerating exactly what is captured and for stating the caller-side storage/pass contract, but says nothing about the returned shape or size beyond that. Useful addition, not rich behavioral context.

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

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

Three short sentences, zero filler: what is captured first, then the read-only contract, then the ordering constraint. Front-loaded and 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, no-output-schema tool the description covers purpose, safety, content, and workflow placement adequately. The only missing piece is what pcb_path expects, a minor gap given there is only one parameter and no enums or nesting.

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

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

Schema coverage is 0% and the sole parameter, pcb_path, is never explained in the description, so that gap is not compensated. The description does clarify the conceptual `baseline` artifact exchanged with verify_board, which is genuinely beyond the schema and keeps this from scoring lower.

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 ('Snapshot') and a precisely enumerated resource (rule severities, netclass limits, .kicad_dru clauses, ignored checks), and anchors it to the consumer tool verify_board. An agent can distinguish this from verify_board itself 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?

Gives a clear timing rule ('Pin before the work, not after it') and explains the downstream usage contract (caller stores the result and passes it as `baseline`). It does not name an explicit alternative or a when-not-to-use case, which keeps it below 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 destructiveHint=true, idempotentHint=true, and openWorldHint=false, so the safety profile is partially carried by structured data. The description adds that files are 'blank,' which is useful, but it fails to connect the destructive hint to the overwrite parameter (i.e., that overwrite=true destroys existing files).

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 action and its outputs with zero filler. Efficient, though extremely terse for a tool with six parameters.

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

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

An output schema covers return values, but with six parameters at 0% schema coverage and a destructive operation, the description does not do enough: it omits the meaning of overwrite, layers, and dimensions, and gives no usage guidance.

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

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

Schema description coverage is 0% and no parameter is explained in the description. The mention of '.kicad_pcb' hints that layers/width_mm/height_mm configure the board, but directory, name, and especially overwrite remain undocumented.

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

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

States a specific verb 'scaffold' plus resource 'new KiCad project' and enumerates the concrete artifacts produced (.kicad_pro, .kicad_sch, .kicad_pcb). Clear enough to distinguish creating a new project from project_open, though it never names that sibling.

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

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

No when-to-use, when-not, or prerequisites are given. It doesn't state the relationship to project_open (open existing vs create new) or when overwrite should be chosen.

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 scope, so the safety profile is fully covered. The description adds only that the call also produces a summary of schematic/PCB contents, which is useful context but not much beyond 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?

One front-loaded sentence with no filler; the verb and resource come first and the summarizing behavior follows. 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?

An output schema exists, so return values need not be explained, and annotations cover the safety profile. What is missing is the meaning/format of the single required path argument and whether the project remains loaded in session state after the call.

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

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

There is one required parameter, 'path', with 0% schema description coverage, so the description carries the full burden of explaining it. It says nothing about whether path is a .kicad_pro file, a project directory, absolute vs relative, or how missing/invalid paths are handled.

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 ('Open an existing KiCad project') plus the additional effect of summarizing schematic/PCB contents. It is clearly distinct from the sibling project_create, 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?

The phrase 'existing KiCad project' implies this is for projects already on disk rather than new ones, which implicitly routes away from project_create. However, no alternative is named and no preconditions (project must exist, must be valid) are 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?

The description adds substantial behavior beyond the annotations: it reports replaced items, footprints outside the outline without moving them, and holes touching existing items; it refuses overlapping keepouts unless allow_overlap is true; and it explains that it writes nothing while returning a revision_token. This is consistent with readOnlyHint=true, idempotentHint=true, and destructiveHint=false.

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 key point, dry run and writes nothing, is front-loaded, and the dense detail is mostly justified by the complex nested parameters and lack of schema descriptions. Some material about confirm behavior and full project ordering is broader than this single tool, but it remains useful context rather than filler.

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

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

For a complex nested-parameter tool with no output schema, the description is complete enough to call it correctly: it defines the dry-run behavior, input shapes, overlap gate, returned revision_token, output_pcb/pcb_path/source_pcb distinction, and the need for verify_board before gates are valid. These details compensate for the absent output schema and sparse input 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?

With 0% schema description coverage, the description carries the burden and explains the important nested fields: outline {x, y, width, height, corner_radius?}, mounting_holes entries, origin enum meanings, and allow_overlap behavior. It leaves output_dir and perhaps pcb_path relatively implicit, so it is strong but not exhaustive.

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: a dry run of replacing the board outline and adding mounting holes, including what would be replaced and what would be refused. It distinguishes itself from the confirm sibling by explicitly saying it writes nothing, returns a revision_token, and that confirmations write a new revision.

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 clearly establishes the dry-run use case, gives a project-order context, and warns that allow_overlap should only be set after a human has read the listed items. It also points agents to verify_board for certification. It does not explicitly name confirm_board_outline as the next step, so the alternative routing is implied rather than stated.

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

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

Annotations already declare readOnly/idempotent/non-destructive, and the description corroborates ("writes nothing and returns a revision_token"), then adds real behavioral context: absent keys fall back to KiCad built-in defaults, loosening and incoherent class values are refused unless the gate flags are set, lengths are mm. The paragraph about confirms writing a new board revision and returning output_pcb describes other tools rather than this one, which adds pipeline context but risks blurring this tool's read-only nature.

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?

Dense but front-loaded: the dry-run behavior and return value come first, then parameter semantics, then gates, then workflow ordering. Parenthetical enumerations replace whole sentences and nothing is repeated.

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, no-output-schema, zero-coverage tool this is a strong description — it explains what is reported (every value that would change, every loosening, every incoherence) and what is returned (revision_token). Remaining gaps are output_dir and the exact shape of the reported change list.

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

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

With 0% schema description coverage the description carries the load and does much of it: units (mm), default-vs-unset semantics for missing keys, the full netclasses entry shape with per-class fields, and the human-approval gating for allow_loosen/allow_incoherent. It leaves pcb_path vs source_pcb, output_dir, and the distinction between via_diameter and min_via_annular_width unaddressed.

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 ("Dry run of setting the board's design rules ... in the project's .kicad_pro") and immediately enumerates the rule families covered. The "dry run" framing cleanly separates it from the sibling confirm_board_rules, so an agent can choose 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?

Gives explicit when-to conditions (preview before confirming, gate flags only after a human reads the listed items, sequencing relative to verify_board and the surrounding pipeline). It never names confirm_board_rules as the follow-up action explicitly, relying on the sibling name and "Dry run" to imply the pairing.

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/idempotent/non-destructive, and the description reinforces this with 'Writes nothing'. It adds real behavioral context annotations cannot: the `unhandled` bucket for inner-layer text and text boxes, the `nothing_to_do` no-token case, and the absence of any verdict. Minor gap: it mentions creating a 'new directory for the prepared project copy' without clarifying whether that directory is created now or only at confirm time, which sits in tension with 'writes nothing'.

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

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

Front-loaded with the core action and the no-write guarantee, then ordering, then edge cases, then the parameter note — a sensible hierarchy with no filler sentences. It is dense and reads as a block, but each clause carries operational 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 tells the agent what comes back (the list of copper text, a revision_token, an `unhandled` section, status nothing_to_do). Combined with the ordering constraints and output_dir rules, nothing needed to invoke it correctly 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 0%, so the description must carry the load. It fully specifies output_dir's default (sibling `<project>_prepared`) and two hard constraints (must not be inside the source project, must not be non-empty) that an agent could not infer from the schema. pcb_path is left to the name alone, which is low-risk but unstated.

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

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

States a specific action (dry-run listing of copper-layer text that would move to silkscreen) and its return (a revision_token), with the 'Dry run' framing immediately distinguishing it from the sibling confirm_input_preparation. An agent knows what this does and what it does not do (change the board) without opening anything else.

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?

Explicit sequencing: 'once per board, BEFORE pin_rule_baseline and before any routing; never inside a routing attempt' tells the agent when to run it and when not to. It also routes verdict-seeking to a named alternative ('only verify_board does'), which the sibling list confirms.

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, but the description adds genuinely new behavior: writes nothing, runs no router, returns a revision_token, skips nets that already have a pour on that layer, and explicitly yields no verdict (only verify_board does). The skip-existing behavior and the 'no verdict' caveat are facts the annotations cannot convey; only the exact return shape of revision_token remains unstated.

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 dry-run contract, then parameters, then sequencing, then the caveat — a sensible order with no filler. It is slightly dense in a single run-on paragraph with the pours example inlined, which costs a bit of scannability 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?

For a three-parameter, sequenced dry-run tool with no output schema, the description covers prerequisites, side effects, the nested parameter format, output directory constraints, and what the tool will not do. The only gap is what the revision_token looks like and what validation failure reports, which the agent cannot infer.

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

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

Schema coverage is 0%, so the description must carry the parameters. It fully specifies the nested 'pours' map with type (net name → copper layer), a one-net-per-layer constraint, and a concrete example, plus output_dir semantics (new directory, default sibling `<project>_poured`, must not be inside the source project). pcb_path is not described, keeping this short of a 5.

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?

Opens with a specific verb+resource ('Dry run of the pour step') and states exactly what happens: validates power planes, returns a revision_token, writes nothing. It also names the sibling that provides the real verdict (verify_board) and implicitly contrasts with confirm_pour_step, so the agent can distinguish it from the rest of the propose/confirm pairs.

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 explicit prerequisite chain (propose/confirm_input_preparation, then pin_rule_baseline, then this step) and a cardinality rule ('once, before routing signals'). It also explains why the ordering exists ('copper-layer text is refused by confirm'), which is exactly the when-to-use context an agent needs.

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 description reinforces and extends the annotations: no writes, a revision_token is returned, unresolved footprints block with status=blocked and no token, and blocking footprints are named. The one weakness is that it mixes in the confirm_* output convention ("returns it as output_pcb (also pcb_path; the board you passed in is source_pcb)") inside this tool's own description, which risks an agent expecting output_pcb from a dry run that writes nothing.

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 dry-run purpose is front-loaded and no sentence is pure filler, but it is delivered as one dense unbroken paragraph that folds in sibling confirm/verify semantics. The revision/output_pcb sentence is about other tools and dilutes an otherwise tight core.

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, and the description does cover the return contract (listed footprints and nets, staging locations, revision_token, blocked status) and the failure mode. Completeness is only dinged by the unexplained columns/spacing/output_dir parameters and the ambiguous statement about output_pcb.

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

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

Schema description coverage is 0%, so the description carries the burden, and it only covers two of six parameters: schematic_path (defaults to the board's own .kicad_sch) and staging_origin ([x, y] page mm, default right of the Edge.Cuts box). The staging-grid parameters columns and spacing, plus output_dir and pcb_path, are never mentioned, leaving genuinely ambiguous knobs undocumented.

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

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

The first sentence names a specific operation in plain terms ("Dry run of importing footprints and nets from the project's schematic into the board") and immediately defines the scope boundary ("writes nothing"). It also implicitly distinguishes itself from the confirm_* siblings by being the non-writing proposal half of the pair.

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?

Explicit ordering is given for the whole workflow ("import_from_schematic -> board_outline -> board_rules -> ..."), and it names the clarifying sibling constraint ("Staged footprints are not placed: placement is a separate step"). It also states that both gates are stale until verify_board runs, which tells the agent when this result is authoritative.

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 description adds substantial behavior beyond the annotations: it writes nothing, returns revision_token none when there is nothing to raise, never moves/hides/re-layers text, and leaves overlap verification to verify_board. It is consistent with readOnlyHint=true, idempotentHint=true, and destructiveHint=false.

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

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

The description is front-loaded with the dry-run purpose and is dense with useful constraints. It is somewhat long and includes workflow/revision details that also pertain to confirm tools, but almost every sentence adds operational value.

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

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

Given the absence of an output schema, the description explains the key return values and statuses: before/after sizes, unhandled items, revision_token, and output_pcb/pcb_path from confirm. It also covers the verification dependency and source-board untouched semantics, making it complete enough for correct invocation.

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

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

Schema description coverage is 0%, so the description must compensate. It documents defaults and meaning for min_height_mm and min_thickness_mm, and contextualizes pcb_path as the source board, but it does not explain the optional output_dir 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?

The description states a specific operation: a dry run that raises silkscreen text below fab minimums on a new revision, lists before/after sizes and unhandled text, and returns a revision_token. It clearly distinguishes this propose/dry-run behavior from the confirm sibling that writes a new board revision.

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 gives explicit project-order guidance and explains that overlaps should be reported by verify_board rather than handled here. It also implies the confirm flow, but it does not explicitly name confirm_silkscreen_minimums as the next alternative.

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

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

No annotations are provided, so the description carries the full behavioral burden. It states the budget benefit but does not disclose whether the named toolset must already be loaded, whether the operation is reversible, whether it affects session state beyond tool schemas, or what errors occur for an unknown name.

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, front-loaded sentence with no filler. The purpose and budget rationale are stated immediately, and every word contributes to the definition.

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

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

For a simple one-parameter tool with no output schema, the description gives the core purpose but omits parameter meaning and behavioral details. It is minimally viable but would benefit from naming the inverse tool and clarifying the required argument.

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 has one required parameter, "name", with 0% description coverage. The description implies the parameter refers to a tool group but does not state the expected name format, whether it must match a loaded toolset, or any examples, leaving the single parameter underspecified.

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 ("Unload") and resource ("a tool group's tools") and adds the outcome of freeing the session's tool-schema budget. It is clearly distinguishable from load_toolset and list_toolsets by the verb, though it does not name those siblings 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 "to free up the session's tool-schema budget" implies the situation in which unloading is appropriate, but there is no explicit when-to-use guidance, no mention of load_toolset as the inverse operation, and no warnings about prerequisites or consequences.

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?

Adds substantial behavior beyond annotations: three refilled kicad-cli runs, union of errors, FAIL precedence over INCOMPLETE, baseline-gated rule weakening, incomplete_reasons, and notes that never change the verdict. This is rich operational context even though annotations already cover read-only and idempotent behavior.

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

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

Front-loads the core purpose in the first sentence, then groups parity, baseline, precedence, and notes into compact paragraphs. The density is appropriate for a high-stakes verification tool, and 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?

Despite having no output schema, the description explains the verdict categories, the complete unconnected and violation lists, and the precedence rules. Together with annotations covering safety, this is complete enough for an agent to invoke and interpret results 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?

With 0% schema description coverage, the description compensates well: it explains parity required/not_applicable, parity_reason with an example, and baseline as the dict from pin_rule_baseline whose absence forces INCOMPLETE. pcb_path is left implicit but is self-evident from the tool purpose.

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: it grades a board with real kicad-cli and returns PASS, FAIL, or INCOMPLETE with complete error lists. The 'acceptance gate' framing and reference to pin_rule_baseline distinguish it from sibling propose/confirm 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?

Explains when the tool is authoritative: only a PASS may be reported as routed or done. It also describes parity modes and that baseline from pin_rule_baseline is required, but it does not explicitly name when-not-to-use conditions or alternatives beyond that dependency.

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