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 only states the basic operations and supported modes; it does not disclose output units, formula assumptions, handling of invalid or conflicting parameters, or any limits on accuracy or applicability.

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 primary operations are front-loaded, and the supported geometry list is compactly appended.

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, no annotations, and a 7-parameter calculation tool, the description should clarify expected results, permissible parameter combinations, and constraints. It does none of that, leaving an agent to infer return values and optional-parameter behavior from parameter names 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 100%, so the schema already documents every parameter, including the default values and the mutual exclusivity between width and targetImpedance. The description adds only a concise restatement of the dual calculation direction and mode support, which does not meaningfully extend the structured parameter 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 clearly states the tool's actions: compute PCB trace impedance or reverse-calculate trace width from a target impedance, and lists supported geometries. However, it does not explicitly distinguish this tool from the sibling calc_trace_width, which likely overlaps in the reverse-calculation use case.

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

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

The description implies when the tool is useful by naming impedance calculation, reverse width calculation, and supported transmission-line types. It does not provide explicit when-to-use versus alternatives guidance, such as when to choose calc_trace_width instead of calc_impedance.

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 discloses that this is a calculation following IPC-2221, which implies a deterministic, non-destructive operation. However, it does not mention return format, units of the calculated width, or behavior for invalid inputs, leaving moderate gaps.

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 focused sentence that states the essential purpose and standard with no filler or redundancy. It is appropriately sized and effectively front-loaded.

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

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

Inputs and defaults are fully documented in the schema, and the purpose is clear. However, with no output schema, the description does not specify the result's units or format, which is a meaningful gap for interpreting the tool's return value in a PCB design 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 100%, so the parameters are already well-documented with units and defaults. The description adds general formula context but does not enrich any specific parameter beyond what the schema provides, matching the baseline-3 case.

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 ('计算最小走线宽度'), a clear resource ('minimum trace width'), and the governing standard ('IPC-2221'), which makes the tool's purpose immediately identifiable. It is clearly distinguishable from siblings like calc_impedance because it targets trace width based on current-carrying requirements.

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

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

The description provides clear context: use this tool when you need to size a trace for a given current-carrying requirement according to IPC-2221. It does not explicitly name alternatives or exclusions, such as distinguishing from calc_impedance, but the context is clear enough for an agent to select it appropriately.

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

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

With no annotations, the description must disclose side effects, but it only lists the pipeline steps. It does not mention that routing may modify existing tracks, what happens if DRC fails, whether it's undoable, or any other behavioral details. For a mutating pipeline, this is insufficient transparency.

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 that conveys the entire pipeline flow. It is efficiently structured with a clean arrow separator, avoiding waste while delivering the essential sequence.

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?

While the pipeline is clearly defined, the description omits details like whether the tool works on the whole board vs current selection (it says 'all' but not explicit), error handling, or any preconditions. It meets the minimum for a multi-step automation but lacks depth for a complex mutation.

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 are zero parameters, so the description does not need to explain any. According to the baseline, a 4 is appropriate since no parameter clarification is required and the schema is empty.

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 it's a pipeline performing fanout, routing, DRC, and silkscreen repair on all components/nets. It uses specific verbs for each stage, distinguishes from siblings like pcb_fanout_component which only does fanout, and makes the integrated nature obvious.

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 explicit when-to-use or when-not-to-use guidance. It does not compare to individual tools or mention scenarios where the full pipeline may be inappropriate. The pipeline nature is implied but not clarified for selection purposes.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It does reveal core behavior (moving components to pad centroids) and the locked-skip rule, but omits side effects (permanent placement changes), scope (all components vs selection), and reversibility. This is partial but not comprehensive disclosure.

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

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

The description is a single, well-structured Chinese sentence that states the purpose ('自动布局'), method ('移动到其焊盘质心'), algorithm level ('一阶优化'), and exception ('锁定元件跳过') with no wasted words.

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

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

For a mutation tool with no annotations and no output schema, the description explains the concept and provides the locked-skip detail, but it lacks information about operation scope, what '一阶优化' means in practice, and behavior when maxMoves is reached. These gaps make it sufficient but not complete.

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

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

The single parameter maxMoves has full schema coverage with its description ('最大移动数（默认 100）'), so the schema already carries the semantics. The tool description adds no extra meaning about how maxMoves is used in the first-order optimization, giving no value beyond structured data.

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

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

The description explicitly states the tool performs automatic layout ('自动布局') by moving components to their pad centroid ('移动到其焊盘质心') and skips locked ones ('锁定元件跳过'). This clearly distinguishes it from manual placement tools like pcb_move_component or pcb_batch_move.

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 conveys clear context: it is an auto-placement optimization tool that moves components to pad centroids, with locked components skipped. However, it does not explicitly mention when to prefer it over related automatic tools like pcb_fanout_component or pcb_auto_route_nets, nor does it state 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?

With no annotations provided, the description carries the full burden. It discloses the two routing strategies and the requirement for DRC recheck, which adds valuable context. However, it fails to mention potential side effects such as modifying or deleting existing tracks, or whether it routes all nets or only selected ones.

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 that is front-loaded with the core action ('自动布线') and packs all key mode information compactly. There is no 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?

For a complex board-modifying operation with 6 parameters and no output schema, the description is too sparse. It misses critical operational details like whether existing tracks are ripped up, how failures are handled, and the scope of nets affected, making it incomplete for the AI agent to fully understand the tool's behavior.

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

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

Schema description coverage is 100%, so baseline is 3. The description adds cross-parameter meaning by linking 'useVias' to the two-layer L-shape mode and 'clearance' to obstacle avoidance, which goes beyond the individual schema descriptions and helps the agent understand parameter interactions.

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 '自动布线' (auto-routing) and specifies two routing modes: single-layer obstacle avoidance and two-layer L-shape with vias. This distinguishes it from manual routing tools like pcb_route_track and other auto-routing variants.

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 when automatic routing is desired and explicitly notes that DRC recheck is needed afterward. It does not explicitly name alternatives or exclusions, but the context of 'auto' versus manual routing is clear 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?

No annotations are provided, so the description carries the full burden of behavioral disclosure. It says it rearranges all silkscreens but does not warn that this is a bulk mutation, whether it can be undone, or whether it affects existing manual placements.

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 short sentence with no filler; the core operation is front-loaded and every word adds 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 no output schema, the description is minimally adequate: the agent knows what action will be taken. However, because it mutates all silkscreen placements and no annotations cover side effects, a note about reversibility or confirmation would make it more complete.

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

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

The tool takes zero parameters and schema coverage is complete, so there are no parameters to document. The description does not need to add parameter details, and the baseline for a zero-parameter tool 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 states a specific verb (自动排列/auto-arrange), a resource (所有丝印/all silkscreens), and a goal (避免重叠/avoid overlap). This clearly distinguishes it from the sibling pcb_move_silkscreen, which is a manual per-element move.

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 intended use is implied: use this when you want automatic, board-wide silkscreen arrangement rather than manual movement. However, it never explicitly names alternatives or states 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?

No annotations are present, so the description carries the full burden of behavioral disclosure. It only restates the operation and does not clarify whether the move is absolute or relative, whether the operation overwrites existing positions, what happens on invalid designators, whether the action is reversible, or what the tool 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 a single efficient sentence with no filler, and the key batch/multiple scope is front-loaded. It is concise and well structured, though it sacrifices important contextual 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?

For a mutating tool with no annotations and no output schema, this one-phrase description is not enough for confident invocation. It omits coordinate units, behavior on partial failure, interaction with current selection, and any return value expectations.

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 already provides 100% description coverage for the single parameter, defining the moves array structure with required designator, x, y and optional rotation. The description adds no parameter-specific meaning, so the baseline score of 3 is appropriate.

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

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

The Chinese description '批量移动多个元件' names a specific action (batch move) and resource (multiple components). It distinguishes the tool from single-component move siblings like pcb_move_component by emphasizing 'batch' and 'multiple', though it leaves some ambiguity about whether '元件' means PCB footprints or generic design elements.

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 '批量' (batch) and '多个' (multiple) imply this tool is for moving several components at once rather than a single component, which is the likely alternative pcb_move_component. However, there is no explicit when-to-use guidance, no exclusion of alternatives, and no mention of constraints like designator existence or selection prerequisites.

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

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

Since no annotations are provided, the description carries the full burden. It discloses that automatic LCSC querying is unavailable due to API protection, which is useful. However, it does not mention side effects (e.g., whether it modifies the board), or details about the output structure beyond noting JSON and CSV.

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, concise and front-loaded with the core action and result. It packs key details (aggregation options, return format) without waste, though it could benefit from a brief usage scenario.

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

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

