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

With no annotations provided, the description carries the full burden of behavioral disclosure. It adds the fact that it works with a real KiCad symbol and requires no coordinates, but it does not mention side effects (e.g., whether the component is added to the schematic, design changes, permissions needed), error conditions, or the return value. This is insufficient for a mutation 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?

The description is a single short sentence, which is concise, but it is under-specified. It does not earn its place by conveying enough actionable information; it omits critical usage and parameter context. Appropriately sized would require at least a couple of sentences explaining key parameters or behavior.

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 5 parameters, 0% schema coverage, and no annotations, the description is grossly incomplete. An agent cannot confidently call this tool without additional information about parameter formats, return behavior, or what happens after the component is added. The presence of an output schema does not compensate for missing operational 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 clarify what 'symbol', 'reference', 'unit', 'value', or 'footprint' mean or how they should be formatted. The agent gets no help beyond the raw schema, which is a significant gap for a 5-parameter tool.

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 'Add' and the resource 'a real KiCad symbol', and explicitly notes that no coordinates are required, which distinguishes it from any coordinate-requiring addition flows. It differentiates from sibling tools like find_symbol (search) and connect_pins (wiring) by implying a placement-free symbol import.

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

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

No explicit guidance on when to use this tool versus alternatives. It mentions 'no coordinates are required' which hints at a use case (adding without positioning), but it does not state exclusions, prerequisites, or recommend when to prefer another tool. The sibling list includes many tools, but none are clearly positioned as alternatives.

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

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

With no annotations provided, the description carries the full behavioral burden. It communicates that the operation mutates net membership, but does not disclose whether existing pin connections are replaced or appended, whether pins can belong to multiple nets, or what happens if the net or pin does not 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?

A single sentence states the action, the resource, and an example pin format with no redundant words. It is front-loaded with the core purpose and is appropriately compact.

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 mutation tool with no annotations and no parameter descriptions in the schema, this one-line description leaves important gaps: connection semantics, failure behavior, and output/return information. The existing output schema reduces the need to explain return values, but the behavioral and parameter context is still under-specified.

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

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

Schema description coverage is 0%, so the description must compensate for the undocumented net and pins parameters. It gives a helpful example format for pins ('U1.3', 'R1.1') but does not explain what a net identifier looks like, whether it is a name or an ID, or how the array elements map to actual pins.

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

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

The description names a specific verb ('Connect'), a precise resource ('semantic pins'), and a target ('an existing net'). The phrase 'existing net' also distinguishes this from the sibling create_net, so an agent can tell them apart immediately.

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

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

The description clearly states the precondition that the net must already exist, implying this tool is for modifying an existing net rather than creating one. It does not explicitly name siblings such as create_net or state when not to use it, but the context is strong enough for correct 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?

No annotations are provided, so the description must disclose behavioral traits. It only states the action without mentioning side effects, error conditions, required permissions, or the nature of the created net. For a mutation operation with zero annotation coverage, this is a significant omission.

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, which is appropriately concise and front-loaded with the core purpose. However, it is under-specified; the brevity works against completeness. It earns its place but leaves critical details unaddressed.

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 no annotations and an output schema, the description should provide enough context for correct invocation. It omits usage scenarios, return behavior, and any operational details. Even though the tool is simple, the lack of guidance makes it incomplete for an agent deciding whether and how to call it.

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

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

The schema description coverage is 0%, so the description must compensate for parameter meaning. The word 'named' hints at the required 'name' parameter, but the optional 'net_class' is not explained at all. The description adds no value beyond what the schema already shows, failing to clarify semantics for either 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 clearly states the action: 'Create a named semantic net in the Circuit IR.' It specifies a verb (create), a resource (semantic net), and the context (Circuit IR). This is specific enough to distinguish from the sibling tools like project_create or component_add, though it does not explicitly name alternatives.

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 guidance on when to use this tool versus alternatives. The description implies you use it when you need to create a net, but it does not state any conditions, prerequisites, or exclusions. Sibling tools are not referenced, leaving the agent to infer usage context.

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

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

With no annotations, the description carries the full burden; it does disclose a state-changing 'commit' and an 'ERC-gate,' suggesting checks can block the commit. However, it does not say whether the commit is destructive, what happens when ERC fails, or whether the earlier steps are actually executed by this 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?

The description is one short sentence with no filler, so it is concise. The use of '+' as a separator creates a telegraphic, ambiguous structure that could be clearer, but it does not waste words.

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

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

