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

Annotations already declare readOnlyHint=true, idempotentHint=true, and destructiveHint=false, covering the safety profile. The description adds useful behavior beyond annotations by specifying the return format ('typed tool names') and the required next step ('inspect eda_tool_schema before invoking').

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

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

The description is two concise sentences with no filler. The main action is front-loaded, and the follow-up instruction to inspect eda_tool_schema is placed second, making the structure efficient and easy to parse.

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

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

For a simple single-parameter, optional-query read-only tool, the description covers the core discovery workflow and points to eda_tool_schema as the next step. The only minor gap is empty-query behavior, but the schema default and annotations mitigate that concern.

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

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

The schema has 0% description coverage and only defines a string 'query' with a default. The description compensates by indicating the query can search by name, category, or purpose, but it does not explain behavior when query is empty or omitted, leaving some ambiguity about the parameter's full semantics.

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

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

The description states a specific action ('Search available tools') with distinct search dimensions (name, category, purpose). It also differentiates the tool from siblings by noting it returns typed tool names and that eda_tool_schema should be inspected before invoking, making its role in the tool-discovery workflow clear.

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

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

The description gives a clear workflow: use this tool to find tools, then inspect eda_tool_schema before invoking. This implies positioning relative to eda_tool_schema and eda_invoke, but it does not explicitly name alternatives or state when not to use this tool.

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

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

Annotations already declare destructiveHint=true and readOnlyHint=false, signaling that this tool can cause writes. The description adds that it applies 'same validation, policy and write checks as direct calls,' which is relevant contextual assurance beyond mere annotations. However, it does not discuss error behavior, return value, or side effects that vary by the discovered tool, so it offers only a modest increment.

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

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

Two front-loaded sentences with zero filler. Each sentence earns its place: the first states the action, the second sets expectations against direct calls. This is concise without sacrificing essential intent.

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 generic tool with two parameters, no output schema, and write-capable annotations, the description is minimal. It doesn't explain how to retrieve or structure arguments, what return format to expect, or that the tool can fail if the referenced tool runs validation errors. The sibling discover-and-schema tools are implied but never referenced, so the operational loop is incompletely described.

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 schema description coverage at 0%, the description must compensate. It identifies 'using its complete schema' as the key explanation for the arguments object, and the sibling tool names (eda_tool_schema) hint at the schema source. But it does not explicitly define the 'name' parameter or how arguments map to the target tool's parameters, leaving meaningful gaps for a generic dispatcher.

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

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

The description states a specific verb and resource: 'Execute a discovered tool using its complete schema.' The term 'discovered' clearly points to complementary sibling tools (eda_find_tools, eda_tool_schema) and distinguishes this invocation step from discovery. It doesn't name an alternative directly, but the purpose is unambiguous.

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

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

There is no explicit guidance on when to use this tool versus alternatives. The phrase 'Execute a discovered tool' implies the use case, and 'same validation, policy and write checks as direct calls' suggests equivalence to direct invocation, but no alternatives or exclusion conditions are stated. An agent is left to infer the correct context from sibling-tool names.

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 provide the safety profile (readOnlyHint, idempotentHint, non-destructive). The description adds useful behavioral context: the tool returns its new target, operates within the same project, and does not infer documents from tab titles. No contradiction with annotations is present.

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

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

Two focused sentences with no filler. The action and outcome are front-loaded, and the negative clarification is efficient and valuable.

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

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

For a tool with three required parameters, a nested object, and no output schema, the description is incomplete. It mentions returning a new target but does not explain the target's shape, the parameter relationships, or the return format. An agent would likely need to inspect the schema heavily and still lack semantic guidance.

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

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

Schema description coverage is 0%, and the description provides no field-level parameter meaning. It does not clarify how top-level documentId and domain relate to the nested target object, nor what windowId or projectId mean. With zero schema coverage, the description needed to compensate but did 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?

The description states a specific action with resources: 'Activate an explicit document in the same project and return its new target.' The clarifying negation 'Does not infer documents from tab titles' further sharpens what the tool is and is not for, distinguishing it from inference-based behaviors among siblings.

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

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

The description gives clear context: use this tool when you have an explicit document in the same project, and avoid it when relying on tab-title inference. However, it does not name alternative tools or explicitly state when not to use it, so routing guidance is implied rather than fully 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 mark this as read-only, idempotent, open-world, and non-destructive. The description adds useful behavioral commitments beyond those annotations: results are boolean-only and the tool never fabricates issue details. This is meaningful transparency about output fidelity, though it doesn't discuss failure modes or return structure.

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

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