For a single-parameter tool without an output schema, the description is reasonably complete. It explains the input mapping and the output format, but lacks details on when the tool is necessary or how the CSV/JSON are structured, which could be important for an agent to interpret results.

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

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

The schema covers 100% of the parameters, and the description adds alpha information about the format of the mapping and the reason for limitation (protected API). The schema already provides the exact structure, so the description doesn't add much beyond that.

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 exports a PCB BOM aggregated by component name, including quantity, designators, nets, and LCSC part numbers, and returns both JSON and CSV formats. It distinguishes itself from sibling tools by being an export-specific operation, though it doesn't explicitly name an alternative for BOM export.

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 usage for exporting BOM data but does not explicitly specify when to use it versus alternatives. It mentions the LCSC codes mapping requirement but does not provide guidance on when this tool is preferred over other PCB analysis tools like pcb_netlist_report or sch_get_netlist.

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 present, so the description carries the full burden. It indicates this is a read-only status check (查看 = view), but does not mention safety implications, required permissions, or potential side effects. Given zero annotations, a 3 is reasonable but it could explicitly state it's non-destructive.

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 sentence, front-loaded with the purpose, and includes key output details. No fluff 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?

For a zero-parameter diagnostic tool, the description is adequately complete. It specifies what status is checked. However, without an output schema, it would be helpful to mention the return type (e.g., JSON structure), but given the simplicity, a 4 is appropriate.

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?

Tool has 0 parameters; description does not need to explain parameter semantics. Baseline 3 is elevated because no parameter documentation is needed at all. The description clearly states what it returns (service ID, connection counts, active window), which adds value beyond the empty schema.

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

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

The description clearly states the tool's function (view Bridge Server connection status) and lists specific information returned (service ID, EDA window connection count, active window). It's distinct from pcb_ping and pcb_get_state in scope, though not explicitly contrasted with them, so it loses one point for lacking an explicit 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?

No guidance on when to use this tool versus alternatives like pcb_ping or pcb_list_eda_windows. The description does not provide context about typical usage scenarios or prerequisites.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. 'Marks violating pairs' is ambiguous—it does not clarify whether this mutates board markers, only returns a report, or has other side effects. The lack of output or side-effect details is a significant transparency gap for a check-like 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 concise sentence that directly states the purpose and behavior. It is front-loaded with the action and resource, and contains no filler or redundant 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 there is no output schema and no annotations, the description should specify what the agent receives after invocation—such as a list of violations, a report, or a board marker update. It also does not clarify whether this is read-only or has persistent effects, making it incomplete for reliable agent use.

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

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

The single parameter minClearance is fully documented in the schema with units (mil) and default value (20). The description adds the concept of a threshold but does not provide additional meaning beyond the schema. This matches the baseline for high schema coverage.

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

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

The description clearly states the tool's function: checking minimum clearances across all component pairs and marking violating pairs below the threshold. It includes a specific verb (check/mark), a specific resource (all component pairs), and the outcome (identified violations), which distinguishes it from broader or unrelated sibling tools.

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

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

The intended use is implied by the description—use this when you need to verify component-pair clearance against a threshold. There is no explicit guidance about when to prefer this over pcb_run_drc or other design rule checks, nor any stated exclusions or 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 burden of behavioral disclosure. It only states the action and does not mention side effects, such as creating a new instance on the board, how it interacts with existing components at the same coordinates, whether it requires a pre-opened document, or how failures are surfaced. Important behavioral context is missing.

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 that communicates the core purpose immediately. There is no redundancy or filler, and the key action is front-loaded.

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

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

Although the schema is complete, there is no output schema and no annotation coverage. The description does not address potential failure modes, what happens after placement, or the behavioral aspects required to use the tool confidently in an agent loop. More context about the placement operation and its effects would be needed for full completeness.

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

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

Schema description coverage is 100%, so the input schema already documents every parameter, including units for coordinates (mil) and layer codes (1=top, 2=bottom). The description adds only the conceptual link between 'library' and libraryUuid/componentUuid, so it does not need to compensate for missing schema information.

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: '从库中放置元件到 PCB' (place a component from the library onto the PCB). It names the resource (component), the source (library), and the destination (PCB), and this wording differentiates it from sibling tools like pcb_relocate_component or pcb_move_component, which imply moving existing components rather than placing new ones.

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 main use case—placing a new component from a library—but gives no explicit guidance about when to choose this tool over alternatives, such as pcb_relocate_component for moving existing components. It also does not mention prerequisites like having a PCB document open or a valid library loaded.

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，描述需承担全部行为披露责任，但它只说“创建”，未提及对已有铺铜区域的影响、层或网络有效性、调用后如何确认结果等。对于写操作而言，行为透明性不足。

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?

描述只有一句话，信息密度高，主题前置，没有冗余内容。虽然过于简短，但作为工具用途描述而言足够简练且易于快速理解。

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?

参数 schema 完整且无嵌套对象，复杂度较低；但无 annotations 和 output 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?

input schema 对所有 6 个参数均有描述，覆盖率 100%，因此描述无需重复参数含义。描述中的“矩形”仅与 x1/y1/x2/y2 的几何意义泛泛对应，未额外增加参数格式、单位或约束信息。

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?

描述明确使用动词“创建”和目标资源“矩形铺铜区域”，清楚表明该工具用于创建矩形铺铜。虽然没有明确与 pcb_create_keepout 等兄弟工具做区分，但资源类型本身足以初步辨别其用途。

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?

描述仅陈述功能，未说明何时应选择铺铜而非走线、keepout 或其他创建类工具。没有列出替代工具或排除条件，代理只能从工具名和上下文推断使用时机。

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 bears the full burden of disclosing behavioral traits. It only states that a differential pair is created, omitting any behavior around validation, failure modes, effects on existing objects, or requirements for the positive and negative nets. This is less informative than even minimally acceptable create-operation descriptions.

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 extremely short, but this is under-specification rather than effective conciseness. A single restatement of the tool's name lacks the structured, front-loaded detail expected of a helpful tool description.

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 create tool with three required parameters, no annotations, and no output schema, the description should provide more context about expected input relationships, possible errors, and how the created diff pair behaves. The current description leaves the agent to infer preconditions and postconditions, making it incomplete for confident 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 100%, so the input schema already documents all three parameters ('name', 'posNet', 'negNet') with clear Chinese descriptions. The tool description adds no additional parameter meaning, but the baseline of 3 applies because the schema fully covers parameter 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 '创建差分对' simply restates the tool name pcb_create_diff_pair ('create differential pair'), providing no additional specificity beyond the name itself. It does not distinguish the tool from related sibling tools such as pcb_create_equal_length or pcb_delete_diff_pair.

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

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

The description provides no guidance on when to use this tool versus alternatives, such as pcb_list_diff_pairs, pcb_delete_diff_pair, or pcb_create_equal_length. There is no mention of prerequisites like whether the referenced nets must already exist or how this differs from creating equal-length constraints.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It only states that an equal-length group is created, but does not mention side effects, whether existing groups are replaced, validation behavior, or any other operational consequences.

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 extremely short and free of filler, but it is under-specified for the decision an agent must make. It is concise without being adequately informative.

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 schema covers parameters, but there are no annotations, no output schema, and no usage or behavioral context. An agent has little information about what actually happens when the equal-length group is created or how this fits with related 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 100%, so the input schema already documents both 'name' and 'nets'. The tool description adds no parameter-level meaning beyond the schema, so the baseline score of 3 is appropriate.

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

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

The description '创建等长组' ('Create equal-length group') clearly identifies a specific action and resource. However, it does not explicitly distinguish this tool from related siblings such as pcb_create_diff_pair or pcb_list_equal_lengths.

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

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

The description provides no guidance on when to use this tool versus the many related alternatives. There is no stated context, prerequisite, or exclusion to help an agent choose 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?

No annotations are provided, so the description carries the full burden of behavioral disclosure. It only says 'create rectangular keepout' and does not mention document state requirements, return behavior, side effects on existing keepouts, or whether the operation can fail.

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 phrase with no filler, front-loading the verb and object. It is appropriately concise for a simple tool, though it could carry more useful context without becoming verbose.

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 5-parameter tool with no annotations and no output schema, the description is too terse. It omits behavior after creation, coordinate ordering beyond the schema, layer semantics, and expected result, leaving an agent unable to fully anticipate the invocation outcome.

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

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

