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

Annotations already declare readOnlyHint=true and idempotentHint=true, so the safety profile is covered. The description adds that it inspects the 'live' runtime rather than static docs, which is mildly useful, but says nothing about cost, pagination, or what 'documented' excludes.

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

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

One sentence, front-loaded with the action and resource, no filler. It is arguably too terse rather than too long, but structurally clean.

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

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

An output schema exists so return values need no explanation, but the undocumented 'filter' parameter and the absence of any tie-breaker against seven other introspection-style siblings leave the definition not quite complete for correct invocation.

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

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

The single 'filter' parameter has 0% schema description coverage, and the description never mentions it or explains its syntax (substring? glob? class-name match?). With a real parameter present and no schema help, the description should compensate but does not.

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

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

States a specific verb (list/inspect) and a distinct resource (documented API classes, runtime paths, methods) in the live EasyEDA extension runtime. This is clearly separable from siblings like easyeda_get_capabilities or easyeda_get_feature_flags, though the description never names those siblings to reinforce the boundary.

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

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

No indication of when to use this versus easyeda_get_capabilities, easyeda_get_tool_profiles, or the other introspection siblings. The agent is left to infer the distinction from the resource noun 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?

Annotations already declare readOnlyHint=true and idempotentHint=true, so the safety profile is covered. The description adds the useful scope of returned content (dimensions, shape, mounting holes) but says nothing about units, coordinate systems, or behavior when a board outline is undefined. With annotations carrying the safety burden, this is adequate but thin.

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 efficient sentence with the resource front-loaded and no wasted words. It is appropriately sized for a simple read tool, though it is arguably too terse to cover the parameter.

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

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

An output schema exists, so return values need not be explained, and annotations cover the read-only safety profile. However, for a tool whose only input is an undocumented projectId, the description leaves the caller without guidance on the identifier, keeping it at minimum-viable 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 schema has one required parameter (projectId) with 0% description coverage, and the description never mentions it or clarifies what form the project identifier takes. Contrasted with the zero-parameter baseline of 4, a single undocumented required param that the description ignores is a real gap.

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

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

The description states a specific verb (Get) and resource (PCB board outline dimensions, shape, mounting hole info), which is clearly distinct from sibling read tools like board_layers, board_stackup, and board_features. It is clear but never explicitly names or contrasts a sibling, so it falls short of a 5.

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

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

There is no indication of when to use this tool versus alternatives such as easyeda_board_features or easyeda_pcb_components, no prerequisites, and no exclusions. The agent must infer its place from the 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?

Annotations already declare readOnlyHint=true and idempotentHint=true, so safety is covered. The description adds real semantic disclosure beyond that: it defines what 'zones' counts (copper Pour boundaries only) versus native Fill and Region primitives, which prevents misreading the counts. It does not discuss cost, limits, or scope beyond 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?

Two tight sentences, front-loaded with the core action and followed by the disambiguating semantics. No filler or restatement of the title.

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

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

An output schema exists, so return formatting needn't be explained, and the description supplies the one piece of non-obvious context an agent needs — the zones/fills/regions distinction. For a single-parameter read tool this is close to complete.

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

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

Schema description coverage is 0% and the single required parameter (projectId) is never mentioned in the description. However, with only one obvious identifier parameter, the description's silence is a minor gap rather than a serious one, so it sits at the baseline for a simple 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?

States a specific verb and resource: 'Get counts of board features.' The second sentence sharpens what is being counted (zones = copper Pour boundaries only) and distinguishes those from fills and regions, which map to sibling tools easyeda_pcb_fills and easyeda_pcb_regions. It is clear, though it doesn't name those siblings explicitly.

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

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

Usage is implied — this is a summary/counting tool — and the note that fills and regions are reported separately hints at when to use this versus the dedicated fill/region tools. There is no explicit when-to-use or when-not-to-use statement, and no prerequisites are given.

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

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

Annotations already declare readOnlyHint=true and idempotentHint=true, so the safety profile is covered. The description adds useful context by naming the kinds of layers returned, but says nothing about scoping, permissions, or what an empty/partial layer list would mean.

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

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

One sentence, front-loaded with the verb and resource, with the enumeration of layer types packed in at the end. Nothing wasted.

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

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

An output schema exists, so return values need not be described, and annotations cover safety. For a simple read-only list tool the description is nearly sufficient, missing only the projectId linkage and a disambiguation from board_stackup.

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

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

Schema description coverage is 0% and the description never mentions projectId or any parameter. The single required parameter name is self-explanatory, but with zero coverage the description is expected to compensate and does not do so.

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

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

States a specific verb (List) and resource (PCB layers) and enumerates the layer categories returned (signal, power, plane, mechanical). It does not, however, distinguish itself from the nearby easyeda_board_stackup sibling, which an agent could easily confuse with this one.

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

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

No when-to-use guidance, no prerequisites, and no pointer to alternatives such as easyeda_board_stackup for stackup-specific questions. The agent is left to infer the tool's place in the PCB inspection family.

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

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

Annotations already declare readOnlyHint=true and idempotentHint=true, so the safety profile is covered. The description adds the payload contents (thickness, material, dielectric constants), a small but genuine addition; it says nothing about scoping 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?

One compact sentence, front-loaded with the verb and resource, with no filler. Efficient, though it could have spent a clause on the projectId requirement.

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

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

An output schema exists, so return values need not be spelled out, and the annotations cover the read-only nature. However, the required projectId is left completely unexplained, which for a one-parameter tool is the main thing an agent needs in order to call it correctly.

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

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