The description is a single front-loaded sentence that earns each phrase: 'native DRC' specifies the operation, while 'preserves boolean-only results' and 'never invents issue details' add critical behavioral constraints. There is 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 no output schema and a nested required target object, the description is too thin to fully guide invocation. It hints at boolean-only results but does not explain how to form target, what domain values imply, or how this tool fits among the sibling tools. Annotations cover safety but not invocation context.

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

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

Schema description coverage is 0% and the description provides no parameter information. It does not explain the target object, how windowId/projectId/documentId relate, or how the domain enum affects the DRC run. The schema gives names and requirements, but the description adds nothing to help the agent construct correct arguments.

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

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

The description clearly states the action and resource: 'Run native DRC'. It adds specific behavioral scope by noting it 'preserves boolean-only results and never invents issue details', which helps distinguish it from route-checking or workflow tools. However, it does not explicitly name or differentiate sibling tools, so it falls short of a 5.

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

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

The description gives no guidance about when to use this tool versus alternatives such as pcb_check_route, eda_workflow, or pcb_get_state. It implies use when a native DRC is needed, but provides no context, exclusions, or alternative routing.

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

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

Annotations already establish read-only, open-world, idempotent, and non-destructive behavior. The description adds value by disclosing that the result is a native MCP image with pixel validity evidence, and by instructing the agent to inspect it visually. This goes beyond the annotation-only safety profile and clarifies what the call returns.

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

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

The description is two short sentences with no filler. The core action and output are front-loaded, and every clause adds useful information: capture scope, optional region units, return type, and follow-up inspection guidance.

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

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

Given the absence of an output schema, the description usefully states the return type and validity evidence. However, it omits guidance on when to choose this tool over state-inspection siblings, does not explain the target object's required fields, and leaves 'pixel validity evidence' vague. This is adequate but has clear 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 0%, so the description must compensate, but it only clarifies the region's unit ('in mm') and the general notion of capturing a 'target image'. The required nested target object, including windowId, projectId, documentId, and domain, is left unexplained by the description, and the schema property names alone carry most of the 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?

The description clearly states a specific action ('Capture target image') and an optional scoped region, and it mentions the output type. It distinguishes this from state-inspection and workflow siblings by being the only capture/screenshot tool, though it does not explicitly contrast it with any 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?

The phrase 'inspect it visually' implies the tool is for obtaining visual evidence, which gives some usage context. However, the description does not explicitly state when to prefer this over state-based siblings like sch_get_state or pcb_get_state, nor does it specify when not to use it.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true, and destructiveHint=false, so the safety profile is covered. The description adds the important behavioral instruction that the returned target must be used unchanged on subsequent tools, which goes beyond the annotations. It does not disclose what the target looks like or how "bridge" behaves, but it does not contradict the annotations.

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

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

The description is a single sentence split into two concise clauses: what the tool inspects and how to use the result. No words are wasted, and the functional instruction is placed at the end where it completes the purpose. It is appropriately sized for a simple, low-parameter tool.

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

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

With only one optional parameter, no output schema, and strong safety annotations, the definition is adequate for basic invocation. Still, the meaning of "bridge," the effect of windowId, and the shape or contents of the returned target are left vague, which makes the description incomplete for an agent that must reliably pass the target to later 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?

The schema has one optional parameter, windowId, and schema description coverage is 0%, so the description carries the burden of explaining it. The description never mentions windowId, what it filters or selects, or how it affects the returned target. This is a significant gap for an agent deciding whether and how to populate the parameter.

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

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

The description uses the concrete verb "Inspect" with a clear resource list—bridge, windows, active project, document, and boards—so an agent can tell this is a session/context introspection tool. It also explains that a target is returned for reuse, which helps distinguish it from more focused state tools like sch_get_state and pcb_get_state. However, "bridge" is unexplained jargon, and the exact relationship between the returned target and the inspected items 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?

The instruction "Use returned target unchanged on subsequent tools" gives clear usage guidance: call this tool first, then pass the returned target to later tools without modifying it. This is practical and actionable. It does not explicitly name alternatives or say when not to use this tool, but the context strongly implies it is the session-entry tool.

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

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

Annotations already declare readOnlyHint, idempotentHint, and destructiveHint=false, so the safety profile is clear. The description adds that the tool returns read/write semantics as part of its output, but it does not disclose behavior beyond that, such as handling of unknown tool names.

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

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

The description is a single, front-loaded sentence with no redundant wording. Every word contributes to understanding what the tool returns.

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

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

For a simple one-parameter introspection tool with rich annotations, the description is nearly complete: it states the output content and the scoping to one tool. The only gap is the lack of explicit clarification that the 'name' parameter refers to a registered tool name.

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

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