For a likely state-changing design workflow, the description omits preconditions, failure behavior, and the meaning of key terms ('ERC', 'semantic state'). Even though the output schema exists and parameters are absent, an agent still lacks enough information to call this tool confidently.

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 zero properties, so there are no parameter semantics to document; the 0-parameter baseline applies. The description appropriately adds no parameter-level detail.

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 core action ('commit semantic state') but buries it after a plus-separated list of other verbs ('Compose + visual-review + ERC-gate'), making it unclear whether those are actions the tool executes or preconditions. It is distinct from the sibling preview/rollback tools by mentioning commit, but 'semantic state' is left undefined.

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 word 'then' weakly implies the tool is a final step after compose, visual-review, and ERC, but there is no explicit when-to-use guidance or mention of alternatives such as design_preview or design_rollback. An agent has to infer the intended workflow.

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

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

With no annotations, the description carries the full burden of behavioral disclosure. It accurately describes the main actions (compose, review, run ERC, preview) and the 'preview' wording implies no commit occurs, but it does not explicitly state whether the tool mutates state or only reads pending changes.

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 filler. Every action word contributes meaning and the overall structure is efficient.

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 there are no parameters and an output schema exists, the description covers the essential context: what the tool does, when to use it, and what it operates on. The only minor gap is the lack of explicit side-effect disclosure, but this is not critical for a preview-oriented tool.

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 has zero parameters, so there is nothing for the description to explain beyond the schema. The baseline for a parameterless tool is 4, and the description provides adequate context for how the tool operates even though it doesn't need to describe any 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 uses specific verbs ('Compose', 'visually review', 'run ERC', 'preview') and explicitly names the resource ('all pending changes') and timing ('before commit'). This clearly distinguishes it from siblings like design_commit and design_rollback, which handle committing or reverting changes.

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 'before commit' gives explicit usage context, telling the agent when this tool is appropriate. It does not explicitly name alternatives or exclusions, but the workflow position is clear enough to guide selection among the sibling tools.

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

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

The description clearly indicates a destructive action by using 'Discard' and scopes that action to pending changes only, which is useful. With no annotations provided, it still omits important behavioral details such as irreversibility, whether committed changes are entirely unaffected, and any side effects on the PCB/IR consistency.

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 conveys the action, scope, and target without any filler or redundancy. Every word contributes meaning.

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

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

For a zero-parameter tool with an output schema, the description is mostly sufficient, but because it is a destructive operation with no annotations, it should at least mention reversibility and the relationship to design_commit. The absence of any usage caveats leaves a modest but real completeness 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?

The tool has no parameters, so the 100% schema coverage is trivially complete and the description does not need to document parameters. The baseline of 4 applies because there is nothing for the description to add.

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 action ('Discard') and a precise resource ('pending PCB and semantic Circuit IR changes'), making the tool's purpose unmistakable. It also naturally contrasts with the sibling design_commit, aiding disambiguation.

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 word 'pending' implies this is for uncommitted changes, which gives some usage context. However, it does not explicitly state when to use this tool versus design_commit, nor does it provide exclusions or workflow 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?

With no annotations, the description carries the full burden of behavioral disclosure. It only states that the tool runs another tool, but does not disclose that the executed tool may have side effects, that errors will occur for unknown names, or that the result format depends on the invoked tool. There is no mention of security considerations or that this tool could trigger destructive actions, making it dangerously under-specified.

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 short sentence, but it is under-specified rather than concise. It omits critical information that an agent needs to use the tool correctly, so the brevity does not serve the user; it hides gaps. A concise description should still be self-sufficient.

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?

This is a meta-tool that can execute any routed tool, so its context requirements are high. The description does not mention how to discover valid tool names, how to construct arguments, what the output schema represents, or any error handling. Without this, an agent cannot safely or effectively invoke it, making the definition woefully incomplete.

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 explain both parameters. It mentions 'by name' and 'given arguments' but does not clarify what 'name' refers to (e.g., the list of valid tool names from search_tools or get_tool_schema), nor does it specify that arguments must conform to the named tool's input schema. The default null for arguments is undocumented, leaving the agent without essential usage details.

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 clear verb ('Run') and resource ('a routed tool') with a parameterized interface (by name and arguments). It distinguishes itself from the sibling tools, which are specific domain actions, by positioning itself as a generic dispatcher. However, it doesn't explicitly contrast itself with the siblings, so it loses a point for not making that differentiation explicit.

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

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

No guidance is given about when to use this tool versus the specific sibling tools. There is no mention of prerequisites (e.g., checking that the named tool exists), no alternative suggestions, and no hint that this is the dynamic execution path. The intended use is implied but not stated, leaving the agent to infer 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?