The schema covers 100% of parameters with descriptions including coordinate roles and units (mil). The description adds only the 'rectangular' shape context, which slightly clarifies that x1/y1 and x2/y2 form opposite corners, but does not significantly expand on the schema.

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

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

The description clearly states the action (create) and the resource (rectangular keepout region). It differentiates itself from pcb_delete_keepout by the create action, though it does not explicitly contrast with any sibling tool.

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

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

No guidance is given about when to use this tool versus alternatives such as pcb_delete_keepout or pcb_create_copper_pour. Usage is only implicit in the verb 'create' and the noun 'keepout.'

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. 'Create via' implies a mutating operation but does not state whether an open document is required, whether the operation is reversible, or what side effects may occur on the board.

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 extremely terse and contains no waste, but it is under-specified for a five-parameter mutation tool. Brevity here comes at the cost of missing context that the schema and annotations cannot provide.

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 mutating PCB tool with no annotations and no output schema. The description does not mention board state requirements, how the via relates to existing nets or tracks, or what the result of a successful creation is, leaving important context absent.

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%, with each parameter documented in Chinese (coordinates in mil, net name, drill and outer diameters). The description adds no additional parameter meaning, so the baseline score 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 '创建过孔' clearly states a specific verb and resource: create a via. It is unambiguous about the tool's purpose, though it does not explicitly differentiate itself from sibling tools like pcb_delete_via or pcb_create_component.

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, nor any mention of prerequisites such as having a board open or a valid net. The agent must infer usage entirely from the tool name and schema.

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 transparency burden. It discloses the estimation approach and the 'mark low nets' behavior, but does not clarify whether 'mark' is a visual overlay, a persistent design modification, or a report output, and it does not mention side effects or prerequisites.

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 entire description is one short, front-loaded sentence that packs the purpose, method, and expected outcome 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?

For a zero-parameter analysis/report tool, the description is reasonably complete: it names the calculation standard, the input concept (trace width sum), and the output behavior (flagging low-capacity nets). It does not detail the report format or threshold, but the low complexity reduces the 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?

The tool has zero parameters, so the baseline is 4. The description adds useful semantic context by explaining that the calculation converts summed trace width per net into a current capacity estimate, which is more informative than an empty schema.

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

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

The description clearly states a specific action (estimate current-carrying capacity), the target resource (each net), the method (IPC-2221, sum of trace widths to current capacity), and the outcome (mark low-capacity nets). This distinguishes it from sibling report/calculation tools like pcb_design_health_report or calc_trace_width.

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

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

The context is implied but not explicit: it is for evaluating net current-carrying capacity across the board. It does not state when to prefer this over alternatives such as calc_trace_width or pcb_run_drc, nor are exclusions provided.

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 indicates a destructive operation but does not mention whether associated tracks, vias, or routing are also removed, whether the deletion is reversible, or what happens when the named differential pair 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?

The description is a single short sentence with no filler. The action and object are immediately visible, and every character 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 single-parameter delete operation, the description is minimally usable because the schema already documents the parameter. However, with no annotations and no output schema, it lacks side-effect and failure-mode context, leaving the agent unable to predict the full impact of a destructive call.

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

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

The input schema already documents the only parameter, 'name', with the description '差分对名称'. The tool description adds no additional semantic meaning beyond that, so the baseline score of 3 applies due to high schema coverage.

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

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

The description '删除差分对' clearly states a specific verb ('delete') and resource ('differential pair'), so the core purpose is unambiguous and distinguishable from delete-tracks or delete-via tools. However, it does not explicitly disambiguate from pcb_delete_selected or state that deletion is by name rather than by selection.

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 about when to use this tool versus alternatives such as pcb_delete_selected, pcb_delete_equal_length, or pcb_delete_tracks. No prerequisites or conditions are provided; the intended usage is only implied by the tool name and resource type.

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 present, so the description carries the full burden of behavioral disclosure. It only says 'delete equal-length group' and does not state whether deletion is irreversible, whether related tracks or design rules are affected, or what happens to the group's name after deletion.

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 efficient sentence with no filler or repetition. It is appropriately concise, though it is arguably too terse because it omits behavioral and contextual details.

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

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

For a destructive tool with no annotations and no output schema, the description is incomplete. It does not clarify what 'equal-length group' means in this PCB context, whether the operation is reversible, or what the result is, leaving the agent without key information for a delete operation.

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 describes the only parameter 'name' as 'equal-length group name' with 100% coverage. The description adds no additional meaning about the parameter, so it is correctly at the baseline for fully schema-documented 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?

The description states the verb 'delete' and the resource 'equal-length group', so the core operation is clear. It does not explicitly differentiate itself from sibling deletion tools, but the resource name already sets it apart from pcb_delete_tracks, pcb_delete_via, pcb_delete_pour, pcb_delete_keepout, and pcb_delete_diff_pair.

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

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

No guidance is given about when to use this tool versus alternatives such as pcb_delete_selected or how prerequisites like an existing equal-length group should be verified. The description neither provides exclusions nor names alternative tools, so the agent receives no decision support.

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 burden of behavioral disclosure. It conveys the destructive delete action but says nothing about scope, reversibility, permissions, or what happens to connected design data. This is minimal but not contradictory.

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 phrase with no filler or redundant clauses. For a one-parameter delete operation, this is appropriately sized and front-loaded.

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

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

The operation is simple and the parameter is fully documented, so the minimal description is arguably sufficient. However, with no annotations and no output schema, the agent receives no information about side effects, return value, or failure behavior, leaving some 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 100%, so primitiveId is already documented. The description adds no extra meaning or usage detail beyond the schema, matching the baseline for fully documented 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?

The description '删除禁布区' states a specific action (delete) and resource (keepout area), making the tool's purpose unambiguous. It does not explicitly differentiate from siblings like pcb_delete_selected or pcb_delete_pour, but the keepout-specific target is 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?

No usage context is provided: there is no statement about when to delete a keepout by primitiveId versus using pcb_delete_selected or other deletion tools. The intended scenario is only implied by the tool name and parameter schema.

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?

There are no annotations, so the description carries the full burden of behavioral disclosure. It only says 'delete' without warning that the operation is destructive, irreversible, or what happens to associated copper-pour data; this is a meaningful gap.

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 compact four-character phrase with no filler or redundancy. While minimal, every word contributes to stating the core operation.

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

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

For a one-parameter delete tool the description is minimally sufficient: the agent knows the action and the schema supplies the required input. However, it omits guidance on how to obtain primitiveId, whether the action is undoable, and any side effects, so there are 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 coverage is 100%: the only parameter, primitiveId, is described as '铺铜图元 ID' (copper pour primitive ID). The description adds no extra meaning beyond this, so the baseline score 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 states a specific action and resource: delete a copper pour ('删除铺铜'), which is distinct from sibling tools like pcb_delete_via or pcb_delete_keepout. It doesn't add detail beyond the tool name, so it is clear but not enriched.

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 on when to invoke this tool instead of pcb_delete_selected or other deletion tools, and there are no prerequisites or exclusions. The intended usage must be inferred from the name and the required primitiveId.

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 present, so the description must carry the full behavioral burden. It only says 'delete currently selected objects' and does not disclose irreversibility, whether a confirmation occurs, what happens when nothing is selected, or the exact scope (though the pcb_ prefix hints at PCB context). This is thin for a destructive mutation.

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 short sentence, perfectly sized for a zero-parameter tool. No filler, no redundant restatement, and every word contributes to the action and target.

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 no output schema, the one-liner is minimally viable but leaves gaps: no behavior on an empty selection, no undo or destructive warning, and no return/result description. Since the tool is simple and parameterless, these gaps are noticeable but not fatal.

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 are zero parameters and an empty schema, so the baseline is 4. The description identifies the implicit input — the current selection — and needs to describe no parameter syntax. It adds just enough context for a parameterless 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 states a clear verb ('删除' / delete) and a resource ('当前选中的对象' / currently selected objects). It is more specific than a tautology and implies a generic delete operation on the active selection, which distinguishes it from type-specific delete siblings such as pcb_delete_tracks or pcb_delete_via, though it doesn't explicitly name them.

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 generic deletion tool versus the many specific delete siblings (tracks, vias, pours, keepouts, diff pairs, equal lengths). The qualifier 'current selected' is the only implicit usage signal; there are no explicit conditions, prerequisites, or exclusions.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. It clearly indicates a destructive operation, but it does not mention side effects, undoability, what happens to connected nets, invalid-ID handling, or whether only track primitives are accepted. Basic intent is conveyed, but meaningful behavioral context is missing.

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 phrase with no filler or redundant detail. It is appropriately sized for a one-parameter destructive operation and every word contributes to stating the operation's purpose.

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

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