With 0% schema description coverage, the description must compensate for the single 'name' parameter. The phrase 'for one tool' implies 'name' is the tool name, which adds some meaning beyond the raw schema, but it does not explicitly state that 'name' must be an existing tool identifier or how it is resolved.

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 ('Return') and a concrete resource ('complete JSON Schema, purpose and read/write semantics') scoped to 'one tool'. This cleanly differentiates it from the sibling EDA operation tools, which perform design actions rather than introspection.

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

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

The description gives no guidance on when to use this tool versus alternatives such as eda_find_tools or eda_invoke. It does not state that it should be called before invoking a tool to discover its schema and semantics.

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 and destructiveHint=false, so the description need not restate safety. It adds some context about the workflow scope but no further behavioral details (e.g., return format or side effects). Meets baseline for annotated tools.

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?

Single concise sentence with no redundant words. Directly conveys the tool's purpose without fluff.

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

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

For a read-only retrieval tool with no output schema, the description adequately communicates what is retrieved. It could mention the return structure, but that is not strictly required here.

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

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

The description adds no new information about the 'stage' parameter beyond the schema's enum. It references some enum values (placement, recovery) but does not explain their meaning or impact. Schema coverage is complete, 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 the verb 'Read' clearly, specifies the resource as 'workflow for the current design stage', and lists relevant contents (placement, image feedback, recovery). This is specific and distinguishes it from generic state getters.

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?

Implies usage when needing workflow information for a stage, but does not explicitly mention alternatives or conditions for choosing this tool over siblings like sch_get_state or pcb_get_state. Guidance is minimal.

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 provide readOnly, openWorld, idempotent, and destructive hints. The description adds context about the nature of results ('real bindings') and explicitly states that prices and stock are not inferred, which goes beyond the annotations and gives useful behavioral insight.

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

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

The description is two sentences, concise and free of filler. It directly states the purpose and a key behavioral detail, with no unnecessary information.

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

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

Given the tool has 5 parameters (including a nested target object) and no output schema, the description is too brief. It does not explain the purpose of the 'target' parameter, the meaning of 'page'/'limit', or provide any details about the return structure beyond 'real bindings'. Users would need additional documentation to use it effectively.

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?

Parameter schema has no descriptions (0% coverage). The description only hints at 'keyword or LCSC part number', which partially maps to 'query' and 'lcsc' but does not clarify the 'target' object, 'page', or 'limit' parameters. It does not sufficiently compensate for the lack of schema descriptions.

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

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

The description clearly states the verb 'Search' and the resource 'library devices', and specifies two search modes (keyword or LCSC part number). This distinguishes it from sibling tools like eda_find_tools, which likely focus on different objects.

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 indicates the tool is for searching library devices, but does not explicitly state when to use this tool versus alternatives or mention any exclusions. It implies usage but lacks explicit guidance on when not to use 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?

The description discloses that the tool applies a route, reads back IDs and connectivity, and then runs DRC, which aligns with destructiveHint and readOnly false. It does not mention reversibility or overwrite semantics, but the annotations already signal destructive 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?

The description is two short sentences with no filler; the main action and workflow are front-loaded. The phrase 'MODEL-supplied' is slightly opaque but does not hurt concision.

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?

It provides a workflow sketch (checks, apply, read back, DRC) and the no-autorouter boundary, but it omits output shape and sufficient detail about target, revision, and operationId. An agent could infer the basic call but would not fully understand all inputs or return values.

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 description refers vaguely to 'revision checks' and a 'path,' but target, operationId, revision, and route are otherwise unexplained. With 0% schema description coverage and a complex nested route schema, the description does not compensate for the lack of parameter guidance.

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 has a clear verb and resource ('Apply path') and explicitly says 'No autorouter,' which helps distinguish it from automatic routing tools. However, 'MODEL-supplied path' is somewhat cryptic and does not fully define the PCB object or outcome.

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 indicates using it after fresh geometry/revision checks and mentions DRC follow-up, but it does not explicitly say when to call this instead of pcb_check_route or eda_run_drc. 'No autorouter' gives a negative boundary but no positive selection criteria.

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

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

Annotations already mark the tool as read-only and idempotent, and the description reinforces this with 'Read-only; never plans or applies routes.' It adds behavioral specificity about the checks performed. It does not describe return values or failure behavior, but since there is no output schema, that is a moderate gap rather than a contradiction.

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

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

The description is a single, compact sentence that front-loads the action and object, then adds a key behavioral caveat. It contains no redundancy and every phrase earns its place.

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

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

The description captures the core operation and non-mutating nature well, which is important for a read-only checker. However, with no output schema, it omits what the tool returns on pass/fail and does not explain how the target or clearance parameters participate in the check, leaving some operational context missing.

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

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