Schema description coverage is 0%: projectId is typed only as a plain string with no description, and the tool description never explains what projectId refers to, its format, or how to obtain it. For the sole required parameter this is a real gap the description should have closed.

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

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

States a specific verb (Get) and resource (PCB layer stackup) and enumerates the returned content (thickness, material, dielectric constants), which separates it from the nearby easyeda_board_layers sibling. It is clear but never explicitly distinguishes itself from that sibling.

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

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

No statement of when to use this tool versus easyeda_board_layers, easyeda_board_dimensions, or easyeda_board_features, nor any prerequisites. The agent must infer the context entirely.

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 (readOnlyHint=false, destructiveHint=false) already tell the agent this performs a non-destructive write, and the description confirms it writes a file to disk. It does not disclose whether an existing file is overwritten, whether directories are created, or permission requirements — meaningful gaps for a file-writing tool.

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

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

A single, well-formed sentence with no wasted words and the action front-loaded. It is efficient, though the terseness is a consequence of under-specification rather than deliberate density.

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

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

Return values are covered by the output schema, but the description leaves the required projectId parameter and format options entirely unexplained, and gives no usage context among four-plus BOM siblings. For a 3-parameter write tool with 0% schema coverage, this is inadequate.

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

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

Schema description coverage is 0%, so the description must carry the load. It hints at 'specified format' (the format enum) and 'file on disk' (filePath) but never explains the required projectId, what project identity means here, or the allowed format values.

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

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

States a specific verb (export), resource (bill of materials), and destination (a file on disk), which is more than a restatement of the name. It does not name or contrast with the adjacent siblings (easyeda_bom_generate, easyeda_bom_validate, easyeda_bom_quality_report), so an agent must infer the distinction.

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

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

There is no when-to-use guidance at all. Given several BOM-related siblings (generate, validate, sourcing, quality_report), the description should say when to export vs. generate, but it offers no selection criteria 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?

Annotations already declare readOnlyHint=true and idempotentHint=true, so safety/idempotency are covered structurally. The description adds no behavioral context beyond that: nothing about whether the BOM is persisted, written to disk, or only returned, and nothing about defaults or side effects.

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 tight sentence with the core action front-loaded. Nothing is wasted, though the phrase 'with grouping and formatting options' could be more specific about what those options do.

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

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

An output schema exists, so return values need not be described, and the read-only profile is covered by annotations. Still, for a tool sitting in a cluster of five other BOM tools, the description leaves the selection decision and parameter meaning underspecified.

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

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

Schema description coverage is 0%, so the schema documents only enums and defaults, not meaning. The description's 'grouping and formatting options' loosely maps to groupBy and format, which is some added value, but it says nothing about the semantics of the grouping modes or format choices, and projectId is entirely unexplained.

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

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

States a specific verb+resource ('Generate a bill of materials for the project') and hints at the two adjustable axes (grouping, formatting). However, it never differentiates from close siblings like easyeda_bom_export, easyeda_bom_validate, or easyeda_bom_quality_report, so an agent must guess which BOM tool to pick.

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

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

No when-to-use guidance, no exclusions, and no mention of the alternatives (bom_export, bom_validate, bom_quality_report, bom_sourcing) despite heavy sibling overlap. The agent gets no help deciding between generation and export.

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

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

Annotations already declare readOnlyHint=true and idempotentHint=true, so the safety profile is covered. The description adds that the report spans 'configured suppliers', hinting at an external/supplier-data dependency, but says nothing about whether live supplier queries occur, latency, or failures when no suppliers are configured.

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

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

A single dense sentence with the action front-loaded and the diagnostic categories trailing for scanning. It is efficient, though the five-item list is somewhat comma-heavy without indicating which checks are default-on.

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

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

An output schema exists, so return shape need not be described. However, for a 6-parameter tool with zero schema descriptions, an agent cannot determine the units or effect of minimum_quality_score or stale_vendor_data_seconds from either source, leaving a real gap before invocation.

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

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

Schema description coverage is 0% across 6 parameters, so the description carries the burden. Its checklist ('missing-MPN', 'missing-footprint', 'low-stock items') implicitly maps to require_mpn, require_footprint, and low_stock_threshold, but minimum_quality_score and stale_vendor_data_seconds are left entirely undefined in both schema and description.

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

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

States a specific verb and resource ('Generate a BOM quality report') and enumerates the exact defect classes it surfaces (unavailable, single-source, missing-MPN, missing-footprint, low-stock). This separates it functionally from easyeda_bom_generate, easyeda_bom_export and easyeda_bom_validate, though it never names those siblings explicitly.

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

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

The enumerated check categories imply when the tool is useful (pre-sourcing BOM audit), but there is no statement of when to prefer it over easyeda_bom_validate or easyeda_bom_sourcing, and no prerequisites or exclusions are given. Usage is inferable rather than stated.

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

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

Annotations already declare readOnlyHint=true and idempotentHint=true, so the safety profile is covered. The description adds almost no behavioral context beyond that: it does not say what happens if 'suppliers' is omitted (all suppliers? default set?), whether it hits an external network/API, or how stale the pricing data may be. The phrase 'from specified suppliers' is the only added detail.

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

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

A single front-loaded sentence with no filler or redundancy. It is appropriately sized, though it is perhaps too terse given the parameter ambiguity it leaves unresolved.

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

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

An output schema exists, so return-value structure need not be described. Still, for a tool with 0% schema parameter coverage, the description omits the supplier-value format and default behavior, which are needed to invoke it correctly. Adequate but with a clear gap.

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

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