For a destructive tool with no annotations and no output schema, the description is too thin. It lacks behavioral caveats, any usage context, and clarification of what the operation does to the broader PCB state. The schema covers the parameter, but the description alone is not enough for an agent to confidently invoke this tool in varied situations.

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%: the only parameter, primitiveIds, is described as "走线图元 ID 列表" (track primitive ID list). The tool description adds no meaning beyond restating the target resource, so the baseline score of 3 applies; it neither harms nor meaningfully enriches parameter understanding.

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 "删除走线" (delete tracks) states a specific action and target resource, making it clear that this tool deletes track primitives rather than vias, pours, or other objects. It is not a tautology and is distinguishable from sibling deletion tools like pcb_delete_via and pcb_delete_selected by the resource named, though it does not explicitly contrast those 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 about when to use this tool versus alternatives such as pcb_delete_selected or pcb_delete_via. No prerequisites, exclusions, or use-case conditions are mentioned, leaving the agent to infer which deletion operation fits a given situation.

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, but it only repeats the operation. It does not state whether deletion is irreversible, whether connected routing is affected, or whether permissions are required.

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 extremely short and front-loaded, but this is under-specification rather than effective conciseness. It omits meaningful behavioral and usage guidance that an agent needs.

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 single parameter is fully described in the schema, but the description provides no output behavior, scope, or side-effect information. For a destructive deletion tool with no annotations and no output schema, this is 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 100%, and the schema already defines primitiveIds as a list of via primitive IDs. The description adds no additional parameter semantics, so the baseline of 3 is appropriate.

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

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

The description '删除过孔' simply restates the tool name pcb_delete_via in Chinese. It conveys the action and object, but adds no differentiation from sibling tools such as pcb_delete_selected or pcb_delete_tracks.

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 provided on when to use this tool versus alternatives like pcb_delete_selected or pcb_delete_tracks. The only usage hint comes indirectly from the parameter name, so the context is implied rather than stated.

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

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

With no annotations, the description carries full burden. It discloses the main behavior (comparing and reporting) and implies read-only operation via 'report'. However, it does not explicitly state that no modifications are made, nor does it specify what happens if no snapshot exists or the exact nature of the report.

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 in Chinese, front-loaded with the core action and outcome. Every word adds value—no fluff or repetition 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?

The description explains the core function and lists the types of changes reported, but since there is no output schema, additional details about the report format or return value would be helpful. It also omits any prerequisites or error conditions, making it adequate but not fully complete for a simple 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 the baseline is 4. The description correctly avoids adding parameter details because there are none, and the empty input schema requires no further explanation.

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 compares the current design with the last snapshot and reports added, removed, or moved components. It uses specific verbs ('compare', 'report') and a specific resource context, distinguishing it from sibling tools like pcb_design_snapshot (which likely creates snapshots) and pcb_get_state.

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 usage for reviewing design changes since the last snapshot, but it does not explicitly state when to use this tool versus alternatives, nor does it mention prerequisites like the existence of a snapshot. 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.

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

No annotations are provided, so the description must convey safety side effects. It mentions 'one-click output' and lists checks, suggesting a read-only report operation, but it does not explicitly state that it makes no modifications to the design. Since there are no annotations, the description carries the full responsibility for behavioral clarity and only implies a non-mutating action.

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 immediately conveys the core purpose ('one-click design health report'), lists key checks, and ends with the rating scale. It is concise without being vacuously short, packing all essential information into one line.

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 zero parameters and no sibling context in the description, it's important to explain what the report includes and how to interpret it. The description does this well, listing the checks and the rating scale. It doesn't mention return format or side effects, but for a report aggregator with no inputs, this is reasonably complete.

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

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

The tool has zero parameterstons, so there is no parameter semantics to clarify. The description nonetheless adds value by explaining what the output encompasses, which is effectively the 'parameterless' contract. With no params to document, the baseline of 4 is justified.

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 produces a design health report, explicitly enumerates the checks included (BOM, connectivity, current carrying, DRC, clearance), and specifies the output rating scale (READY/NEEDS_WORK/POOR). This distinguishes it from sibling tools that perform individual checks (e.g., pcb_run_drc, pcb_bom_export), positioning it as an aggregator.

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 one-click comprehensive health check. It does not explicitly state which sibling tools to use instead of or in addition to this one, but the inclusion of multiple check types in the description implicitly advises using this aggregate tool for a quick overview. It lacks explicit 'use this instead of individual checks' guidance, but the intent is clear.

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. It discloses that a snapshot is saved, implying a persistent side effect, but does not mention whether prior snapshots are overwritten, how many can be stored, or whether the design is modified. For a zero-parameter tool, this is acceptable but not fully transparent.

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

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

A single, front-loaded sentence states the action and purpose with no 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?

Given zero parameters, no annotations, and no output schema, the description provides the essential context: what the tool does and why it matters (baseline for pcb_design_diff). Return behavior is not described, but for a simple snapshot tool this is a minor 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 zero parameters, so the schema fully covers everything. The description adds the key semantic context that the snapshot is meant as a baseline for pcb_design_diff, which is sufficient.

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: save a snapshot of the current design. It also names the downstream consumer (pcb_design_diff), which distinguishes this tool from the many other pcb_* 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 implies usage context: create a baseline before later comparisons via pcb_design_diff. It does not explicitly state when not to use it or name alternatives, but the baseline purpose is clear enough for an agent.

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 fully disclose behavioral traits. It mentions auto-fixing but does not state that it modifies the design, what exactly is changed beyond silk-screen conflicts, whether changes are reversible, or any side effects. The promise of a before/after comparison is vague about its format and safety implications.

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 that front-loads the core action (run DRC and auto-fix) and includes the current scope (silk-screen conflicts) and output (before/after comparison). It is concise with zero wasted words.

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

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

Given this is a mutation tool that can alter the design, the description is incomplete. It does not explain the format of the before/after comparison, whether the tool requires an open document, if it is idempotent, or what happens when other fixable issues exist beyond silk-screen conflicts. No output schema exists, so the description carries the load for expected results.

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 the schema trivially covers 100% of parameter semantics. Per scoring guidelines, baseline for 0 params is 4. The description adds no parameter info, but none is needed.

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 runs DRC and automatically fixes issues, specifically silk-screen conflicts, and returns a before/after comparison. It distinguishes itself from sibling tools like pcb_run_drc by the auto-fix behavior, making the purpose 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?

The description implies usage for automated DRC fixing but does not explicitly state when to use it versus alternatives like pcb_run_drc (for manual run) or pcb_move_silkscreen/auto_silkscreen (for targeted fixes). No when-not-to-use guidance is provided.

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

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

No annotations are provided, so the description carries the full burden. It does not explicitly state that the tool is read-only, and the output type is ambiguous due to the use of '或' (or) without clarifying conditions. It fails to disclose any side effects or dependencies.

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, but it packs multiple output types and input variants, making it slightly dense yet still front-loaded. No wasted words, but readability could be improved.

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 clarify what the response will include. It mentions file lists and JSON-lines statistics but doesn't explain how outputs vary or what the exact structure is. Error handling and return format are not specified, leaving agents uncertain.

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

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

The schema covers 100% of the parameter description, and the tool description does not add significant detail about the path parameter beyond what is already in the schema (directory vs file types). The baseline of 3 is appropriate.

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

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

The description clearly states the tool inspects .eprj3 projects and returns project index, schematic/PCB/panel file lists, or source file statistics. It uses a specific verb '检查' (inspect) and names the exact resource type, distinguishing it from sibling tools that operate on open documents or specific actions.

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 usage when project structure info is needed from a file path, but it does not explicitly state when to use this over other tools or mention any alternatives. No exclusions or edge cases are noted.

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

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

With no annotations provided, the description carries the full burden of disclosing behavior. It reveals that code runs in the extension environment and that 'eda' is the official API, but it omits crucial warnings about potential side effects, destructiveness, or permission requirements of executing arbitrary code. This is a significant gap for a code execution 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 two sentences plus an illustrative example, front-loading the purpose and providing necessary context. Every sentence contributes value with no redundancy or filler, and the example is compact yet informative.

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

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

