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

Annotations already declare readOnlyHint=true, idempotentHint=true and destructiveHint=false, so safety is covered. The description adds genuinely new behavioral context beyond the annotations: that results are organized by execution channel and that it reports negative knowledge (what KiCad 10 makes impossible). The only gap is that it doesn't explain the filter/status semantics of the returned rows.

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

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

Two tight sentences that front-load the tool's scope and end with the operative instruction. Every clause earns its place; nothing is redundant.

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

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

An output schema exists, so return-value documentation is not required, and the description covers purpose, channel breakdown, and preconditions. It is nearly complete for such a simple, zero-required-parameter read tool; only the meaning of the status categories is left implicit.

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

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

Schema description coverage is 100%, so both parameters (a substring query and a status enum) are fully documented in the schema itself, establishing the baseline of 3. The description adds no syntax, matching behavior, or format detail for query or status beyond what the schema already provides.

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

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

States a clear intent: enumerate what the server can do, through which channel (cli, ipc, file), and what KiCad 10 makes impossible. This is a specific meta-resource that is easy to distinguish from all domain siblings (pcb_summary, run_erc, lib_search, etc.). It stops just short of a 5 because it never frames itself as a capability-discovery/status tool versus any conceptually adjacent 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?

"Consult it before promising the user something" gives an explicit trigger condition, which is unusual and useful guidance. It does not name an alternative or state when *not* to call it, 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 readOnly/idempotent/non-destructive already in annotations, the description adds real behavioral context: the sheet is written once from the datasheet and verified against rendered pages (data provenance), and it discloses the no-sheet fallback path via a subagent. No pagination or size limits are mentioned, so not a 5.

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

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

Three sentences, but the first is a dense run-on packing the row-by-row/page-number provenance into a long clause. The routing benefit ('cheapest answer') is buried in the middle rather than front-loaded, costing scannability.

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

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

An output schema exists, so return values need not be explained, and annotations carry the safety profile. The description still covers what the sheet contains, its trustworthiness, and the no-sheet fallback, leaving little an agent must infer to call it correctly.

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

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

Schema description coverage is 100%, so the schema already documents 'part', 'find' and 'section' (including the regex example and the heading list). The description only indirectly echoes sections ('pins, limits, the values...'), adding no syntax or format detail beyond the schema. Baseline 3.

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

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