Schema description coverage is 0%, so the description carries the full burden for both parameters. It implies projectId (the BOM project) and suppliers, but gives no guidance on supplier identifier format (names? IDs? enum values?) or whether the suppliers list is optional with a default. This leaves genuine ambiguity for the caller.

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

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

States a specific verb ('Retrieve') and resource ('pricing and availability information for all parts in the project BOM'), which is clearly distinguishable from siblings like easyeda_bom_validate, easyeda_bom_export, and easyeda_bom_quality_report. However, it never explicitly names or contrasts itself with those siblings, so it falls short of a 5.

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

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

The description says nothing about when to use this tool versus the other BOM tools (validate, export, generate, quality_report), nor any prerequisites such as whether the BOM must already exist. Usage must be inferred entirely from the name and purpose sentence.

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

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

Annotations already declare readOnlyHint=true and idempotentHint=true, so the safety profile is covered. The description adds that validation is performed against external LCSC inventory (an external dependency) and enumerates the finding types, but says nothing about permissions, whether the check is cached/live, or latency expectations.

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

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

One front-loaded sentence with no filler, leading with the verb and resource. It is efficient, though a touch terse given the tool sits among several near-neighbor BOM tools.

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

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

An output schema exists, so return values need not be explained, and the description covers the operation and its finding categories. However it omits the when-to-use routing among the BOM siblings and any meaning for the sole parameter, leaving genuine gaps for an agent choosing between 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 0% and the single parameter (projectId) is undocumented in the schema. The description only alludes to it via 'the project BOM,' adding negligible meaning; a low-coverage single param deserves at least a note on what identifier is expected.

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

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

Specific verb (validate), resource (project BOM), and data source (LCSC inventory), plus the concrete finding categories (missing, obsolete, alternate parts). This distinguishes it from easyeda_bom_quality_report and easyeda_bom_sourcing in substance, though it never names a sibling to sharpen the boundary.

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

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

The LCSC-inventory framing implies the scenario (checking procurement readiness of a BOM), so usage is inferable, but there is no explicit when-to-use, no prerequisite, and no guidance on choosing this over easyeda_bom_quality_report or easyeda_bom_sourcing.

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

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

Annotations already declare readOnlyHint=true and idempotentHint=true, so the safety profile is covered. The description adds that version and capabilities are included in the response, a small amount of context beyond the structured fields, but no detail on what 'capabilities' means or connection 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?

A single efficient sentence that front-loads the primary purpose and appends the secondary returns. No filler.

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

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

An output schema exists, so return values need not be detailed in prose, and a zero-parameter read-only status tool is inherently simple. Slight gap: no hint about what the bridge status values mean or how to react to a disconnected 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?

The tool takes zero parameters, so the schema imposes no semantic burden and the baseline is 4. Nothing in the description is required to explain inputs.

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

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

States a specific verb ('Check') and resource ('EasyEDA Pro bridge connection status') plus the fields returned (version, capabilities). However, it does not distinguish itself from adjacent siblings like easyeda_health_check or easyeda_get_capabilities, which cover overlapping ground.

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 this should be used versus easyeda_health_check, easyeda_get_feature_flags, or easyeda_get_capabilities, all of which appear to query related state. The agent must infer the distinction from names 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?

Annotations already declare readOnlyHint=true and idempotentHint=false; the description adds real behavioral context beyond that: oversized PNGs are downsampled without cropping and original/final dimensions are reported. This is useful, non-obvious behavior for a capture 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?

Two tight sentences with no wasted words; the core action is front-loaded and the downsampling caveat follows immediately.

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

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

An output schema exists so return values need not be explained, yet the description still notes what gets reported (original/final dimensions). For a single-param capture tool this is nearly complete; only sibling differentiation is missing.

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

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

Schema coverage is 0% and there is one optional parameter (tabId). The description compensates by explaining that the tab is either the given one or the last-focused tab, which clarifies the optional/default semantics beyond the bare schema.

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

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