The description covers the tool's purpose, execution environment, and provides an example, but it does not explain the output/return value format or warn about risks. Since there is no output schema, the description should clarify what the agent receives after execution, and it does not specify error behavior or that code may mutate state.

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 descriptions for both 'code' and 'windowId'. The description adds an example showing how to write a return statement, which provides practical semantic context beyond the schema's parameter descriptions. This extra example meaningfully helps the agent understand how to construct valid input.

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

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

The description clearly states the tool executes JavaScript code directly in the JLC EDA Pro environment, with a specific verb ('执行') and resource ('JavaScript 代码'). It distinguishes itself from all sibling tools by being a generic code executor rather than a specific operation, and it explicitly labels itself as advanced/debug.

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 mentions '高级/调试用' (advanced/debug use), providing clear context for when to use the tool. However, it does not explicitly state when not to use it or mention alternatives among the many sibling tools, leaving the guidance somewhat implicit.

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

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

No annotations are provided, so the description must carry behavioral transparency. It clearly states that fanout vias are created for all pads and that they belong to the same net, which is useful. However, it does not disclose side effects, constraints, reversibility, or what happens to existing traces/vias, leaving notable gaps for a mutation operation.

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

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

The description is a single, compact, front-loaded sentence that conveys the action, target, and net context without filler. Every word earns its place, making it appropriately concise for a one-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?

The description covers the core operation and target, which is adequate for a simple one-parameter tool with no output schema and strong sibling context. Yet it omits potential side effects, success/failure signals, and explicit differentiation from pcb_auto_fanout_and_route, leaving the context only minimally complete for an agent.

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 parameter 'designator' is already described in the schema as '元件位号，如 U1'. The tool description only references '指定元件' without adding extra meaning beyond the schema, so it meets the baseline but does not enrich parameter 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 ('创建扇出过孔' / create fanout vias) targeting a specific resource ('指定元件的所有焊盘' / all pads of the specified component). The added '（同一网络）' clarifies the net relationship, and the component-level scope distinguishes it from broader tools like pcb_auto_fanout_and_route.

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

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

The description clearly implies component-scoped fanout usage by emphasizing '为指定元件' (for the specified component). However, it does not explicitly compare with alternatives like pcb_auto_fanout_and_route or state when this tool should not be used, so it stops short of full usage 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?

No annotations are provided, so the description carries the full burden of behavioral disclosure. It only restates the purpose and gives output examples; it does not disclose whether the tool is read-only, requires an open PCB document, or what error behavior to expect. The 'get' wording implies read-only, but the description does not explicitly confirm this.

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 communicates the action and two representative output fields in minimal space, and every part contributes to understanding the tool's purpose.

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 simple getter, the description is acceptable but has gaps: it does not specify that a PCB document must be open, does not list the full return shape, and relies on '等' to cover unlisted outputs. Since there is no output schema and no annotations, these omissions leave some important context to inference.

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 and the input schema is empty, so there is no parameter semantics for the description to clarify. The baseline of 4 applies because no parameter information is needed; the description focuses on the output content instead.

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 action ('获取工程信息' — get engineering information) and gives concrete examples of the resource scope ('板名、层数等' — board name, layer count, etc.). It is specific enough to distinguish from sibling tools like pcb_get_state, though it does not explicitly name the sibling it differs from.

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

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

The description provides no guidance on when to use this tool versus alternatives. There are many sibling tools with potentially overlapping scopes (e.g., pcb_get_state), but no mention of when this one is preferred or when another should be used instead.

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 behavioral burden. '查询' signals a read-only query operation, but the description does not disclose return format, side-effect profile, or other behavioral details beyond what the name already implies.

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 redundant information. It conveys the essential purpose 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?

Given the low complexity (zero parameters, no nested objects, no output schema), the description is mostly complete for selecting and invoking the tool. It could be improved by noting the format of the returned feature list, but this is a minor 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 zero parameters, and the schema already fully covers parameter requirements. There is nothing for the description to add, so the baseline score of 4 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 clear action ('查询' / query) and a specific resource ('bridge 支持的功能列表' / feature list supported by bridge). This distinguishes it from sibling tools like pcb_get_state or pcb_ping, although the term 'bridge' is not explicitly defined.

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: an agent would call this to discover which features the bridge supports. However, there is no explicit when-to-use guidance or mention of alternatives. The implied context is enough for a zero-parameter introspection tool but not explicitly 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?

There are no annotations, so the description carries the full burden. 'Query' implies a read-only operation, but the description does not disclose the return shape, whether all primitive types are included, or what happens for an unknown or empty net.

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 word contributes to stating 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 single-parameter query this is minimally viable: an agent knows what to supply and what kind of data comes back ('all primitives'). However, there is no output schema or description of the return format, so the agent cannot predict the response structure or error behavior.

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

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

Schema coverage is 100%: the only parameter 'net' is already documented as '网络名称' (net name). The description only restates this by referring to the 'specified net' and adds no format, validation, or default information.

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 ('query') and a precise resource ('all primitives of the specified net'), making the operation unambiguous. This distinguishes it from sibling getters like pcb_get_tracks and pcb_get_pads, which filter by primitive type rather than by 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?

No guidance is given on when to choose this tool instead of related retrieval tools such as pcb_get_tracks, pcb_get_pads, or pcb_get_silkscreens. The agent must infer the appropriate context from the tool name alone.

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 behavioral burden. '查询' (query) reasonably implies a read-only operation with no side effects, but the description does not disclose return shape, filtering semantics, or any state requirements, leaving some ambiguity.

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 extremely concise with no filler words, and the core action is front-loaded. It is efficient, though perhaps too terse to fully compensate for the lack of annotations and output 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?

For a simple tool with one optional parameter and no output schema, the description names the returned concept (pad information) but does not say whether designator filters results, whether a list or single item is returned, or whether an open document is required. It is minimally 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?

The input schema already describes the only parameter with 100% coverage ('元件位号（可选）'). The description adds no additional meaning beyond the schema, so the baseline of 3 is appropriate.

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

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

The description states a clear verb-resource pair: 查询 (query) 焊盘信息 (pad information). It is clear about what the tool does, though it does not explicitly distinguish itself from siblings like pcb_get_tracks or pcb_get_net_primitives.

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 alternative getters, no mention of the optional designator filtering behavior, and no prerequisites or context for invocation. The agent must infer usage entirely from the name and schema.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure, but it only says 'query all silkscreen text'. It does not describe what data is returned, whether coordinates or text strings are included, or whether an open board context is required.

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 with no filler, stating the action and the target resource directly. It is appropriately sized for a simple parameterless query 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?

The description is minimally sufficient for a zero-parameter read tool, but it lacks detail about the expected return contents and any operational context such as requiring an open PCB document. Since there is no output schema, a bit more description would make the tool easier to use 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 input schema has zero parameters, so there are no parameter semantics that the description needs to clarify. The baseline for a zero-parameter tool is 4, and no additional parameter-specific information is required.

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

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

The description states a clear action, '查询' (query), and a clear resource, '所有丝印文字' (all silkscreen text). It is understandable on its own, though it does not explicitly differentiate it from sibling silkscreen-related tools such as pcb_move_silkscreen or pcb_auto_silkscreen.

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 about when to use this tool versus related tools, nor any mention of prerequisites such as an open PCB document. An agent must infer usage entirely from the tool name and the brief 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?

No annotations are provided, so the description carries the full burden. It implies a read operation and mentions scope ('complete state'), but it does not disclose return format, potential size/cost, side effects, or how the state is structured.

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 compact sentence with the key information front-loaded and a short parenthetical list of examples. No filler or redundant phrasing.

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 parameterless getter, the description is minimally viable: it names the resource and gives examples of contents. However, with no output schema and no return-shape details, an agent can only guess at what fields will be 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?

There are zero parameters, so the 0-parameter baseline of 4 applies. The description does not need to explain 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?

The description states a specific verb ('获取'/'get'), a clear resource ('PCB 完整状态'/'PCB complete state'), and gives concrete inclusions (components, nets, board outline). This helps distinguish it from sch_get_state and narrower getters such as pcb_get_tracks or pcb_get_pads, though it does not explicitly contrast them.

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 call this tool versus sibling getters like pcb_get_board_info, pcb_get_tracks, or pcb_get_pads. The description defines what it returns but not when it should be preferred.

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 only says 'query' and does not explain whether the tool returns segments, selects them, what properties are included, how filters behave, or whether there are any side effects. The query wording implies a read operation, but this is not explicit enough.

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 very short and front-loaded, containing no filler or redundant phrasing. It is concise to the point of being sparse, but as far as structure and economy of language go, it is effective.

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-oriented tool with no annotations and no output schema, the description is too minimal to give an agent a complete picture. It does not describe return format, units, coordinate system, filtering semantics, or what differentiates this tool from other PCB query tools. The agent would need to rely on trial and error.

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%, with both optional parameters ('net' and 'layer') documented in the schema. The tool description itself adds no parameter-level meaning, but because the schema already explains the parameters, the baseline of 3 is appropriate.

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

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