Schema description coverage is 0%, and the description does not compensate: it only mentions the route as an 'explicit MODEL-supplied path' and says nothing about the 'target' object or how route properties like clearance, vias, or segments are interpreted. The agent must rely on schema property names 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?

The description opens with a specific verb, 'Check', and names the precise object—'explicit MODEL-supplied path'—and the constraints checked: copper, pad shapes, board edges, and layer transitions. This clearly differentiates it from route planning or applying routes.

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 clear context by framing the tool as validation of a model-supplied path and explicitly states it 'never plans or applies routes,' which tells the agent what not to use it for. However, it does not explicitly name sibling alternatives like pcb_apply_route or state when to prefer them.

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 readOnlyHint, idempotentHint, and non-destructiveness; the description aligns with these by saying 'Read' and 'No autorouting'. It adds value by enumerating the data categories (endpoints, copper, obstacles, outline, connectivity), giving a clearer picture than the annotations alone.

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

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

A single two-clause sentence that front-loads the action and object, adds one crucial non-assertion ('No autorouting'), and contains no redundant filler. Every word earns its place.

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

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

For a read-only context getter with no output schema, the description names the main return content categories, which is helpful. However, it omits any explanation of the target parameter structure, the expected net format, or how the returned routing context is represented, leaving moderate gaps for an agent to resolve from the schema alone.

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

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

Schema description coverage is 0%, so the description must compensate, but it only loosely implies the 'net' parameter by mentioning net endpoints and gives zero explanation of the nested 'target' object or its windowId/projectId/documentId/domain fields. The agent must guess parameter semantics from names and schema structure.

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

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

The description opens with a specific verb ('Read') and names the exact resources: net endpoints, copper, obstacles, outline, and connectivity. The explicit 'No autorouting' clause distinguishes it from route-modifying siblings like pcb_apply_route or pcb_check_route, so an agent can select it confidently.

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?

'before the MODEL chooses a path' clearly frames when this read is appropriate, and 'No autorouting' rules out the expectation that this tool will make routing decisions. It does not explicitly name sibling alternatives or give when-not-to-use conditions for pcb_get_state, so it falls just short of full routing guidance.

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

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

Annotations already declare readOnlyHint, openWorldHint, idempotentHint, and destructiveHint false. The description's 'Read' wording is consistent but adds no additional detail about side effects or state changes. It mentions 'explicit unsupported geometry' but that concerns return data, not 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?

The description is a single, clear sentence with no redundancy. It efficiently enumerates the key elements returned without unnecessary detail.

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

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

The description lists the content returned but does not specify the response format, units beyond mm, or how 'unsupported geometry' is represented. With no output schema, more detail on return structure would improve completeness, but the description is adequate for a basic 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?

The input schema has one object with windowId, projectId, documentId, and domain, but the description provides no explanation of these parameters or how they affect the result. Schema description coverage is 0%, leaving the agent to infer their meaning from names 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?

The description clearly states the tool reads real pads, tracks, vias, components, and outline in mm, with revision and unsupported geometry. It distinguishes itself from sch_get_state (schematic) and other pcb tools by focusing on a full PCB state read.

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 a read-only state retrieval but does not explicitly state when to choose this over alternatives like pcb_get_routing_context or pcb_check_route. The context of sibling tools helps, but explicit usage guidance is missing.

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

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

Annotations already declare readOnlyHint, idempotentHint, and non-destructive behavior, so the base is covered. The description adds specific details about the nature of the read (e.g., actual world coordinates, rotated/mirrored pins) which provides useful behavioral context beyond the annotations, though no contradictions exist.

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

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

The description is a single, dense sentence that conveys all essential information without redundancy. It is front-loaded with the verb 'Read' and efficiently lists the types of data returned.

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

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

The description gives a clear idea of what is returned (components, footprint bindings, coordinates, wires) and includes units and transformation details. While it lacks an explicit output schema, the description sufficiently outlines the return content for a read-only tool, and the absence of side effects is covered by annotations.

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

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

The schema has a single nested 'target' object with required fields, but the description does not mention any of these parameters or their meanings. With 0% schema coverage, the description fails to compensate by explaining what 'target' refers to or how the parameters affect the read.

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

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

The description uses the explicit verb 'Read' and lists specific resources: components, footprint bindings, pin coordinates, and wires, with details like 'in mm' and 'rotated/mirrored pins'. This clearly distinguishes it from sibling tools like pcb_get_state, which target PCB routing context.

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 use for schematic state retrieval by mentioning 'sch' in the tool name and listing schematic-related elements, but it does not explicitly state when to use this over alternatives like pcb_get_state. No direct comparison or condition is given, so guidance is implicit rather than explicit.

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