States a specific verb+resource: captures the visible EasyEDA schematic/PCB canvas as PNG. This clearly distinguishes it from most siblings, though it does not explicitly contrast with the close sibling easyeda_canvas_capture_region (which implies a sub-region 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?

Provides implied context via 'the given tab or last-focused tab', telling the agent the capture target defaults to the active tab. However, it gives no explicit when-to-use guidance nor routes the agent between this tool and easyeda_canvas_capture_region or easyeda_canvas_locate.

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

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

Adds two behavioral facts that annotations do not carry: the call mutates viewport state ('This moves the visible viewport'), which explains the idempotentHint=false, and oversized results are downsampled rather than cropped, so the requested region is preserved. It stops short of stating any size threshold or resolution cap for the downsampling.

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

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

Three short sentences, each carrying a distinct fact (what it does, the viewport side effect, the downsampling guarantee), with the core action front-loaded. No filler or repetition of the title.

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 capture tool with an output schema to describe the returned image, the description covers action, side effect, and result-fidelity behavior adequately. The only remaining gap is how the tab scope (tabId) interacts with the capture, which neither schema nor description explains.

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

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

Schema description coverage is 80% and the coordinate parameters are already documented in the schema (including edge-order tolerance); the description adds no coordinate semantics of its own. The undocumented tabId remains unexplained in both places, so the baseline 3 holds.

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

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

States a precise verb+resource+output format ('Zoom to a rectangular document/canvas region and capture it as PNG'), which cleanly separates it from the sibling easyeda_canvas_capture (full canvas) and easyeda_canvas_locate. An agent can distinguish it from every other canvas/board tool without opening a schema.

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

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

Usage context is implied by the region-capture framing, but there is no explicit when-to-use-vs-alternatives guidance: nothing says to prefer easyeda_canvas_capture for whole-canvas shots or easyeda_canvas_locate for coordinate lookup. The viewport-move warning is a helpful hint but not routing guidance.

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

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

Annotations already cover the safety profile (readOnlyHint=true, idempotentHint=false), and the description adds context beyond them: it clarifies the coordinate space (document/canvas coordinates) and discloses that the call has a visible side effect on the user's viewport, which is what makes idempotentHint=false intelligible. It does not describe rate limits or how tabId scoping behaves, so it falls short of a 5.

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

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

Two tightly written sentences, with the core action front-loaded and the usage routing second. No filler or restated name/title.

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

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

An output schema exists, so the description needn't detail the return value, though it helpfully summarizes it as the resulting viewport rectangle. Combined with the disclosed coordinate space and sibling routing, an agent has enough to call it correctly; only the tabId parameter remains opaque.

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

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

Schema description coverage is 0%, so the description carries the burden. It does clarify the meaning of x/y ('coordinate', 'document/canvas coordinates') and scale, which is real added value, but tabId is left completely unexplained and no format or default values are given for the optional 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?

Specific verb (Zoom) + resource (EasyEDA canvas) + input semantics (coordinate/scale) + return value (viewport rectangle). It also distinguishes itself from easyeda_canvas_capture by naming that sibling directly, so an agent can tell them apart without opening either schema.

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

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

Explicitly states both usage modes: 'to frame a location before calling easyeda_canvas_capture, or standalone to navigate the user's view to a point of interest.' The alternative and the condition selecting it are both named, leaving nothing to inference.

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

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

Annotations already declare readOnlyHint and idempotentHint, so the safety profile is covered. The description adds genuinely useful behavioral context beyond that: results cite a source and caveat, and the values are explicitly estimates rather than certified — important for an agent deciding how much to trust the output.

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

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

Two sentences, front-loaded with the verb and resource, dense with the covered domains, and ending on the critical trust caveat. No filler and nothing repeated from the title.

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

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

With an output schema present, the description need not explain return values, and it correctly focuses on scope and trust limits. Combined with full schema coverage and read-only annotations, an agent has everything needed to invoke this correctly.

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

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

Schema description coverage is 100%, so every parameter (topic, layer, loadA, currentA, protocol, etc.) is already documented in the schema, setting the baseline at 3. The description enumerates topic domains that map onto the topic enum but adds no format, conditional-requirement, or unit nuance beyond what the schema already provides.

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

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

States a specific verb ("Look up") plus the exact resource (generic engineering reference guidance) and enumerates the covered domains: IPC-2221 trace-width/current-capacity, clearance bands, protocol routing, decoupling, bulk capacitance, DFM checklist. This clearly separates it from sibling check tools like easyeda_drc_run and easyeda_erc_run, which evaluate an actual board rather than return static reference data.

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 the reference/estimates nature and contrasts against certified values, which implicitly signals when to use it over real DRC/ERC checks. However, it never names an alternative tool or states an explicit condition for choosing this over a live rule check, so the routing guidance is implied rather than stated.

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

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

Annotations already declare readOnlyHint=false, idempotentHint=true, destructiveHint=false, so the safety profile is partly covered. The description adds genuinely new context: the focus prerequisite, the not_available failure mode, and the fact that only coarse severity counts come back while per-violation detail stays inside EasyEDA Pro. It does not explain the non-read-only side effect beyond 'refreshing the panel'.

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

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

Three tight sentences, front-loaded with the action, then the precondition, then the return-shape caveat. No filler or repetition.

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

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

An output schema exists, so the description is not obligated to spell out return values, and it usefully notes the coarse-count limitation. However, the two input parameters, especially the 'rules' override array, are entirely unexplained, leaving an agent unable to use the tool's filtering capability confidently.

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

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

Schema description coverage is 0% and the description never mentions either parameter, including the required projectId or the optional 'rules' filter array. With zero documentation in the schema, the description needed to compensate and does not.

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

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

States a specific verb+resource: running EasyEDA Pro's native PCB DRC and refreshing the visible DRC panel. This is clearly distinguishable from neighboring diagnostic tools such as easyeda_pcb_constraint_check and easyeda_rule_check_summary.

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

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

Gives an explicit precondition ('Requires a PCB document to be focused') and the consequence of not meeting it (indeterminate not_available with a focus error). It does not name or exclude sibling alternatives like pcb_constraint_check, so it falls short of a full when/when-not routing statement.

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

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

Annotations cover the safety profile (readOnly false, idempotent true, destructive false), so the description's added value is the failure behavior: fail-closed scopes, native counts being authoritative, and 'not_available' on unavailable focus. That is meaningful beyond structured fields, though the version-specific 'fails closed' condition is narrow.

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?

Four short sentences, front-loaded with the action and its precondition, then failure modes. Dense but every sentence carries information; no filler.

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

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

An output schema exists so return values need not be described, and the scope/failure behavior is covered. However, with four parameters and zero schema description coverage, the description leaves checks and pageUuid entirely unexplained, which is a real gap for a tool the agent must configure correctly.

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

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

Schema coverage is 0%, so the description must compensate. It explains the scope enum semantics well (focused works, page/all_pages fail on this version), but says nothing about checks, pageUuid, or the required projectId, leaving half the parameters undocumented.

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

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

States a specific verb and resource ('Run native schematic ERC') and adds that it supplements aggregate counts with inferred_floating_pins, so the agent knows it is a native ERC plus an extra inferred metric. The 'native' qualifier implicitly separates it from easyeda_semantic_erc_validate/auto, but those siblings are never named.

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

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

Gives a clear precondition ('Requires a focused schematic') and states which scope values work versus fail ('explicit focused is supported; page/all_pages fail closed on EasyEDA Pro 3.2.149'). No alternative tool is named for cases where focus is unavailable, which is the only gap.

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 declare readOnlyHint=false, idempotentHint=true, destructiveHint=false, which covers the safety profile, but the description adds nothing behavioral. It does not say whether files are overwritten, what filePath defaults to, or what productionReview mode 'block' does — the only non-obvious behavior in this tool.

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

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

A single front-loaded sentence with no filler or redundancy. Brevity is appropriate in form, though it is brevity achieved by omission rather than by tight editing of necessary 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 6-parameter, nested-object tool with no schema descriptions and 0% coverage, the description leaves the parameters entirely undocumented (the output schema handles return values). The core call — what filePath, drillFormat, excludeLayer, and productionReview do — is not addressed.

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

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

Schema coverage is 0% across 6 parameters, including an enum (drillFormat), an array (excludeLayer), and a nested object (productionReview with mode/boardData). The description explains none of them, so an agent gets no help on drill format, layer exclusion, or review mode semantics.

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

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

States a specific verb and resource: 'Export PCB design to Gerber files', with the end goal (PCB fabrication) named. It is clearly distinguishable from siblings like easyeda_bom_export or easyeda_pcb_production_review, though it does not explicitly contrast with 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?

The description gives no when-to-use context, no prerequisites (e.g. must the PCB be synced from schematic first?), and no alternatives such as easyeda_pcb_production_review. The 'for PCB fabrication' phrase hints at intent but is not actionable guidance.

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

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

Annotations already declare readOnlyHint and idempotentHint, so the safety profile is covered. The description adds what is returned (profiles, flags, operations), but since an output schema exists, that content is largely redundant rather than additive behavioral context.

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

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

A single front-loaded sentence with no filler. Slightly padded by listing return contents that the output schema already documents, but nothing is wasted.

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

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

With an output schema present, no-arg invocation, and annotations covering safety, the description supplies enough for an agent to call it correctly. The only real omission is how it relates to the narrower sibling 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?

Zero parameters, so there is nothing to disambiguate; the baseline for a no-param tool is 4. The description correctly implies no input 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?

States a specific verb (Return) and resource (server capabilities) and enumerates the contents: profiles, feature flags, supported operations. However, it does not differentiate itself from close siblings like easyeda_get_feature_flags, easyeda_get_tool_profiles, and easyeda_get_server_config, which cover overlapping ground.

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 call this versus the more targeted siblings (get_feature_flags, get_tool_profiles, get_server_config). An agent must infer that this is the broad aggregate call rather than the narrow one.

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

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

Annotations already declare readOnlyHint and idempotentHint, so safety is covered. The description adds nothing beyond that — no note on whether flags are per-project, cached, or mutable server-side state, which is the kind of context that would justify a higher score.

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 sentence with no filler, and the resource is front-loaded. It is efficient, though it is arguably under-specified rather than deliberately tight.

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

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

With no parameters and an output schema present, return-value explanation is unnecessary, so the description is close to sufficient. The remaining gap is routing: nothing tells the agent how this differs from the other easyeda_get_* introspection tools.

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

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

The tool takes zero parameters, so there is nothing for the description to disambiguate. Baseline 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?

States a specific verb and resource ('Return ... feature flag values'), so an agent knows it reads runtime feature-flag state rather than design data. However, it offers no differentiation from nearby read-only siblings such as easyeda_get_capabilities, easyeda_get_server_config, or easyeda_get_tool_profiles.

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

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

There is no statement of when to call this versus the other introspection tools, nor any prerequisite or exclusion. The agent must infer usage purely from 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?

Annotations already declare readOnlyHint=true and idempotentHint=true, so the safety profile is covered structurally. The description adds a genuine behavioral guarantee beyond that ('secrets are never exposed', output is redacted), which is useful for deciding whether the result is safe to surface. However, it says nothing about the shape or size of the config returned, or whether any config classes are withheld entirely.

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

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

Two short sentences, zero filler, and the most important fact (redaction) is front-loaded. It is efficient, though the extreme brevity is part of why the parameter gap above goes unexplained.

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

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

An output schema exists, so return values need not be described here, and the read-only nature is carried by annotations. The remaining gaps are the undocumented 'include_flags' parameter and the absence of any routing versus sibling introspection tools, leaving this definition only 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?

Schema description coverage is 0% and the single parameter 'include_flags' (boolean, default false) is never explained in the description. An agent cannot tell from either source what flags would be included or how the output changes when it is set. With one undocumented parameter, the description should have compensated and does not.

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

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

The description states a specific verb and resource ('Return server configuration') and adds a meaningful scope qualifier ('safe/redacted'). It is clear enough to act on, but it does not differentiate itself from closely related siblings such as get_feature_flags, get_capabilities, or get_tool_profiles, which also read server-side metadata.

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

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

No when-to-use guidance is given. The description does not say under which circumstances an agent should call this instead of the adjacent introspection tools, nor does it state any prerequisites. The only hint of applicability is the implicit 'debugging/inspection' framing.

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

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

Annotations already declare readOnlyHint=true and idempotentHint=true, covering the safety profile. The description adds nothing beyond that: it does not say whether profiles are static or dynamic, what a 'profile' represents, or whether the list is exhaustive or filtered.

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 that is front-loaded with the verb and resource, with nothing wasted. It is arguably under-specified rather than verbose, but structurally clean.

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

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

An output schema exists, so return values need not be explained. Still, the key concept ('tool profile') is left undefined and undistinguished from sibling introspection tools, so the description is only minimally complete for a discovery 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 tool takes zero parameters, and the description correctly implies no input is required. With no parameters to document, the 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?

States a specific verb and resource ('List available tool profiles and their descriptions'), so an agent knows exactly what the tool returns. However, it offers no differentiation from nearby introspection siblings such as easyeda_get_capabilities, easyeda_get_feature_flags, or easyeda_api_inventory, leaving the agent to guess which listing is relevant.

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 versus the many other capability/inventory tools. No prerequisites, no context, no exclusions are stated.

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

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

Annotations already declare readOnlyHint and idempotentHint, so safety is covered. The description adds the meaningful behavioral trait that this consolidates six signals 'in one call,' which is the reason to pick it over several narrower probes; it stops short of noting cost or refresh characteristics.

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

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

Two sentences, no filler. The payload list comes first and the usage cue second, so the agent gets the 'what' before the 'when' with nothing wasted.

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

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

Zero parameters, full annotation coverage, and an output schema that carries the return shape, so the description only needed to state the aggregate scope and the entry-point role — both are present. Nothing an agent needs to invoke it correctly is missing.

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

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

The tool takes zero parameters, so per the rubric this is the baseline 4. The description correctly implies a no-argument call ('in one call') and there is nothing further the schema leaves ambiguous.

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

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

Names a specific verb and resource ('return server health status') and enumerates the exact payload (runtime version, profile, bridge state, EasyEDA version, keyless sourcing, catalog size), so it reads as an aggregate status roll-up. It does not explicitly differentiate itself from close siblings like easyeda_bridge_status or easyeda_get_server_config, so the agent must infer the boundary.

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

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

Gives a clear situational trigger: 'the single actionable status check after first connecting the bridge extension.' That tells the agent when to reach for it rather than a narrower sibling, but it never names an alternative or states exclusions (e.g. after the bridge is already healthy, prefer bridge_status).

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

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

Annotations cover the safety profile (readOnlyHint, idempotentHint, destructiveHint=false), so the description need not restate them. It adds useful context about what data is returned (timing snapshots, retention policy), though it doesn't describe freshness, scope, or whether data is aggregated vs. live.

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

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

A single, front-loaded sentence that lists exactly what the tool returns with no filler. Every phrase earns its place.

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

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

Output schema exists, so return value details are not required in the description. Annotations cover safety. The main gap is the undocumented `includeRecentEvents` parameter, but for a read-only diagnostics tool this is a minor completeness issue.

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

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

Schema description coverage is 0%, so the single parameter `includeRecentEvents` is undocumented in the schema. The description does not mention this parameter at all, leaving its semantics (default true, what events are included) unexplained. Baseline 3 for a one-parameter tool with no compensating description.

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

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

States a specific verb (Return) and resource (latency budgets, runtime metrics, cache/vendor timing, storage retention policy), clearly identifying this as a diagnostics/observability tool. However, it does not explicitly differentiate from siblings like easyeda_health_check, easyeda_bridge_status, or easyeda_get_server_config, which also serve operational/status purposes.

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 easyeda_health_check or easyeda_get_server_config. The phrase 'for performance diagnostics' hints at context but does not name conditions 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 readOnlyHint and idempotentHint already provided, the description adds useful behavioral context: the focused-tab prerequisite and the fact that an empty list is returned rather than an error when no PCB tab is active. It does not cover pagination or permission details beyond that.

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

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

The description is front-loaded with the core action and returned fields, followed by a compact prerequisite/behavior note. It is appropriately sized with no filler sentences.

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

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

The output schema exists, so return values need not be fully explained, and the annotations cover safety traits. However, with zero schema description coverage, the missing parameter documentation (projectId, limit, offset) leaves a meaningful gap for correct invocation.

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

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

Schema description coverage is 0% for all three parameters, and the description does not explain projectId, limit, or offset. It mentions returned fields, not input parameters, so it fails to compensate for the undocumented 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 states a specific verb (List) and resource (components placed on the active PCB layout), and it names the returned identity fields. It clearly distinguishes this PCB component listing from sibling tools like pcb_tracks and schematic_components by specifying 'active PCB layout'.

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

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

It gives clear usage context: the tool requires a focused PCB tab in EasyEDA Pro, and it describes the no-active-tab behavior. However, it does not explicitly compare against alternatives or state when not to use this tool.

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

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

Annotations already declare readOnlyHint=true and idempotentHint=true, so the safety profile is covered. The description usefully enumerates the validation categories, but does not say what a failing check does, whether it merely reports or blocks, or how results are surfaced, so it adds limited behavioral context.

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

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

Two sentences, front-loaded with the action and followed by a scannable list of checks. No filler, though the long enumeration is dense rather than 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?

An output schema exists so return values need not be described, but with 0% schema coverage on a large nested input object the description is far too thin on inputs. For a tool of this complexity it should explain the boardData contract.

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

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

Schema description coverage is 0% and the tool takes a complex nested boardData object with dozens of undocumented fields plus projectId. The description names validation categories that only loosely imply some fields but explains no parameter meaning or required structure, so it fails to compensate for the coverage gap.

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

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

States a specific verb ('Run ... validation') and resource ('PCB constraint') and enumerates exactly what is checked. However, it never distinguishes itself from close siblings like easyeda_pcb_constraint_report or easyeda_drc_run, leaving an agent to guess which validation entry point to pick.

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 versus easyeda_drc_run, easyeda_rule_check_summary, or easyeda_pcb_constraint_report, nor any stated prerequisites. The agent is left to infer usage entirely from 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?

Annotations already declare readOnlyHint and idempotentHint, so the safety profile is covered. The description adds that the output explains applied constraints and flags items needing manual review, which is useful context about the result shape, but nothing about scope limits, data sourcing, or how boardData is consumed.

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

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

A single front-loaded sentence with zero filler; the report's purpose and its two-part content (applied constraints, manual-review items) are stated immediately.

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

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

An output schema exists, so return values need not be explained. However, given a 2-parameter schema that is 0% documented and a heavily nested boardData object, the description leaves the agent without enough context to supply the request body correctly or to choose this tool over the constraint-check sibling.

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

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

Schema description coverage is 0% and boardData is a large nested object with ~40 undocumented fields, yet the description says nothing about what projectId or boardData must contain. An agent has no textual hint about required vs. optional board data or which fields drive the analysis.

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

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

Specific verb (Generate) + resource (PCB constraint report) with the output framed as a human-readable explanation of applied vs. manually-reviewed constraints. It is distinguishable from the sibling easyeda_pcb_constraint_check, though the description never explicitly says how it differs from a 'check'.

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

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

No when-to-use guidance, prerequisites, or alternatives. With easyeda_pcb_constraint_check and easyeda_pcb_production_review as siblings, the agent gets no signal about which to call for a constraint audit versus a report.

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

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

Annotations already cover safety (readOnlyHint, idempotentHint), but the description adds substantive context: no Fill mutation is exposed, netless fills are returned rather than skipped, and polygons are emitted in a 'bounded normalized' form. This is value beyond the annotations, though pagination/rate behavior is unmentioned.

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

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

Two dense sentences, front-loaded with the discriminating scope before the detail about netless fills and the read-only guarantee. Every clause carries information; nothing is filler.

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

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

An output schema exists, so return shapes need not be restated, and the description still summarizes the notable ones. The one real gap is undocumented pagination parameters, which leaves an agent guessing about result-set bounds.

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

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

Schema description coverage is 0% and the description never mentions projectId, limit, or offset. The presence of limit/offset pagination parameters is a meaningful behavior an agent must know about, and neither the schema nor the description explains them, so the description does not compensate for the coverage gap.

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

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

States a specific verb (List) and resource (native PCB Fill primitives) and explicitly separates it from copper pours/zones, which is exactly the sibling confusion risk with easyeda_pcb_regions. It also enumerates the fields returned, so an agent knows what it gets without opening a schema.

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

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

Clear context: use this for native Fill primitives, not pours/zones, and it notes that netless fills are surfaced explicitly with netless=true (a real selection gotcha). It does not name a sibling tool outright or state when-not to call it, so it stops short of a 5.

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

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

Annotations already declare readOnly=true, idempotent=true, destructive=false, so the safety profile is covered. The description adds that output is severity-ranked findings with remediation, which is useful. But it never explains the gateMode semantics (warn vs block vs off), which is the one behaviorally significant aspect of this tool.

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

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

Two tightly written sentences with zero padding; purpose and placement in the workflow are 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?

An output schema exists, so return values need no explanation, and annotations cover safety. But with 0% schema coverage and a deep nested parameter object, an agent cannot tell what inputs to supply or how gateMode changes behavior. The description is complete on purpose but incomplete on invocation.

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

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

Schema description coverage is 0% and the description mentions no parameter at all. Three parameters, one of which is a large nested boardData object with ~35 fields, are left entirely undocumented. gateMode's warn/block/off values in particular have behavioral meaning that the description should explain but does not.

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

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

States a specific verb (run) and resource (fabrication/assembly/testability production review rules) with scope clarified as PCB handoff, and the DFM/DFA/DFT framing plus 'before Gerber export' distinguishes it from easyeda_drc_run and easyeda_pcb_constraint_check. It stops short of naming those siblings explicitly, so a 4 rather than 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?

Clearly places the tool in the workflow: 'before Gerber export or manufacturing submission.' That is real when-to-use context. However, it never names the alternative checks (DRC, constraint check) an agent should skip in favor of this one, so it lacks exclusions.

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

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

Annotations already assert readOnlyHint and idempotentHint, and the description harmonizes with them rather than contradicting ('Read-only; no Region mutation is exposed'). It adds real behavioral context beyond the annotations: the polygon is 'bounded normalized', and regions are 'native' vs. pour-derived geometry, which shapes how an agent interprets results.

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

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

Two sentences, no filler, with the core identity (native regions, not pours) front-loaded and the read-only guarantee trailing. Every clause carries information.

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

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

An output schema exists, so return-format explanation is not owed. However, the pagination and projectId parameters are undocumented anywhere, and no note on large result sets or default limit (100, max 200) is given, leaving a real gap for a listing 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?

Schema description coverage is 0% and the description never mentions limit, offset, or projectId. For a 3-parameter tool with an undocumented pagination pair and a required projectId, the description should compensate for the schema gap and does not.

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

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

States a specific verb (list) and resource (native PCB Region primitives) and explicitly scopes it against copper pours/zones, which distinguishes it from siblings like easyeda_pcb_fills, easyeda_pcb_tracks, and easyeda_pcb_vias. The listed attributes (layer, rule type/name, line width, lock state, polygon) further pin down the 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 phrase 'separately from copper pours/zones' implies the boundary against the copper-fill siblings, but no tool is named and no when/when-not condition is stated. Usage is inferable rather than explicit, which is the definition of an implied-usage 3.

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

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

Annotations already cover the read-only/idempotent safety profile, and the description adds genuinely non-obvious behavior: a multi-point track surfaces as several segments sharing one net, and an unfocused PCB tab yields an empty list rather than an error. That empty-list contract is exactly the kind of disclosure that prevents agent confusion.

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

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

Two tight sentences, front-loaded with the resource and scope, with the segment-grouping caveat and empty-list contract following. No filler.

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

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

With an output schema present the field list is somewhat redundant, but the empty-list behavior is useful. The gap is the undocumented limit/offset pagination semantics for a list tool, which an agent needs to page correctly.

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

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

Schema description coverage is 0% and the description never mentions projectId, limit, or offset. The fields it lists are return values, not parameters, so the three inputs remain undocumented in both schema and prose.

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

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

States a specific verb and resource ('List copper track segments on the active PCB layout') and enumerates the returned fields, which cleanly distinguishes it from siblings like easyeda_pcb_vias, easyeda_pcb_fills, and easyeda_pcb_regions.

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 implicitly scopes usage to the active PCB layout and notes that tracks come from add_track, but it never says when to pick this over the neighboring PCB-primitive listers. Usage context is implied rather than spelled out.

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

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

Annotations already declare readOnly and idempotent, so the safety profile is covered. The description adds valuable non-obvious traits: it requires a focused PCB tab, returns an empty list rather than an error when no tab is active, and caveats that the hole/outer diameter unit is not independently verified against a physical dimension. This goes well beyond the annotations.

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

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

The description is front-loaded with the core action and returned fields, then adds prerequisite and caveat information. It is fairly dense but every element serves a purpose. The parenthetical caveat about the diameter unit is a bit long but still earns its place by flagging a data-quality limitation.

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

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

With an output schema present, the description need not detail return values, yet it helpfully enumerates them. However, for a tool requiring a projectId and offering limit/offset, the absence of any parameter guidance and the lack of explicit tie between the 'active PCB layout' and the projectId leave an important gap. The behavioral caveats are good, but the description is incomplete on how to invoke the tool correctly.

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

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

Schema description coverage is 0%, and the description mentions none of the three input parameters (projectId, limit, offset). It only lists output fields, leaving the agent with no information about the required projectId or how pagination via limit/offset behaves. The description does not compensate for the missing schema descriptions.

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

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

The description states a specific verb (List) and resource (vias on the active PCB layout), and it enumerates the returned fields. It clearly distinguishes this tool from sibling PCB list tools such as easyeda_pcb_tracks, easyeda_pcb_components, and easyeda_pcb_fills, which cover different 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?

The only usage-relevant statement is a prerequisite (focused PCB tab) and an edge-case behavior (empty list instead of error). There is no explicit guidance on when to choose this tool over alternatives, nor any condition or exclusion that would help an agent decide between this and other PCB inspection 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?

Annotations already declare readOnlyHint=false, idempotentHint=true, destructiveHint=false, and the description is consistent with an idempotent, non-destructive re-check. It usefully adds that output is normalized to pass/fail/inconclusive and covers duplicate nets, free networks, and unconnected pins, but says nothing about cost, timeouts, or what happens when native details are unavailable.

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

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

Two sentences, front-loaded with the action and the value proposition, no filler. Every clause carries information about what is combined and why the classification matters.

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

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

An output schema exists so return values need no explanation, and the overall intent is covered. But for a 7-parameter tool with nested DRC/ERC override objects and only 57% schema coverage, the description does not explain the manual-log path or policy variants, leaving gaps an agent must resolve from the schema.

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

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

Schema coverage is 57%, and the description only obliquely touches parameters ('native DRC/ERC results' for useNativeChecks, 'policy-aware classification' for policy). The manual message overrides, the projectId scoping, and the policy enum values are left to the schema.

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

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

States a specific verb (run/classify) and resource (post-write schematic QA) and distinguishes itself from the raw easyeda_drc_run / easyeda_erc_run siblings by explaining it layers policy-aware classification on top of native DRC/ERC output. An agent can tell this is not the same as the plain rule-check 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?

'after generated edits' implies when to use it, but no alternatives are named the way a 5 would (e.g. 'use easyeda_drc_run for raw results'). No when-not guidance or prerequisites are given.

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

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

Annotations already declare readOnlyHint, idempotentHint and destructiveHint=false, so the safety profile is covered. The description adds the analysis scope but no operational context such as required inputs, whether the tool depends on a loaded project, or failure modes. The return-shape sentence is redundant given an output schema exists.

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

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

Two sentences, zero filler, with the analysis scope front-loaded and the return statement trailing. Well sized for the amount of information it conveys.

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 an 8-parameter tool with nested objects and zero schema description coverage, the description should carry far more weight. It omits parameter semantics and usage conditions, and its return-value sentence is unnecessary because an output schema is present.

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

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

Schema description coverage is 0% across 8 parameters (rails, loads, sources, regulators, capacitors, protections, limits, projectId). The description names several conceptual categories that loosely map to those parameters, but it provides no format, required-vs-optional, or unit semantics to compensate for the total absence of schema descriptions.

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

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

The description states a specific verb (Analyze) and resource (power tree) and enumerates the analyzed domains: sources, regulators, loads, protection, bulk capacitance, current budget, dropout, thermal risk. This clearly distinguishes it from the schematic/BOM/board siblings. It stops short of naming the alternatives or conditions that select it.

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