The description states a clear verb ('查询' / query) and a specific resource ('走线段' / track segments), and the optional filters are suggested by the schema. However, it does not explicitly differentiate this tool from sibling retrieval tools like pcb_get_net_primitives or pcb_get_pads, so it stops short of a perfect score.

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 instead of alternatives such as pcb_get_net_primitives, pcb_get_pads, or pcb_delete_tracks. The description only states what the tool does, without any context, prerequisites, or 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?

With no annotations, the description must carry behavioral weight, and the word 'list' does convey a read-only, non-mutating operation. Still, it does not describe the return format, ordering, or any dependence on board state or open document, so some behavioral aspects are left unspecified.

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 that front-loads the operation and resource with no filler or redundancy. For a zero-parameter list tool, this is appropriately concise and well-structured.

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

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

For a simple zero-parameter list operation, the description is mostly sufficient, but there is no output schema and the description does not say what the returned differential-pair data contains or how it is structured. This is a minor gap given the tool's simplicity, but it prevents full completeness.

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 and schema description coverage is effectively 100%, so there are no parameter semantics for the description to clarify. Per the baseline for no-parameter tools, the description is adequately silent.

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 clear verb ('列出' / list) and specifies the exact resource ('所有差分对' / all differential pairs), making the operation unambiguous. However, it does not explicitly contrast with sibling tools such as pcb_create_diff_pair or pcb_list_equal_lengths, so differentiation is implicit rather than stated.

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 'list all differential pairs' implies the tool should be used when a read-only enumeration of differential pairs is needed. However, it gives no explicit when-to-use or when-not-to-use guidance and does not mention alternatives 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?

There are no annotations, so the description carries the transparency burden. It clearly states the tool is read-only in intent by listing windows and their active status, which covers the core behavioral context. However, it does not clarify what values 'activity status' may take or whether the list may be 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?

One short Chinese sentence conveys the action, resource, and output scope with no filler. This is highly concise and front-loaded.

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

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

This is a simple, zero-parameter listing tool, so the description is close to sufficient. However, there is no output schema, and the description does not state the exact return format or explain how the returned data would be consumed by related tools like pcb_select_eda_window.

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 no parameter ambiguity. The description correctly communicates the only meaningful thing needed: the tool's scope is all connected EDA windows, not any specific one.

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 a specific resource ('所有已连接嘉立创EDA窗口') with a clear scope ('活动状态' / active status). It clearly distinguishes this tool from siblings like pcb_select_eda_window, which selects a window.

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 that this tool is used for inspecting connected EDA windows before interacting with them, but it does not explicitly say when to prefer it or when not to use it. Given the sibling pcb_select_eda_window, a brief 'use this before selecting a window' would improve 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?

No annotations are provided, so the description carries the full burden of behavioral disclosure. '列出' implies a read-only listing, but the description does not explain the return format, scope, or what constitutes an equal-length group. Transparency is minimal.

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, direct sentence with no filler or redundancy. It is appropriately sized for a zero-argument list 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?

For a zero-parameter list operation, this is minimally viable: it names the action and resource. However, with no output schema and no annotations, it does not describe the returned structure or the exact scope of '等长组', leaving some 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?

There are zero parameters and the schema is empty, so the 0-parameter baseline of 4 applies. No parameter clarification is needed because none exist.

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 a clear resource '所有等长组' (all equal-length groups), which distinguishes it from sibling create/delete equal-length tools and from pcb_list_diff_pairs. The action and target are 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?

No guidance is given for when to use this tool versus alternatives. It does not state prerequisites such as an open PCB document, nor does it contrast with pcb_list_diff_pairs or other list operations. Usage context is only implied by the name.

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 correctly implies a mutating action ('move') and includes the unit 'mil', but does not disclose whether a document must be open, whether the change is reversible, what happens on an invalid designator, or what the tool 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 a single front-loaded sentence with no filler. It states the action, target, and unit efficiently, earning its place despite being minimal.

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 minimum-viable description for a simple move operation: the action is clear and the schema covers all parameters. However, with no annotations and no output schema, it lacks details about prerequisites, coordinate system origin, or expected response, leaving meaningful gaps for an agent.

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 designator, x, y, and rotation. The top-level description adds only 'mil' and 'specified coordinates', which adds minimal value beyond the parameter descriptions. This matches the baseline for high schema coverage.

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

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

The description states a specific action ('move'), a resource ('component'), and a target ('specified coordinates'), so an agent can understand the core function. However, it does not distinguish this tool from the similarly named sibling 'pcb_relocate_component', so it cannot fully clarify which one to choose.

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

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

The description provides no guidance on when to use this tool versus alternatives such as pcb_batch_move, pcb_relocate_component, or pcb_move_silkscreen. It does not mention exclusions, prerequisites, or typical contexts, leaving the agent to infer usage from the tool name alone.

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 merely restates the tool name in Chinese and does not disclose coordinate semantics (absolute vs. relative), whether the move affects only the specified primitive, reversibility, or failure 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 very short and contains no filler, but it is under-specified and essentially duplicates the tool name. It lacks the structure needed to convey any context beyond the basic action and object.

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 state-changing tool with no annotations and no output schema, this one-line description is insufficient. It omits whether x/y are new absolute positions or deltas, what rotation means in this context, and any error or edge-case behavior, leaving an agent without enough information for confident 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 100%, so the schema already documents primitiveId, x, y, and rotation. The description adds no parameter-level meaning, but the baseline of 3 is appropriate because the schema carries the parameter information.

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 '移动丝印文字' ('move silkscreen text') states a specific verb and resource, clearly identifying this as the tool that relocates silkscreen text rather than components or tracks. It does not explicitly differentiate from siblings like pcb_move_component or pcb_batch_move, so it falls just 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?

There is no guidance on when to use this tool versus alternatives such as pcb_batch_move or pcb_auto_silkscreen. The phrase only implies a generic use case and provides no exclusions, prerequisites, or 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?

No annotations are provided, so the description must disclose side effects and return behavior. It says it 'checks' and 'marks' nets, but does not state whether it modifies the board, what the output format is, or if it is read-only. The behavior is only partially clear.

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, information-dense sentence that front-loads the main purpose and adds brief parenthetical details. Every word contributes to clarity without 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, the description should clarify what the tool returns. It mentions pad counts and track segment counts and marking unrouted nets, but does not specify the return format (e.g., a report, a list, a boolean). The tool's simplicity is offset by this ambiguity, leaving the agent uncertain about how to interpret results.

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 sole parameter 'nets' is described in the schema as '指定检查的网络（默认全部）' (specify nets to check, default all), which already provides full semantic coverage. The description adds no extra beyond this, so it meets the baseline for high schema coverage.

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

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

The description clearly states the tool checks connectivity of all nets, and elaborates with specific outputs (pad count, track segment count, marking unrouted nets). This is a specific verb-resource combination that differentiates it from sibling tools like pcb_run_drc or pcb_component_clearance_check, which address different checks.

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 provided on when to use this tool versus alternatives. It does not mention typical scenarios, prerequisites, or exclusions. The description simply states what it does, leaving usage context implicit.

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, and the description only says it generates a report. It does not explicitly state that it is read-only, whether it modifies any PCB data, or what the output format looks like. For an unannotated tool, this leaves behavioral expectations unclear.

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 efficiently conveys the purpose and scope without redundant words. Every word contributes to understanding, and it avoids unnecessary length.

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 read-only report tool with no parameters, the description covers the core functionality but lacks specifics about the report's output format, structure, or usage context. Without an output schema, the agent must infer what the report returns. The description could be more complete by stating the expected output type or typical use cases.

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?

This tool has zero parameters, so the baseline of 4 is appropriate. The description's mention of 'from PCB pad data' implies the source input, though no further parameter details are needed. It adds meaning beyond the empty schema by explaining the data source.

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 'generate' and the resource 'netlist report from PCB pad data', specifying the direction (component→pin→net and net→component). This distinguishes it from sibling report tools like pcb_bom_export or pcb_design_health_report by focusing on netlist content.

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

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