No annotations are provided, so the description carries the full burden of behavioral disclosure. It does not state whether the operation is read-only, what the output schema implies, how results are ordered, or whether pagination/limits apply. The term 'real symbols' hints at filtering but is vague and unexplained.

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, concise sentence with no waste. However, it is under-specified, so it sacrifices necessary detail for brevity. It is not well-structured for helping an agent decide on usage because it lacks essential context, making it more under-specification than effective conciseness.

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 3 parameters (one required), an output schema, and no annotations, the description is grossly incomplete. It does not explain the query syntax, the role of the library filter, the meaning of the limit, or what the return structure looks like. An agent cannot reliably invoke this tool correctly with the current information.

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

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

Schema coverage is 0%, meaning the description must compensate for undocumented parameters. The description does not mention any parameters (query, limit, library) or their meaning. An agent cannot infer what 'limit' or 'library' control from the text, so the parameter semantics are entirely absent.

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 clear verb ('Search') and resource ('installed/project KiCad libraries') with an object ('real symbols'). It is distinct from siblings like project_create or component_add, which are clearly different operations. However, it does not explicitly differentiate from other search-like tools, so it lacks explicit 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?

There is no guidance on when to use this tool versus alternatives. It does not mention when it is appropriate, what prerequisites exist, or any conditions that would make another tool preferable. The description provides no context for usage beyond the basic action.

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

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

With no annotations, the description must carry the behavioral disclosure burden. It conveys a read-only listing operation returning short summaries, which suggests no side effects. However, it does not mention failure modes, authorization needs, or behavior when the category is invalid or empty.

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 filler. It names the action, the resource, and the output format compactly, making it easy to scan.

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

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

For a simple one-parameter tool, the description is mostly adequate, especially with an output schema available. However, it omits guidance on where to get valid category values and does not position itself relative to adjacent tools such as list_tool_categories or search_tools, leaving some navigational ambiguity.

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 for the single 'category' parameter. It only restates that tools are organized by category, without explaining what kind of value is expected (slug, display name), or how to discover valid categories, such as through list_tool_categories.

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

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

The description uses a specific verb ('List') and resource ('routed tools in a category'), and states the output shape as 'name + one-line summary'. This clearly separates it from sibling tools like list_tool_categories, which lists categories rather than tools, and get_tool_schema, which focuses on a single tool's schema.

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

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

The description implies the use case through 'in a category', but it never explicitly says when to use this tool versus alternatives like search_tools or list_tool_categories. No when-not-to-use guidance or sibling routing is provided, so the agent must infer the intended context.

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

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

With no annotations provided, the description must carry the full behavioral burden. It only states the action (fetch schema) without disclosing whether the operation is read-only, if any authentication is required, error conditions, or rate limits. Since it's a 'fetch' it likely has no side effects, but that's not explicitly stated, and the description fails to provide any such 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?

The description is a single, front-loaded sentence with no wasted words. It states the core purpose immediately and avoids fluff. This is an example of excellent conciseness and structure.

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?

Although an output schema exists (so return values are covered), the description is still incomplete. It doesn't explain how to use the tool (e.g., you need to provide a valid tool name), any constraints on the name, or when it's appropriate to call this before using execute_tool. For a tool with one parameter, a minimal description might suffice, but it leaves out practical context that an agent would need 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?

The schema has one parameter 'name' of type string with 0% coverage from the description. The description says 'for a single routed tool' which implicitly suggests the name refers to the tool, but it doesn't explicitly explain that the 'name' parameter is the tool identifier. It adds little meaning beyond what the schema already shows, and for a 0% coverage case, the description should compensate by clearly describing 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 clearly states the tool fetches the full schema (parameters) for a single routed tool. It uses a specific verb (fetch) and resource (schema), which distinguishes it from sibling tools that focus on creating, inspecting, or executing tools. However, 'routed tool' is domain-specific and might not be immediately clear to an agent, so it's not a perfect 5.

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

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

There is no guidance on when to use this tool versus alternatives. The description doesn't mention that this should be called before executing a tool, nor does it exclude other tools like search_tools or get_category_tools. An agent is left to infer its usage, and no alternative tools are named.

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

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

No annotations are provided, so the description carries the burden. 'Inspect' strongly implies a read-only, non-mutating operation, and the description names what state is examined. However, it does not disclose behavior for invalid references, error handling, or whether the 'current net membership' reflects uncommitted design changes.

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

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

A single, dense sentence with no filler. The main action and object are front-loaded, and the scope details are packed efficiently.

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

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