Names a specific resource (a part's fact sheet) and enumerates its contents: pins, limits, values, recommended circuit, package. It also differentiates from siblings by naming doc_sections, doc_text and doc_page in the no-sheet fallback. It lacks a clean action verb (it reads as a noun phrase rather than 'returns the fact sheet'), which keeps it just shy of a 5.

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

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

'The cheapest answer to a datasheet question' gives clear selection guidance for choosing this over the raw doc_* tools, and the fallback sentence explains what happens when no sheet exists. It stops short of an explicit when-not (e.g., when to prefer doc_text or doc_page directly for non-fact-sheet questions).

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

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

The annotations declare openWorldHint=false, yet the entire description is about interacting with an open world of external websites (manufacturer sites, distributor mirrors, scripted download portals, login walls, bot checks). That is a direct contradiction of the annotation, so per the rubric this scores 1 even though the description otherwise discloses rich fallback/error behavior.

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

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

Five tight sentences that front-load the core action before describing the fetch/browser/fallback ladder. Each sentence carries load-bearing information about mechanics or failure handling, with only minor redundancy around the browser-vs-plain-fetch decision.

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

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

An output schema exists, so return values need no explanation. For a network tool with 8 parameters, 1 required, and complex browser-fallback behavior, the description covers the operational flow, failure routing to doc_import, and where to source URLs adequately.

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 75%, so the schema already documents url, tags, title, subdir, browser and filename, and this is the baseline case. The description adds library-location context but leaves expect and notes unexplained and does not reconcile its stated default ('research/references') with the schema's subdir default ('datasheets').

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 ('Download a technical document into the project's documentation library') and clarifies scope (research/references by default, indexed with URL, date, size, hash). It clearly distinguishes itself from the sibling doc_import, which is named as the redirect target when fetching fails.

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-use guidance for each mode: plain fetch first, headless Chromium when the site serves a scripted portal or refuses the client, and doc_import when login walls/bot checks defeat both. It also says where to find URLs ('web search first; manufacturer sites and distributor mirrors usually both work').

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=false, idempotentHint=true and destructiveHint=false, so the mutation/idempotency profile is covered. The description adds only that the document is indexed; it says nothing about where it lands (the subdir default) or what side effects indexing triggers, so it adds limited value beyond the structured fields.

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

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

A single front-loaded sentence stating the action and its result, with zero redundant or filler content.

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

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

An output schema exists, so return values need no explanation, and annotations carry the safety profile. However, for a 7-parameter import tool with only 43% schema coverage, the description leaves too many behavioral and parameter details unstated to be fully complete.

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

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

Schema description coverage is only 43%, and the description mentions no parameters at all. Key fields such as tags, notes, title, and subdir (default 'datasheets') are undocumented in both places, so the description fails to compensate for the coverage gap it inherited.

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

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

States a specific verb+resource (import a document into the documentation library) and adds the outcome that it is indexed. This distinguishes it from read-oriented siblings like doc_list/doc_text/doc_fetch, but it does not explicitly name which sibling it is not.

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 'already on disk' implies the condition for use (a locally stored file, e.g. one saved from a browser), but there is no explicit when-to-use guidance or pointer to alternatives such as doc_fetch. Usage is only implied.

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

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

Annotations already declare readOnlyHint, idempotentHint, and destructiveHint=false, so the safety profile is covered. The description adds one behavioral detail — that text hits include page numbers — which helps the agent chain calls. It says nothing about result volume, pagination, or truncation behavior for a limit-capped list.

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

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

Two tight sentences with no filler, and the follow-up-call hint is front-loaded alongside the purpose. 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 no explanation, and annotations fully cover the safety profile. The description supplies the chaining hint that ties it to doc_text/doc_page. Remaining gaps (limit semantics, when to prefer sibling doc tools) are minor.

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

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

Schema coverage is 50%: the query parameter is richly documented in the schema, but limit is not. The description adds no parameter-level guidance (e.g., search scope, how query matches) beyond what the schema already states, so the baseline of 3 applies.

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

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

States a concrete verb pair and resource: 'List or search the documentation library.' An agent can tell this is the entry-point query tool. It does not explicitly contrast itself with doc_fetch or doc_sections, so it falls short of full sibling differentiation.

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 implies the intended workflow by noting that text hits carry page numbers so a following doc_text or doc_page call can proceed directly — useful routing context. However, it never states when to prefer this over doc_fetch, doc_sections, or doc_facts, so usage is only implied.

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 idempotentHint=true, destructiveHint=false and openWorldHint=false, so safety is covered. The description usefully adds that the return value is image data rather than text, but says nothing about output limits, page-range constraints, or why readOnlyHint is false for a render operation. Adequate but not rich.

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

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

A single sentence, front-loaded with the action and its result, then the use cases. No filler, no restatement of the tool name or schema.

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

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

With no output schema, the description must signal the return type, and it does ('return it [an image]'). Combined with the annotation profile and a fairly well-described schema, an agent has enough to call it correctly; only edge details like resolution limits remain 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 coverage is 67%: 'doc' enumerates its accepted forms (id, file name, title, path) and 'scale' documents the 144 dpi reference point. The description adds nothing about 'page' numbering or scale trade-offs, so the schema does the heavy lifting. Baseline 3 is appropriate.

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

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

States a specific verb and resource ('Render one page of a PDF to an image and return it') and immediately carves out its niche by contrasting with the sibling doc_text: for content 'text extraction cannot carry.' An agent can distinguish it from doc_text, doc_fetch and doc_sections without opening any schema.

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

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

Gives clear usage context — pinout drawings, package dimensions, tables, anything text extraction misses — which effectively routes the agent away from doc_text toward this tool. It stops short of an explicit 'use X instead when Y' statement, but the selection condition is unambiguous.

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

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

Annotations already establish readOnly, idempotent, non-destructive, and closed-world behavior, so the description's additional value is modest. It adds the scoping behavior that the output is an index with page references and that it should be called before text/table retrieval. It does not cover pagination or limit behavior, but with annotations present this is a reasonable 4.

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, front-loaded with the return contents, then the workflow and rationale. Every phrase contributes to understanding what to call and when; there is no filler.

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

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

Output schema exists, so return format need not be fully restated, yet the description still tells the agent what the index contains. Annotations cover safety, and the description covers purpose and sequencing, leaving only minor parameter detail to the schema.

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

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

Schema coverage is moderate at 67%, and the description contains no parameter-level guidance for `doc`, `find`, or `limit`. The schema itself documents `doc` and `find` with examples, but `limit` is only constrained by default/max and not described anywhere. The description fails to compensate for the remaining 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?

The description states exactly what the tool returns—an index of bookmarks, contents, headings, and table/figure captions with page numbers—rather than just restating the name. It distinguishes this from sibling tools by positioning it as the first step before doc_text or doc_page. An agent can identify its role without opening the schema.

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

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

It gives an explicit workflow: 'Ask this first,' then use doc_text with the returned pages or doc_page for a specific table. It names the alternatives and explains why this ordering is useful for datasheet lookups. This is clear when-to-use guidance.

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

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

Annotations already declare readOnly/idempotent/non-destructive, so the description adds non-obvious behavior: token cost of a find ('a few hundred tokens'), that scans/drawings return empty, and that find suppresses page text unless pages is given. It stops short of describing truncation behavior for max_chars or the exact response shape.

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

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

Front-loads the core purpose, then elaborates cost, modes, and the empty-page caveat in tightly packed sentences. No sentence is wasted, though the find-cost clause is dense and could be split.

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

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

An output schema exists, so return-shape explanation is unnecessary; the description supplies the mode logic, cost, and failure case needed to call it correctly. Only minor gaps remain around max_chars and behavior when the document is missing or unreadable.

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 75% schema coverage the schema documents doc/find/pages but not max_chars, and the description compensates by explaining the find-vs-pages interaction and defaults ('with find: default none', 'add pages to read a page around a hit'). max_chars remains only vaguely covered by 'capped to keep the answer readable'.

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 ('extract the text of a PDF / read a text document'), names the modes (per page or search), and explicitly routes image/scanned pages to the sibling doc_page. An agent can identify the tool and its boundary with doc_page without opening the schema.

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

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

Gives clear when-to guidance: use find for a cheap lookup, add pages to read around a hit, and use doc_page for pages that are drawings/scanned images. It does not address when to choose this over the other doc_* siblings (doc_facts, doc_sections, doc_fetch), so the alternative coverage is only partial.

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 idempotent=true, destructive=false, openWorld=false, and readOnly=false, so the agent knows this is a safe, repeatable operation. The description usefully adds that the work is done via kicad-cli and that parsed rows come back, but it omits the notable side effect (a CSV is written to disk) and any truncation behavior from max_rows. With annotations covering the safety profile, this is modest added value.

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

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

A single front-loaded sentence with no filler; the action, format, engine, and return shape are all packed in efficiently. Nothing is padded 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?

An output schema exists, so return values need not be described, and the schema covers most parameters. However, for a tool that writes a file and caps output at max_rows (default 500), the description never warns about the on-disk artifact or potential row truncation, leaving meaningful gaps.

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

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

Schema description coverage is 80%, so the schema already documents fields, group_by, output_path, and schematic_path in detail. The description contributes nothing parameter-specific (no hint about max_rows truncation or grouping semantics), so the baseline of 3 applies.

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

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

States a specific verb and resource (export a bill of materials as CSV), names the underlying mechanism (kicad-cli), and notes it returns parsed rows. It does not distinguish itself from the adjacent sibling export_fab, which an agent could plausibly confuse it with.

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

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

There is no when-to-use guidance and no mention of alternatives such as export_fab, render_board, or sch_netlist. The only routing-relevant detail ('any sheet of the project works; the root sheet is used') lives in the schema, not the description.

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

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

Annotations already declare readOnlyHint=false, idempotentHint=true and destructiveHint=false, so the write profile is partly covered. The description adds value beyond that: it explains that it writes to disk and enumerates outputs with sizes and hashes, and flags the staleness trap of unsaved in-editor changes. It stops short of covering concurrency or overwrite behavior for existing output 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?

Two sentences, zero filler, with the core action front-loaded and the caveat placed second. Nothing restates the name or the schema.

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

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

With an output schema present, return values need not be spelled out, and the disk-write plus save-first caveat covers the main operational risk. It is nearly complete for an 8-parameter export tool; a note on where files land or overwrite behavior would close the remaining 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 75% and the schema already documents formats, layer selection, and output directory defaults. The description itself adds no parameter-level meaning (e.g., it never mentions board_path, output_dir, or how layers interact with gerbers), so the baseline 3 applies.

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

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

States a concrete verb and resource ('Produce fabrication files with kicad-cli') plus the observable outcome (listing files with sizes and hashes). It is clear what the tool does, though it never names a sibling like export_bom or render_board, so the boundary against those adjacent export tools is left implicit.

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

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

Provides one important prerequisite ('Reads the board file on disk: save in KiCad first if it has unsaved changes'), which is real usage guidance. However, it gives no when-to-use/when-not-to-use framing or routing toward alternative export tools, so guidance is implied rather than explicit.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true, destructiveHint=false and a closed world, so the safety profile is covered. The description adds useful content scope (it reports placement geometry 'exactly as KiCad will place it', including pad drill and layers), but says nothing about error behavior for a bad lib_id or how project shadowing affects results.

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 tightly packed sentence with the resource front-loaded and no filler. The enumerated field list is dense but each item earns its place by telling the agent what data is available.

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

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

With an output schema present, the description needn't explain return formatting, and the content enumeration plus full schema coverage make the tool callable without ambiguity. Only the routing relative to sibling lookup tools is left unstated.

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

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

Schema description coverage is 100%; both lib_id and project_path are documented in the schema, including the shadowing behavior of project libraries. The description adds no parameter-level detail beyond that, so the baseline 3 applies.

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

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

States a specific resource (one library footprint) and enumerates exactly what is returned: description, tags, mount type, courtyard size, 3D model, and every pad with its geometry, drill and layers. This is far more specific than the sibling names (sym_info, lib_fetch, lib_search) and lets an agent tell what it will get without opening the schema.

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

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

There is no explicit when-to-use statement and no named alternative. The agent is left to infer that this is the footprint-inspection counterpart to sym_info or a deeper alternative to lib_fetch/lib_search, but the description never says so.

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

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

Annotations already cover the safety profile (read-only, idempotent, non-destructive), so the description's real contribution is accuracy disclosure: closed forms are ~10% optimistic for tightly coupled pairs, and the tool reports the fab's own published number when geometry matches a table entry. That is genuine behavioral context beyond the annotations, though it omits any formatting/units caveat for the returned value.

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 tightly written sentences, front-loaded with what it does, followed by the accuracy caveat and design recommendation. No filler, no repetition of schema or annotation content.

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

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

With an output schema present, return values need no explanation, and the read-only annotations cover the safety profile. What remains for the agent to know — method, accuracy limits, which result to trust, and where presets are defined — is all supplied.

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 3 is the baseline; the description exceeds it by scoping the computation to outer-layer geometry and framing "pair" vs. single-ended, which maps meaningfully onto the gap_mm distinction. It adds no syntax details beyond the schema, but the applicability constraint is real added 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?

Specific verb+resource combo ("Estimate the impedance of an outer-layer trace or pair on a stack-up preset") that no sibling covers, and it names the two computation paths (closed-form microstrip formulas vs. the fab's published table entry). An agent can distinguish it from stackup_info, review_board, etc. without opening a schema.

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

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

The description gives decision guidance: use the closed-form result generally, but design to the table entry when the geometry matches. It also references stackup_info for preset definitions. It lacks an explicit "when not to use this" exclusion, but the context is clear enough to invoke correctly.

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

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

Annotations already declare readOnlyHint, idempotentHint, destructiveHint=false and openWorldHint=false, so the safety profile is covered. The description adds useful behavioral context beyond that: it discloses the diagnostic scope and that it returns remedial advice ('what to do about any problem'), which annotations do not 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-loaded with the core purpose, followed by the enumerated checks and a single call-to-action sentence. The first sentence is somewhat list-heavy but every clause adds diagnostic scope; no filler.

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

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

An output schema exists, so return-value detail is not required. The description covers what is inspected and when to invoke, which is sufficient context for a no-param diagnostic tool. It could note that the output is human/agent-readable guidance, but the gap is minor.

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

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

The tool takes zero parameters, so there is nothing to disambiguate; baseline for a no-param tool is 4. Schema coverage is 100% and the empty schema matches the description's implication of a no-argument diagnostic call.

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 (diagnose) and resource (this server and its environment), then enumerates the concrete facets checked: answering process, kicad-cli binary, API reachability, open documents. No sibling tool overlaps with this role, so the purpose is unmistakable.

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 trigger condition: 'Call this first whenever another tool fails unexpectedly.' This is clear, actionable guidance for when to reach for this tool. It stops short of naming when-not to use it as a general health check vs. routine calls, so it falls just short of the 5 bar.

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

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

Annotations already cover safety (readOnlyHint=false, idempotentHint=true, destructiveHint=false), so the bar is lower. The description adds important context beyond annotations: the data comes from EasyEDA user/JLCPCB drafts, is converted by easyeda2kicad, and should be treated as 'drafts, never as verified'. It does not mention auth or rate limits, but for a local file-generation tool this is a strong addition.

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 what the tool produces, then the usage workflow, then the quality caveat. It is somewhat long, especially the first sentence with nested parentheticals, but every sentence contributes useful routing or trust context.

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

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

With an output schema present, the description need not explain return values. It covers the tool's purpose, source of data, workflow placement, and a critical quality warning. It does not restate workspace or registration constraints already covered by the schema, but those are available in structured fields.

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 83%, so the schema already documents most parameters. The description mentions the LCSC code and that files go 'into a library next to the project', but it adds no syntax or behavioral detail for the parts enum, lib_dir, lib_name, overwrite, or project_path beyond what the schema provides. Baseline 3 is appropriate.

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

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

The description states a specific verb and resource: fetching/converting symbol, footprint, and 3D model for one LCSC code. It clearly distinguishes the tool from siblings by naming parts_search for stock lookup and fp_info/doc_page for validation, so an agent can route correctly without opening schemas.

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

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

It gives an explicit workflow: 'A part swap becomes: parts_search for the code and stock, lib_fetch for the files, then fp_info and the datasheet drawing (doc_page) for the pad-for-pad check.' This names the alternatives and the sequence for using this tool, leaving little inference needed.

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

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

Annotations already cover the safety profile (readOnlyHint, idempotentHint, destructiveHint=false), so credit goes for added context: the tool reports index size and age, and the description discloses that the index is self-maintaining elsewhere. It does not discuss cost on large libraries or failure behavior, so it stops short of a 5.

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

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

Two sentences, zero filler: the action comes first, the crucial 'you probably don't need this' caveat second. 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?

For a zero-required-parameter maintenance tool with fully documented params and an output schema covering the reported size/age, the description supplies everything an agent needs to decide whether to call it at all.

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 rebuild and project_path are already fully documented, including the shadowing behavior of project libraries. The description adds no parameter-level meaning beyond what the schema states, so the baseline 3 applies.

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

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

Specific verb pair (build/refresh) on a named resource (library index), plus the side effect of reporting size and age. It explicitly names the sibling lib_search and clarifies the division of labor, so an agent can distinguish the two 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 an explicit when-not to use it ('Normally unnecessary') and names the alternative (lib_search) plus the conditions under which that alternative supersedes it (build on first use, automatic refresh of changed libraries). Nothing is left to inference.

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

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

Annotations already declare readOnly/idempotent/non-destructive/openWorld=false, so the safety profile is covered. The description adds genuinely useful behavior beyond that: a ~30-second one-time index build on first use, incremental refresh of only changed libraries, and result ordering (exact and prefix name matches first).

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

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

Three sentences, front-loaded with scope and scale, then ranking, then the latency caveat. Every sentence carries information an agent needs; no filler.

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

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

An output schema exists, so return values need not be described, and annotations cover the safety profile. The description closes the remaining notable gaps (latency, refresh behavior, relevance ordering), leaving only the kind/limit parameters undocumented.

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 50%: query and project_path are documented, while kind and limit are not explained in the description at all (kind's enum and limit's bounds are only implicitly self-documenting). The description's note that matching spans name/description/keywords and its ranking rule partially duplicate the query schema text rather than compensating for the undocumented parameters.

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

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

States a specific verb+resource ('Search every symbol and footprint library') with concrete scale (22,000 symbols / 15,000 footprints) and the indexed fields (name, description, keywords). Clear on its own, but it never names or distinguishes itself from near-neighbors like parts_search or lib_fetch, so an agent must infer the boundary.

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

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

There is no explicit when-to-use/when-not-to-use guidance and no alternative tool is named. The presence of parts_search and lib_fetch in the sibling list makes this omission costly, since the agent has to guess which search entry point applies.

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

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

Annotations already cover the safety profile (readOnly, idempotent, non-destructive), so the description isn't required to restate that. It adds genuinely new behavioral context: the tool depends on an undocumented endpoint, and a failure indicates the endpoint changed rather than a missing part — a non-obvious trait an agent cannot infer from annotations or schema.

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

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

Two sentences, no filler. The purpose and returned fields come first, with the endpoint-fragility caveat second — well front-loaded and 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?

An output schema exists, so return-shape detail is optional, and the failure-mode disclosure closes the main operational gap. The only shortfall is the absence of selection guidance against sibling search tools, which keeps it just short of complete.

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

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

Schema coverage is 67%: keyword and limit are documented in the schema, while in_stock_only carries only a default with no explanation. The description enumerates return fields rather than adding input-side meaning, so it does not compensate for the undocumented parameter. Baseline 3 is appropriate given partial 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?

States a specific verb ('Search') and a precise resource ('JLCPCB's assembly parts catalogue'), then enumerates what the results contain (LCSC code, MPN, package, stock, basic-part flag, unit price). This clearly separates it from the KiCad-library siblings like lib_search and lib_index, which operate on a different catalogue entirely.

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

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

There is no statement of when to reach for this tool versus the similarly named lib_search, nor any prerequisites (e.g. that keyword must be an MPN or value+package). The only contextual guidance given is a failure-mode note, which is about diagnostics, not tool selection.

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

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

Annotations already declare readOnly, idempotent, non-destructive and closed-world, so the safety profile is covered. The description adds useful context beyond that: it reports units (mm and degrees), KiCad layer names, and item ids, plus a pagination cue. It stops at 3 because it never describes result shape semantics and the output schema already owns return values.

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, no filler, with the core purpose front-loaded ahead of the pagination note. It is tight and appropriately sized for the tool's complexity.

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

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

An output schema exists, so return-value details are not required here, and annotations cover the safety profile. What remains is a passable orientation for a filtered list tool; adding a note about which filters combine or the board_path default would have closed the remaining 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 coverage is 57%, so the description should carry some of the load. It clarifies the 'kind' selector ('one kind') and page mechanics (limit/offset) but says nothing about the net, ref, layer, or board_path filters, leaving half the surface documented only in the schema. Baseline 3 fits.

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 clear verb (List) and resource (items of one kind from the board open in KiCad), adding scope detail (single kind) and output units (mm/degrees). It does not explicitly distinguish itself from nearby siblings such as pcb_net_stats or sch_list_components, so it stops short of a 5.

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

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

The second sentence gives implied guidance for large boards ('page with limit and offset'), which tells the agent when pagination matters. However, there is no explicit when-to-use vs. alternatives routing, no mention of which sibling to prefer for aggregated stats, and no exclusions.

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

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

Annotations already declare the safe read-only/idempotent profile, so the bar is lower; the description adds real value by disclosing special output behaviors (a hint when a net has pads but no tracks, differential-pair candidate detection) and that it operates on the currently open board. It omits the default result cap (200) and any truncation behavior, which an agent should know.

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

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

A single front-loaded sentence with no filler; every listed item corresponds to a returned metric. It is somewhat list-dense, but nothing is wasted.

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

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

With an output schema present, return values need not be re-explained, and annotations cover the safety profile. The definition is nearly complete for a read-only stats query; the main gap is that truncation/default-limit behavior is never surfaced to the caller.

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 67%: the `net` and `board_path` params carry descriptions while `limit` is documented only by its default/min/max constraints. The description mentions no parameters at all, so it adds nothing beyond the schema — baseline 3 is appropriate.

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

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

States a specific resource ('per-net routing statistics from the open board') and enumerates the exact metrics returned: track count/length, widths, layers, vias, pads, pad-without-track hints, and differential-pair mismatch. The 'per-net' framing separates it from board-level siblings like pcb_summary and review_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?

The description never says when to reach for this tool versus alternatives such as pcb_summary, route_check, or impedance_calc, nor any preconditions beyond the implicit 'open board'. Usage must be inferred entirely from the purpose text.

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

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

Annotations already declare the safe read profile (readOnly, idempotent, non-destructive, closed-world), so most of the safety burden is covered. The description adds non-annotation context: it operates on a live editor session, requires the API enabled and the board open, and explains the failure path via kicad_doctor.

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, front-loaded with the action and reported contents, followed by the prerequisite and remediation. No filler or redundancy.

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

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

With an output schema present, return values need no explanation, and the description still covers scope of reporting, environment prerequisites and the fallback path. Nothing needed to call 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?

There is a single optional parameter documented at 100% schema coverage, so the schema already explains board_path and the omit-to-use-open-board behavior. The description adds no additional parameter syntax or constraints, which is the baseline 3 for a fully-covered single param.

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 (Describe) and resource (the board open in KiCad's PCB Editor) and enumerates exactly what is reported: title block, copper layer count, enabled layers, outline size, item counts, stackup and netclass rules. This scope distinguishes it from narrower siblings like pcb_list_items, pcb_net_stats and stackup_info.

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?

Explicitly states the preconditions (KiCad running with the API enabled and the board open) and routes the agent to kicad_doctor when they are not met. It does not contrast against sibling summary tools, but the applied context is clear enough to decide when to call it.

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

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

Annotations already declare readOnly=true, idempotent=true and non-destructive, so the safety profile is covered. The description adds genuinely useful context beyond that: it reports editor lock files, telling the agent whether KiCad currently has the project open – a behavioral fact the 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?

One sentence, front-loaded with the verb and resource, followed by a tight enumeration of outputs. No waste; only the minor cost of a long comma list.

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 re-explained, and annotations carry the safety profile. Combined with the described scope, this is complete enough for an agent to call it correctly, missing only explicit sibling routing.

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 single 'path' parameter already documents that it accepts a project directory or any .kicad_pro/.kicad_sch/.kicad_pcb inside it. The description adds nothing to parameter semantics, so the baseline 3 is appropriate.

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

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

States a specific verb pair ('locate' and 'describe') applied to a concrete resource (a KiCad project) and enumerates exactly what it returns: root schematic, board, sheets, text variables, netclasses, format versions, lock files. This is far more specific than a sibling like review_project, though it never draws the boundary against that sibling explicitly.

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

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

Usage is only implied – an agent can infer this is the entry-point inspection call before other project operations, but there is no explicit when-to-use or when-not-to-use guidance, and no mention of how it differs from the similarly-scoped review_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?

Annotations already declare readOnlyHint=false, idempotentHint=true, destructiveHint=false, and the description adds context that it reads the board file from disk and returns the rendered image. However, it does not clarify that rendering writes a PNG file to disk (the reason readOnlyHint is false) or note the default output location, which the schema covers instead.

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, front-loaded with the core action and output. "Reads the board file on disk" is slightly redundant given the schema's board_path description but still clarifies the input source.

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 adequately conveys the return (the image itself). However, for a 6-parameter tool with only 33% schema coverage, it leaves the rendering options (side, quality, dimensions) unexplained, so it is not fully complete.

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

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

Schema description coverage is only 33% — side, width, height, and quality are undocumented, and the description adds no semantics for any of these. With low coverage the description should compensate for the missing parameter meaning, but it does not.

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 (Render), resource (the board), output format (3D PNG via kicad-cli), and delivery method (returns the image). An agent can distinguish this from sch_render since it operates on the board rather than the schematic.

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?

"so you can look at it" implies a visual-inspection use case, but there is no explicit when-to-use guidance and no sibling named as an alternative (e.g., sch_render for schematics). Usage is only implied.

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

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

Annotations already establish the safety profile (readOnly, idempotent, non-destructive), so the bar is lower. The description still adds real value by disclosing the result vocabulary (PASS/WARN/FAIL/UNVERIFIED) and that each finding carries evidence and a limit source, which goes beyond the annotation set.

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 purpose, then a dense but purposeful enumeration of checks, closing with the output contract. The single long middle clause is heavy but every listed check earns its place; no filler sentences.

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

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

For a multi-check review tool with a full schema and an output schema present, the description covers the check surface and result semantics adequately. It does not explain how failures are grouped or whether it requires a schematic, but the output schema absorbs the return-value burden.

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

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

Schema description coverage is 100%, so the schema already documents board_path, fab enum behavior, and schematic_parity. The description adds no parameter-level syntax or format detail, so the baseline 3 is correct.

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

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

Specific verb+resource ('Review a board') followed by an explicit enumeration of the checks performed (DRC, zone fill, footprint-outline, manufacturability, power-net widths, stitching, decoupling). It reads as a superset of siblings like run_drc, but never names them, so an agent must infer the distinction rather than being told.

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 framing 'the way a fab and a layout reviewer would' implies a comprehensive multi-check review, which contrasts implicitly with the narrower run_drc/route_check siblings. However, there is no explicit when-to-use, no when-not-to-use, and no named alternative, so guidance is only implied.

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, openWorldHint=false and destructiveHint=false, so the safety profile is covered. The description adds useful behavioral context—it is a compound run producing one verdict plus a list of checks that could not run—but does not cover cost, runtime, or failure handling.

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

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

A single sentence, front-loaded with the core action and scope, with zero filler. 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 an output schema present and annotations covering the safety profile, the definition needn't explain return values, and it still conveys the compound nature and the verdict+failed-checks output. Only the absence of any selection guidance keeps it from being fully complete.

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

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

Schema description coverage is 100%, so both parameters (path and the fab enum) are already fully documented in the schema. The description adds nothing beyond that, making the baseline 3 appropriate.

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

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

Specific verb+resource ('full review of a project') with explicit scope: every schematic check plus every board check in one report. This scope contrast lets an agent distinguish it from the individual review_schematic and review_board siblings without opening any schema.

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

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

The compound scope implies 'use this for an all-in-one review rather than the per-layer review tools,' but no sibling is named and there is no explicit when-to-use/when-not guidance. Usage is inferable rather than stated.

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

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

Annotations already declare readOnlyHint, idempotentHint, non-destructive, and non-open-world, so the safety profile is covered. The description adds genuine value beyond that by disclosing the result taxonomy (PASS/WARN/FAIL/INFO/UNVERIFIED) and that each check carries its evidence, which shapes how the agent should interpret the response.

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, front-loaded with the verb and resource, followed by the scope list and result semantics. The check list is dense but every item earns its place; minimal waste.

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 the parameter is fully documented in the schema. The description adequately establishes scope and result interpretation; only the sibling routing (vs run_erc/review_board) 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?

With a single parameter and 100% schema description coverage, the schema already fully documents schematic_path (format, absolute/relative, any-sheet fallback to root). The description adds nothing about the parameter, so baseline 3 applies.

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

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

States a specific verb (review) and resource (schematic), then enumerates the concrete dimensions checked (ERC, footprints, values, annotation, power nets, decoupling, BOM, SPICE). This clearly distinguishes it from review_board and review_project by resource, though it never explicitly names those siblings.

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

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

The enumeration of checks implies a comprehensive review, but there is no explicit when-to-use guidance and no mention of alternatives such as run_erc (ERC only) or sch_netlist. An agent must infer the tool's scope and relationship to siblings entirely from the name and check list.

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

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

Annotations already establish read-only, idempotent, non-destructive, closed-world behavior, so the safety profile is covered. The description adds real behavioral substance on top: the default skew thresholds per interface with their datasheet source (CM5), the 1.6 mm default via length, the pairing-name heuristics, and that unrouted pairs are surfaced rather than skipped.

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

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

Two dense sentences, zero filler, and the core action is front-loaded before the supporting detail. The parenthetical list of interfaces and thresholds is information-dense rather than redundant, so length is justified even if slightly packed.

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 described, and the description covers pairing detection, defaults, and threshold sourcing. What remains unstated is failure behavior (missing board, absent .kicad_pro for net classes) and whether results cover only differential pairs or all nets, but those are minor against the richness already 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?

Schema coverage is 100%, so a baseline of 3 would be defensible. The description goes beyond the schema by stating the default skew limits that skew_limit_mm overrides (0.15 mm Ethernet/MIPI, 0.1 mm PCIe/USB 3.0, 0.15 mm USB 2.0) and their origin, and by tying the via_length_mm default to board thickness, which gives the numbers real 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?

Opens with a specific verb+resource ('Measure every differential pair on a board') and then enumerates exactly what is measured: routed length per half, skew vs. interface limits, coupled share, and layer changes. It also states how pairs are discovered (X_P/X_N, X_DP/X_DN, X+/X-) and that unrouted pairs are reported. It is highly specific, though it never explicitly distinguishes itself from siblings like review_board, pcb_net_stats, or impedance_calc.

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

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

The description implies the usage context (checking differential-pair routing quality on a .kicad_pcb), and the per-interface skew limits hint at the scope (Ethernet, MIPI, PCIe, USB). But it gives no explicit when-to-use or when-not-to-use guidance, and no routing to alternatives such as impedance_calc or review_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 declare readOnly/idempotent/non-destructive, so the safety profile is covered. The description adds real value beyond that by disclosing verdict semantics: what the result counts (clearance violations, unconnected items, schematic parity) and the non-obvious rule that unrouted nets can never be PASS.

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 tight sentences with no filler, front-loaded with the action and resource. The verdict details and the unrouted-nets rule each earn their place.

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

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

An output schema exists, so return format need not be explained, and the description covers the board_path input adequately through the schema. The main residual gap is the undocumented severity enum values, but overall the definition is complete enough to call 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 coverage is 75%, above the midpoint, so the schema does most of the work. The description references schematic parity in the verdict, loosely tying to the schematic_parity flag, but does not explain severity levels ('default','all','error','warning') or the all_track_errors switch. Baseline 3 is appropriate.

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

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

States a specific verb ('Run') and resource ('Design Rules Check on a board') plus the underlying tool (kicad-cli). It further specifies what the check counts, which sharpens the purpose. It does not explicitly differentiate from the closest sibling run_erc, relying on 'board' to imply the distinction.

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

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

Usage is implied (run this to check a board's design rules), and 'Works whether or not KiCad is open' is a useful operational note. However, there is no explicit when/when-not guidance and no mention of alternatives like run_erc or route_check for schematic or routing checks.

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

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

Annotations already cover safety (readOnly, idempotent, non-destructive, closed-world), so the description is not obligated to restate those. It adds real value beyond them: the verdict vocabulary (PASS/WARN/FAIL/UNVERIFIED), the reason UNVERIFIED can occur (no report produced), that findings are keyed by stable ids and item UUIDs, and that execution shells out to kicad-cli independently of a running app.

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

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

A single front-loaded sentence with the verb and scope first, the return contract second, and the environment note last. Dense but every clause carries information; the nested parenthetical slightly hampers scanability.

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 enumerated, yet the description still summarizes the verdict model. Combined with the whole-hierarchy scope and the runtime-dependency note, an agent has what it needs; only error/timeout behavior for the underlying kicad-cli invocation is unaddressed.

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

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

Schema description coverage is 100%, including the severity enum's semantics, so the schema carries the parameter burden and a baseline of 3 applies. The description adds nothing about schematic_path or severity, but nothing is left ambiguous either.

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

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

States a specific verb (Run), a specific check (KiCad's Electrical Rules Check), and an explicit scope (the whole schematic hierarchy) via a named engine (kicad-cli). This cleanly separates it from the PCB-side sibling run_drc without requiring the schema to be opened.

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

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

Usage is implied by the tool's role - run it to validate a schematic's electrical rules - and the note that it "works whether or not KiCad is open" is a mild environmental condition. However, it never states when to prefer this over run_drc, review_schematic, or kicad_doctor, and no prerequisites 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?

Annotations already declare read-only, idempotent, non-destructive, and closed-world behavior, so the safety profile is fully covered. The description adds only what content is returned (pins with numbers/names/types/positions), which is largely redundant with the output schema; it adds little behavioral context beyond annotations.

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

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

A single sentence that front-loads the resource and its returned detail, with the use-case clause last. Every clause contributes; 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?

Given the simple retrieval scope, full schema coverage, rich annotations, and an output schema, the description supplies enough to call the tool correctly. It could mention error behavior for a missing ref, but that is a minor omission for a read-only getter.

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

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

Schema coverage is 100%, with both required parameters (schematic_path, ref) documented in the schema. The description adds no syntax or format details for ref or path, so the schema carries the burden and baseline 3 applies.

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

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

States a specific resource ('one placed symbol') and enumerates the returned pin attributes (number, name, electrical type, sheet position), so an agent knows it retrieves a single symbol's full pin-out. It does not name sibling tools such as sch_list_components or sym_info to differentiate, but the scope is unambiguous.

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

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

Provides a clear use case – 'what you need to wire to it' – which tells the agent to call it when pin-level wiring data for a specific placed symbol is required. It offers no explicit exclusions or named alternatives, so the agent must infer that list-level tools are for enumeration.

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

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

Annotations already establish read-only, idempotent, non-destructive, closed-world behavior. The description adds meaningful operational context by stating it reads from the file and works while KiCad is closed, plus it discloses optional pin-coordinate inclusion. It does not cover pagination/limit behavior, but the annotation bar is already met.

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

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

The description is compact and front-loaded: the core action and scope come first, followed by the returned fields and the important closed-file note. Every sentence earns its place without redundant preamble.

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 rich annotations and an output schema, the description does not need to explain return values or safety. It clearly covers the core listing behavior and one key operational constraint, though it could better address multi-sheet handling or alternative tools.

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 80%, so most parameters are already documented. The description mentions optional pin coordinates, which loosely maps to include_pins, but it does not add meaningful semantics for ref_prefix, include_power, or limit beyond the schema.

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

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

States a specific verb (list) and resource (every placed symbol on one schematic sheet), so an agent can tell this is a schematic-component listing tool. It does not explicitly distinguish itself from close siblings such as sch_get_symbol, so it misses the top band.

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

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

Usage is implied by the description: list components from one schematic sheet, and it notes this works with KiCad closed. However, it gives no explicit when-to-use/when-not guidance or alternative tool routing against siblings like sch_get_symbol or pcb_list_items.

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

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

Annotations already declare readOnly/idempotent/non-destructive, so the bar is met; the description adds genuinely useful behavior beyond them by disclosing the cache and its invalidation condition ('cached until any schematic file changes') and the root-sheet-export mechanism.

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 tight sentences, front-loaded with what is returned, then provenance/caching, then the one-line value proposition. No filler or restatement of the tool name.

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

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

An output schema exists so return values need no explanation, and caching, refresh, and multi-sheet path resolution are all covered. The only real gap is the truncation behavior implied by max_nets.

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 75%, so most parameters are self-documented and the 3 baseline applies. The description elaborates on cache/refresh semantics, but says nothing about max_nets or what happens when the net count exceeds it, leaving that one parameter's behavior opaque.

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 resource (resolved connectivity of the whole schematic hierarchy) and enumerates exactly what is returned: nets with nodes, components, sheets. The closing claim 'source of truth for what connects to what' cleanly separates it from siblings like pcb_net_stats or sch_list_components.

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 explains provenance (exported by kicad-cli from the root sheet) and the caching lifecycle, which implies when the tool is appropriate and when refresh is needed, but it never names an alternative (sch_trace, pcb_net_stats) or states when this tool is the wrong choice.

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 cover the safety profile (idempotentHint=true, destructiveHint=false, readOnlyHint=false), and the description adds real context beyond that: it writes files to disk, produces one artifact per sheet in SVG mode, and returns paths for the client to read. It does not say what happens to pre-existing files in the output directory, which is the one notable gap for a writing tool.

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

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

A single front-loaded sentence that carries purpose, mechanism, output shape, and return value with no filler or repetition.

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

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

An output schema exists, so return values need not be detailed, yet the description still explains that paths are returned for display. Combined with the two schema-documented parameters, the definition is nearly complete; only overwrite/cleanup behavior for the output directory is 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 coverage is 67%, with schematic_path and output_dir already documented in the schema. The description adds meaning to the format enum by explaining that svg yields one file per sheet while pdf yields a single multi-page file, which an agent cannot infer from the enum values alone.

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 (render/draw), resource (every sheet of the schematic), the two output formats, the underlying engine (kicad-cli), and the return payload (file paths). It is clearly distinguishable from the sibling render_board tool, which handles the PCB side.

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 choice between svg and pdf is implied ('one file per sheet' vs 'one multi-page PDF'), but there is no explicit when-to-use guidance, no statement of preconditions (e.g. project must be opened), and no named alternative tool for other render targets. Usage is inferable but not spelled out.

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

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

Annotations already cover safety (readOnly, idempotent, non-destructive, closed-world), so the bar is lower. The description adds genuinely useful behavior beyond them: unconnected pins return net=null, and results come from the cached netlist (a staleness/precondition caveat). It does not state what the cache-read implies for freshness, but the added context is substantive.

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

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

Three short sentences, front-loaded with the core action, then the null-pin edge case, then the caching note. No filler or redundancy.

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

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

With an output schema present, annotations covering safety, and full schema descriptions, the description's job is mostly to add edge-case and precondition context, which it does (null nets, cached netlist). Only the freshness/lifecycle of the cache is unaddressed, keeping it just short of 5.

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

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

Schema coverage is 100%, so the schema already documents ref, pin, and schematic_path. The description only reinforces the single-component scope and the 'all pins when omitted' behavior, adding little beyond the schema. Baseline 3 applies.

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

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

The description gives a specific verb and resource: list each pin's net and all other members of that net, scoped to one component. That is clearly distinct from sch_netlist (whole-project netlist) even though the sibling is not named. It stops short of explicit sibling routing, so 4 rather than 5.

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

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

Usage is implied by 'for one component' versus a whole-netlist tool, and 'Uses the cached netlist' hints at a prerequisite (a netlist must already be built). However, no explicit when-to-use/when-not or named alternative (e.g., sch_netlist) is given, so this is minimum-viable guidance.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true, openWorldHint=false and destructiveHint=false, so the safety profile is fully covered by structured fields. The description adds modest value by noting the data is the fab's published geometry plus the source it was read from (provenance), but says nothing about caching, network access, or freshness.

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

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

A single front-loaded sentence with no filler; the returned fields are listed compactly. It is efficient, though the trailing 'with the source they were read from' clause is slightly dense and could be tightened.

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

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

An output schema exists, so the description need not explain return shapes, yet it still characterizes the payload; annotations cover the safety profile and the sole parameter is fully documented. The remaining gap is usage/routing context relative to sibling tools like impedance_calc.

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 a single parameter and 100% schema description coverage, the schema already documents the preset names, aliases, and default. The description adds no parameter-level detail beyond what the schema provides, so the baseline of 3 applies.

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

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

The description names the resource precisely and enumerates its contents (layers with thickness and permittivity, trace geometries per target impedance, provenance source), which lets an agent know exactly what data comes back. However, the action is nominalized ('A stack-up preset:') rather than stated as a verb+resource, and it never distinguishes this lookup from siblings such as impedance_calc or fp_info.

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

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

There is no when-to-use guidance, no prerequisites, and no mention of alternatives or exclusions. The only routing signal lives in the parameter description (available preset names/aliases), not in the tool description itself.

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

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

Annotations already declare readOnlyHint, idempotentHint, non-destructive, and closed-world, so the safety profile is covered. The description does add one genuinely useful behavioral note beyond that: derived symbols are returned flattened as KiCad places them, which affects how output should be read. It says nothing about error behavior for an unknown lib_id or about output size/pagination, so it adds some but not rich 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?

Two sentences, front-loaded with the scope ('Everything about one library symbol') followed by the content list, with a single closing caveat about derived symbols. The long enumeration is dense but each item is informative 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?

An output schema exists, so the description need not explain return structure, and annotations cover safety. For a read-only single-entity lookup with two well-documented parameters, the description is sufficient; only the lack of sibling routing keeps it from being fully complete.

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

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

Schema description coverage is 100%; lib_id's format and project_path's library-shadowing semantics are fully documented in the schema itself. The description adds no parameter-level information (e.g., that project_path changes which symbol definition wins), so baseline 3 applies.

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

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

The description names a specific resource (one library symbol) and enumerates exactly what is retrieved: description, datasheet, default footprint, footprint filters, units, and every pin with number/name/electrical type. That is far more than a restatement of the name. It stops short of naming siblings (lib_search, lib_fetch, fp_info) that an agent might confuse it with.

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

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

Usage is only implied: the exhaustive content list signals 'call this when you need full detail on a single known symbol', and the required lib_id implies a symbol already identified. There is no explicit when-to-use statement, no exclusions, and no routing to lib_search (to find a symbol) or fp_info (the footprint counterpart).

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