The description provides no guidance on when to use this tool versus alternatives such as sch_get_netlist or pcb_get_net_primitives. It fails to mention prerequisites, use cases, or exclusions, which is essential for a reporting tool among many.

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 only says 'switch to' a document and does not disclose whether the document must already be open, whether this changes the active document or opens a file from disk, what happens for an invalid UUID, or whether the operation has any side effects on subsequent commands.

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 filler or repetition of the tool name. It is appropriately front-loaded, although the brevity comes at the cost of missing usage 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?

For a simple one-parameter utility, the core invocation is captured: the UUID identifies a document and the action is to switch to it. However, with no annotations and no output schema, operational context such as prerequisites, failure behavior, and how to confirm the active document has changed is absent.

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 already describes the only parameter as a document UUID at 100% coverage, so the description does not need to repeat it. It adds marginal semantic value by clarifying that the UUID refers to either a schematic or PCB document, but it provides no extra format or 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 specific verb and resource: '切换' (switch) to a specified document, and it clarifies that the document can be a schematic or PCB. This is clear enough to identify the operation, though it does not explicitly differentiate itself from sibling tools by naming an alternative.

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

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

The description provides no guidance about when to call this tool versus alternatives, nor does it mention prerequisites such as the document already being open in the session. It does not state that this should be used before PCB/schematic editing commands, even though that is likely the intended pattern.

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 present, so the description must carry the full behavioral burden. It discloses that the tool performs a status check, but it does not say what response to expect, whether the call is purely read-only, or how failures are signaled. This is a meaningful gap for a tool with no output 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?

The description is a single front-loaded phrase that names the action and the target with no filler or repetition. It is appropriately sized for a parameterless health-check tool, though it could have added a bit more 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?

For a simple zero-parameter ping tool, the description is nearly sufficient: an agent can identify and invoke it without constructing arguments. However, 'bridge' is left somewhat ambiguous and the expected result/return value is not described, so the description is not fully self-sufficient in the absence of an output 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?

The tool has zero parameters and 100% schema description coverage, so the schema already exhaustively documents the inputs. The description adds no parameter details, and none are needed; for a zero-parameter tool the baseline score of 4 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 uses a specific verb ('检查' / check) and a specific target ('bridge 连接状态' / bridge connection status), so an agent can tell this is a bridge connectivity health check rather than a design-editing operation. It does not explicitly contrast with sibling tools, but none of the siblings cover bridge status, so the purpose is distinct enough.

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: call this tool when you need to verify whether the bridge connection is alive, as 'ping' in the tool name also suggests. There is no explicit guidance on when not to use it or what alternative to prefer, but no sibling appears to be a direct alternative.

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

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

With no annotations, the description carries the behavioral disclosure burden. It does reveal a significant non-obvious side effect: the operation automatically disconnects traces. However, it does not explain what happens to the disconnected tracks, whether the action is reversible, or what 'safe' precisely guarantees.

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 phrase that states the purpose and key behavior without filler. It is efficiently sized, though it sacrifices important usage context for brevity.

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 four-parameter relocation tool with full schema coverage, the description covers the core purpose and a key side effect. But with no annotations and no output schema, the lack of usage guidance and ambiguous post-move routing behavior leaves notable gaps for an agent deciding whether to invoke 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?

Schema description coverage is 100%, as x, y, rotation, and designator all have individual descriptions. The tool description adds no extra parameter-level meaning, so the baseline of 3 is appropriate.

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

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

The description states a clear verb and resource: 'safe relocate component' with a key behavioral qualifier 'auto-disconnect traces'. It conveys what the tool does, though it does not explicitly differentiate it from the overlapping sibling tool pcb_move_component.

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 such as pcb_move_component or pcb_batch_move. The phrasing implies use when a safe relocation with automatic trace disconnection is desired, but that 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?

With no annotations, the description carries the full burden. It discloses the routing style (parallel L-shaped, negative net offset by gap) and that it reports length deviation. However, it does not state whether existing traces are removed/replaced, which objects are mutated, or how the deviation report is delivered.

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, front-loaded with the core action and containing the method and report behavior. Every phrase earns its place with 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?

For a mutating 4-parameter tool with no annotations and no output schema, the description covers the core routing behavior but leaves gaps: no return-value format, no side effects, no mention that pairName defaults to all pairs, and no preconditions. It is adequate but 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 coverage is 100% with defaults for all four parameters, so the baseline is 3. The description adds context for gap as an offset between nets, but this largely restates the schema's '正负线间距' and adds no new parameter-specific syntax or format 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 clearly identifies the tool's specific verb+resource: differential pair auto-routing, with the routing method (parallel L-shaped traces, negative net offset by gap) and a distinct output (reports length deviation). This differentiates it from siblings like pcb_route_track, pcb_auto_route_nets, and pcb_create_equal_length.

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 provided on when to use this tool versus alternatives. It does not mention prerequisites such as existing differential pairs, nor does it contrast with pcb_auto_route_nets, pcb_create_diff_pair, or pcb_create_equal_length. The only signal is the tool name and implied 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?

No annotations are provided, so the description carries the full burden of behavioral disclosure, but it only says 'draw a track.' It does not explain whether existing tracks are overwritten, whether design rules are checked, whether a document must be open, or what the tool returns after execution.

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?

At three characters, the description is extremely concise and has no filler, but it is under-specified rather than appropriately sized for a tool with four required parameters. The single phrase lacks useful structure and does not earn its place as a standalone definition.

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

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

With no output schema, no annotations, and a nested points array among four required parameters, an agent needs more context about what happens when the tool runs and how results are reported. The description is incomplete and leaves almost all behavioral context to the schema and 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?

Schema description coverage is 100%, and each parameter (net, layer, width, points) has a basic descriptive comment. The description text adds no parameter-specific meaning beyond what the schema already provides, so the baseline score 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 '画走线' clearly identifies a drawing/routing operation on a PCB track, so an agent can infer the primary resource and action. However, it does not differentiate this tool from sibling track-related tools such as pcb_create_via or pcb_delete_tracks, though it is not a tautology.

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

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

The description provides no guidance on when to use this tool versus alternatives like pcb_create_via, pcb_create_diff_pair, or pcb_delete_tracks. No prerequisites, exclusions, or contextual selection cues 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?

No annotations are provided, so the description carries full burden for behavioral disclosure. It only states the operation and does not reveal whether DRC modifies the design, what results are returned, whether it is asynchronous, or any side effects. It is not misleading but is minimal.

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, focused sentence that immediately conveys the tool's purpose with no filler or redundant 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?

For a simple no-parameter tool, the description is minimally adequate, but it does not explain the output or return format, and there is no output schema to fill that gap. It also omits potential side effects, though the operation appears to be a check.

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 are zero parameters, and the input schema is empty. The description has no parameter-explanation burden, so the 0-parameter baseline of 4 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, '运行 PCB 设计规则检查 (DRC)', states a specific verb ('run') and resource ('PCB design rule check'), expanding the acronym. The explicit 'PCB' clearly distinguishes it from the sibling sch_run_drc and other PCB operations.

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 'PCB' prefix and the DRC operation, but the description gives no explicit when-to-use guidance, prerequisites, or mention of the schematic alternative sch_run_drc. There are no exclusions or contrasting sibling references.

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 bears the full burden of behavioral disclosure. It states the action but does not disclose what the tool returns (e.g., image path, base64 data, or rendered artifact), whether it opens a UI, or whether any state is affected. This is a meaningful gap for a tool whose output is not schema-defined.

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 redundant phrasing. For a parameterless tool, this level of brevity is appropriate and 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?

Given the tool has no parameters and no output schema, the description is nearly sufficient for selecting and invoking it. However, it does not explain the result format or side effects, which are important for an agent that must consume the screenshot afterward. The missing output semantics keep 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?

The tool has zero parameters and the schema fully documents this with an empty properties object. There is no parameter ambiguity for an agent to resolve, and the description adds the only relevant semantic information: the operation targets the current PCB editor.

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 ('截取', capture) and a clear resource ('当前 PCB 编辑器截图', current PCB editor screenshot). It clearly identifies the tool's function and is distinct from all sibling tools, which perform editing, routing, or inspection operations rather than screen capture.

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

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

The description provides no guidance on when to use this tool, what situation it is designed for, or how it relates to alternatives. There is no implied context beyond the literal action, so an agent receives no help in deciding between this and other PCB 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?

With no annotations provided, the description carries the full burden of explaining behavior. 'Select a component in the editor' reveals the action but not side effects such as clearing previous selection, focusing/zooming the view, whether an open document is required, or what happens if the designator is not found. These are significant unknowns for a UI-state-mutating operation.

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

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