The tool is simple (one required parameter) and has an output schema, which reduces the burden on the description. Still, the unclear meaning of 'reference' and the absence of any usage guidance leave enough ambiguity that an agent may hesitate about when to invoke it and how to populate its only parameter.

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 identifies the resource type and never defines what 'reference' means (designator, ID, path?), its expected format, or how it relates to existing components. It adds little beyond the parameter name itself.

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

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

The description uses a specific verb ('Inspect') with a clear resource ('a Circuit IR component') and defines the scope precisely: 'real pins and current net membership'. This clearly distinguishes it from mutation/creation siblings like component_add and connect_pins.

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

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

No explicit guidance on when to use this tool versus alternatives such as find_symbol or design_preview. The read/inspect intent is implied by the verb, but no scenarios, prerequisites, or exclusions are stated.

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

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

With no annotations, the description carries the full burden of explaining behavior. It clearly indicates the tool returns a list of categories with per-category tool counts and, via the verb 'List', implies a read-only operation. It does not mention details such as ordering or whether empty categories are included, but the essential behavior is disclosed for a simple listing 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?

The description is a single, front-loaded sentence with no filler or redundancy. It communicates the resource, the action, and the output shape in eleven words.

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

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

For a zero-parameter tool with an output schema, the description is largely complete: it says what is listed and that counts are included. The only notable gap is not explicitly pointing the agent to sibling tools like get_category_tools for drill-down, and the term 'routed' is left slightly ambiguous.

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 zero parameters, so there is nothing for the description to explain semantically. The baseline of 4 applies because no parameter information is needed to invoke the tool correctly.

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 ('List'), a precise resource ('routed tool categories'), and the key qualifier ('how many tools each holds'). It clearly distinguishes this from sibling tools like get_category_tools, which focus on retrieving tools within a category rather than the category/count overview.

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 tool is for getting a top-level overview of categories and their sizes, but it never explicitly says when to use this instead of get_category_tools, search_tools, or get_tool_schema. There is no alternative guidance, so an agent must infer the intended use case.

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

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

With no annotations, the description carries the behavioral burden. It does disclose an important side effect: it initializes the board, schematic, and semantic Circuit IR, not just the project shell. However, it does not mention whether the operation can overwrite an existing project, what state it leaves the project in, or any errors that may occur.

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 one tight sentence with no wasted words. The main verb and resource appear first, and the important initialization behavior is included without padding.

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

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

The tool has three required parameters with zero schema descriptions and no annotations, so the description needs to provide more context. While the output schema exists and the purpose is clear, the lack of parameter semantics and workflow guidance leaves the definition incomplete for reliable invocation.

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

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

Schema description coverage is 0%, and the description does not mention name, width_mm, or height_mm at all. It adds no meaning beyond the bare property names, leaving the agent to infer what width_mm and height_mm represent or what constraints apply.

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: 'Create a project' and then details what gets initialized: board, schematic, and semantic Circuit IR. This clearly distinguishes project_create from lower-level sibling tools like component_add, connect_pins, and create_net.

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

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

It clearly implies this is the tool for creating a new project before working on it, but it never explicitly says when to use it versus alternatives or lists preconditions such as needing an empty workspace or valid dimensions. The usage context is present only by implication.

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

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

No annotations are provided, so the description carries the full behavioral disclosure burden. It conveys that the operation is read-oriented ('Find') and defines the matching behavior as name or summary matching, but it omits details such as case sensitivity, partial matching, ordering, or the exact scope of 'routed 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?

The description is a single, tightly worded sentence with the verb and resource front-loaded. It contains no filler, redundancy, or unnecessary detail, making every word earn 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 one-parameter, read-only search tool with an output schema present, the description is largely complete for invoking the tool correctly. It would be slightly stronger if it clarified the meaning of 'routed tools' or explicitly routed users to this tool versus category-based browsing.

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

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

The input schema provides no description for the 'query' parameter and schema coverage is 0%, but the description compensates by explaining that the keyword is matched against 'name or summary'. This gives the parameter clear meaning beyond the schema's bare existence.

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

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

The description uses a specific verb ('Find') and a specific resource ('routed tools'), and it states the exact matching criterion ('name or summary matches a keyword'). This clearly distinguishes it from sibling tools like list_tool_categories, get_category_tools, and get_tool_schema, which serve different purposes such as browsing categories or retrieving 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?

The description implies the tool should be used when an agent has a keyword and needs to locate relevant routed tools. However, it does not explicitly contrast this with alternatives like list_tool_categories or get_category_tools, nor does it state 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.