The description is a single, front-loaded sentence with no filler. It directly states the action and resource, and it is appropriately sized for a simple one-parameter tool. 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?

The combination of description and schema is minimally sufficient to invoke the tool with a designator, but missing behavioral context leaves gaps: no return value indication, no statement about side effects, and no mention of prerequisites like an open PCB document. This is adequate but not complete, especially given that no annotations or output schema exist to fill those 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 100%, so the designator parameter is already documented as '元件位号' (component designator). The description adds little about the parameter beyond implying that the selected entity is a component, but per the rubric the baseline of 3 applies when the schema fully covers parameter 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 clearly states a specific action ('select') and resource ('component in the editor'). It is not a tautology and is understandable, but it does not explicitly mention selecting by designator or differentiate itself from sibling tools, though the verb 'select' helps separate it from move/create/delete operations.

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 provided for when to use this tool versus alternatives. It does not mention preconditions, exclusions, or scenarios where another sibling tool such as pcb_move_component or pcb_create_component would be more appropriate. The only implied usage is 'when you want to select', which is tautological.

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 full burden for behavioral disclosure. It only says 'select' but does not explain what that entails—e.g., whether it changes the active window, affects subsequent commands, if it is reversible, or any prerequisites. This is a significant gap for a tool that sets execution 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, concise sentence that directly conveys the purpose and usage context. There is no redundant or filler content, making it highly 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 the simplicity of the tool (one parameter, no output schema), the basic purpose is covered, but the lack of behavioral details (e.g., how selection affects subsequent operations) leaves gaps. With no annotations, the description should disclose more to be fully complete, but it is minimally adequate.

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 already provides full description coverage for the only parameter windowId, including its provenance from pcb_list_eda_windows. The description adds no further semantic meaning to the parameter, so a baseline score of 3 is appropriate.

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

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

The description clearly states the verb 'select' and the resource 'currently active JLC EDA window', and specifies the purpose of designating an execution target when multiple windows are open. It distinguishes from the sibling pcb_list_eda_windows which lists windows, making the purpose 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?

The description provides a clear context: use when multiple EDA windows are open to specify the execution target. It implies when to use but does not explicitly mention when not to use or provide alternative tools, but the context is clear enough for an agent.

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

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

No annotations are provided, so the description must carry the full burden. It mentions the underlying method (setNetlist) and supported formats, adding some context about behavior, but does not disclose side effects (e.g., whether it overwrites existing schematic, requires a specific document to be open, or has restrictions on netlist size). The mention of 'official' hints at reliability but is insufficient for full transparency.

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 brief and front-loaded with the main purpose, followed by a short list of formats. It is efficient, but the format list is a bit cryptic (e.g., 'DISA/DSNET') without explanation, which could be seen as slightly wasteful for users unfamiliar with those terms. Otherwise, it is concise and well-structured.

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

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

With no output schema and minimal annotations, the description should ideally explain what the tool returns (e.g., success indication, generated schematic). It also lacks prerequisites (e.g., must have a schematic open) or error conditions. The description is adequate for a simple import tool but misses key context for an agent to fully anticipate the outcome.

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

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

Schema coverage is 100%, describing both parameters, so the baseline is 3. The description adds format context for the 'type' parameter (lists formats) but does not add semantics for 'netlist' beyond what the schema's example already shows. No additional format syntax or validation details are provided, so it does not exceed the baseline.

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 (import netlist to generate schematic) with a specific resource (sch_Netlist.setNetlist) and lists supported formats, distinguishing it from siblings like sch_get_netlist and sch_generate_from_pcb.

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 usage for netlist-based schematic generation and lists formats, but does not explicitly state when to use this versus alternatives like sch_generate_from_pcb or when not to use it (e.g., for PCB generation). It lacks explicit exclusions or alternative pointers.

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 behavior. It lists a sequence of actions (read, convert, import, generate) but does not say whether it modifies the existing schematic, overwrites files, or requires specific permissions. It also does not mention potential side effects or errors. The transparency is minimal beyond the bare steps.

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 that front-loads 'one-click' and outlines a clear sequence with arrows. Every word is functional, and the structure conveys the workflow efficiently. There is no unnecessary text.

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

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

The tool performs a multi-step generation task but lacks explanation of the tool's output or return value (no output schema). It also does not specify prerequisites like having a current PCB with a netlist report or whether the schematic is created new or modified. For a moderately complex operation, the description is 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?

The input schema has one parameter 'type' with a description ('网表格式（默认 Protel2）') that is fully covered. The tool description itself does not add extra meaning to this parameter; it only mentions the default conversion to Protel2. Since schema coverage is 100%, the baseline is 3, and the description does not enhance it further.

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 the current PCB netlist report, converts it to Protel2 format, and imports it into the schematic to generate something. It implies the output is a schematic generated from the PCB, which distinguishes it from simple netlist import tools. However, the exact output (e.g., a new schematic file, an update) is not explicitly stated, and it could be confused with sch_generate_from_netlist without clear 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?

The description gives no guidance on when to use this tool versus alternatives like sch_generate_from_netlist or pcb_netlist_report. It does not mention prerequisites (e.g., an open PCB document, existing netlist) or exclusions. The intended context is only implied by the steps described.

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 for behavioral disclosure, but it only says 'export netlist.' It does not state whether the tool returns the netlist content, writes a file, has side effects, or requires an open schematic, leaving important behavior undocumented.

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 has no filler and is front-loaded, but it is a single terse phrase with no elaboration. It is under-specified rather than appropriately concise, similar to a placeholder-level description.

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, no output schema, and an optional format parameter, the description leaves critical context missing: valid values for 'type', default behavior, return format, and whether any schematic state is required. An agent would have to guess or call the tool blindly.

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's description of 'type' as '网表格式' (netlist format) gives basic meaning to the only parameter, and schema coverage is 100%, so the baseline is 3. The tool description adds no extra parameter guidance, such as accepted format values or what happens when the optional parameter is omitted.

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 and object: '导出网表' (export netlist), which clearly identifies the tool's function. It does not explicitly distinguish itself from sibling tools, but no sibling performs netlist export, so 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 guidance on when to use this tool versus alternatives, no prerequisites, and no mention of whether it should be run after schematic editing or before PCB layout. The agent must infer usage entirely from the tool name and terse 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?

With no annotations, the description carries the behavioral burden. It does convey that this is a read-only operation through '读取', but it does not disclose what the returned state actually contains, whether an open schematic is required, or any error behaviors.

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 extremely short and front-loaded, but the brevity borders on under-specification because '状态' is ambiguous. For a zero-parameter tool, this level of concision is acceptable, though not exemplary.

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

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

Even with no parameters, the lack of an output schema and the vague term 'state' leave the agent without a clear expectation of the return value or how this tool fits into a broader workflow. A brief sentence naming the state fields or return type would make it complete.

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

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

The input schema has zero parameters, so the 0-parameter baseline of 4 applies. There is no parameter meaning 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 uses a clear verb ('读取' / read) and identifies the resource as '原理图状态' (schematic state), which distinguishes it from PCB-state and netlist tools. However, 'state' remains somewhat broad and the description largely restates the tool name.

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 provided on when to use this tool versus alternatives such as pcb_get_state or sch_get_netlist. There are no conditions, exclusions, or workflow hints.

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 only says 'run schematic DRC' and provides no insight into whether the operation is read-only, what checks are performed, how results are returned, or how strict mode affects behavior. This is a significant transparency gap for a tool with no annotation support.

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 phrase with no filler or repetition. It front-loads the core action, though its brevity leaves behavioral details to other dimensions; that is a completeness issue, not a conciseness flaw.

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 minimally viable: an agent can infer the operation and see the strict parameter in the schema. However, with no output schema and no annotations, it lacks any indication of return format, side effects, or what strict mode actually changes, leaving useful 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?

The schema already documents the only parameter strict with the description '是否严格模式' (whether strict mode). The tool description adds no additional parameter-level meaning, but since schema description coverage is 100%, the baseline of 3 is appropriate.

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

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

The description states a specific action ('运行原理图 DRC' = run schematic DRC) on a clear resource, and the 'schematic' qualifier distinguishes it from the sibling pcb_run_drc. The name is expanded into an unambiguous, human-readable operation.

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 usage: run DRC against a schematic rather than a PCB, especially given the sibling pcb_run_drc. However, it does not explicitly state when to choose this tool over alternatives or mention any prerequisites such as having an open schematic document.

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