EasyEDA Pro MCP

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

Annotations already declare readOnlyHint=true, destructiveHint=false and openWorldHint=false, so safety is covered; the description contributes the evaluation scope and the three accepted identifier types. It does not describe the result shape, what happens when a device cannot be resolved, or why JLCPCB stock is queried despite openWorldHint=false — that last point is a mild tension worth noting but not a direct contradiction.

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

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

A single dense sentence with the verb and subject front-loaded and zero filler; every clause names a distinct evaluation dimension. Nothing could be removed without losing 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?

With five parameters including a nested target object and no output schema, the description does enough to convey what is compared and how devices are addressed. It stops short of hinting at the comparison result's structure (match/mismatch verdicts per dimension), which an agent would want since no output schema exists.

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 60%, and the only real semantic layer the description adds is restating the UUID/LCSC/designator forms that deviceA and deviceB schemas already document. The nested 'target' object and 'timeoutMs' remain undocumented in both the schema and the description, so the gap is not compensated.

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

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

The description opens with a specific verb and resource ('Compares two component devices') and enumerates the evaluated dimensions (pinout matching, footprint geometry, JLCPCB stock, drop-in feasibility). This clearly separates it from siblings such as easyeda_get_device_details or easyeda_verify_pin_pad_mapping, though no sibling is named explicitly to confirm 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 use case is implied through 'drop-in replacement feasibility' and the accepted identifier forms, which suggests comparing candidate parts. However, there is no explicit when-to-use, when-not-to-use, or pointer to an alternative (e.g., get_device_details for single-part inspection), so the agent must infer the routing decision.

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 this as read-only, non-destructive, and closed-world, so the safety profile is covered. The description adds useful analysis scope by listing the discrepancy categories and a synchronicity score, but it does not disclose operational behavior such as whether both targets must already be open or how the comparison is scoped.

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

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

The description is two tightly written sentences, front-loaded with the cross-domain comparison purpose and followed by a compact list of detected discrepancies. Every phrase contributes to identifying the tool's scope.

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

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

There is no output schema, and the description lists detected issue types plus a synchronicity score but does not explain the result structure or whether omitted targets default to active documents. For a three-parameter nested-target analysis tool, it covers purpose well but leaves important operational and return-value details thin.

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

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

Schema coverage is 67%: pcbTarget and schematicTarget already carry 'Expected PCB/schematic document target' descriptions, and timeoutMs is self-documented with default and bounds. The description reinforces the two-domain mapping with 'between Schematic and PCB' but adds no target-selection or timeout semantics beyond the schema.

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

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

The description states a specific action and resource: cross-domain discrepancy analysis between Schematic and PCB in EasyEDA Pro. It then names concrete discrepancy types it detects, which clearly distinguishes it from single-domain siblings such as easyeda_run_drc or easyeda_run_schematic_erc.

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 cross-domain framing and issue list imply this is the tool for schematic-vs-PCB consistency checks, but it never explicitly says when to use it instead of easyeda_prepare_schematic_pcb_sync, easyeda_verify_connections, or single-domain validation tools. Usage is inferable rather than directly 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 destructiveHint=true, idempotentHint=false and readOnlyHint=false, so the safety profile is covered. The description still adds real context: execution requires human approval, the confirmation must be the exact prepared phrase, and PCB saving is a distinct step. Timeout behavior and what the call returns are not described.

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, with the mutation-plus-approval gate front-loaded ahead of the per-action detail. The closing note that saving the PCB remains separate is terse to the point of ambiguity, given that 'save' is itself one of the enum values.

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

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

For a destructive, non-idempotent tool with 11 enum actions, a nested params object, and no output schema, the definition covers only the editDrcRules path. An agent still lacks guidance on obtaining the mutationId or confirmation for other actions, and on where results are retrieved.

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

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

Schema description coverage is only 25%, so the description must compensate, and it does so for one case: for editDrcRules it specifies params:{editId} and the exact confirmation. It leaves the 11-value action enum largely unexplained and says nothing about params for the other actions or about timeoutMs.

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: runs a mutating EasyEDA Pro action, gated on human approval. That distinguishes it from the read-only siblings, but it does not name how it relates to the many easyeda_prepare_* tools that presumably generate the confirmation, nor to easyeda_get_mutation_result.

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 prerequisite of human approval and the editDrcRules special case are stated, which gives implied usage context. However, it never says explicitly that a prepare_* tool must run first, that get_mutation_result should be used afterward, or when to choose one action enum value over another.

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

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

Annotations already declare readOnlyHint, idempotentHint, destructiveHint=false and openWorldHint=false, so safety is covered. The description adds useful scope beyond that by naming the five things inspected and noting it returns 'suggested next steps', but it says nothing about failure modes (e.g. what is returned when the extension is not connected), latency, or how the structured result is shaped.

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

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

A single front-loaded sentence with the key noun phrase ('structured diagnosis') first and a compact enumeration of what is diagnosed. No filler, no 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?

With no input parameters and no output schema, the description carries the burden of explaining what comes back, and the enumerated diagnostic surfaces plus 'suggested next steps' do most of that work. It stops short of describing the result structure or the expected remedy path, which would close the remaining gap for a troubleshooting entry point.

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; the baseline of 4 applies. No misleading parameter language is present.

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: it 'returns a structured diagnosis' and enumerates the diagnosed surfaces (local MCP bridge, EasyEDA Pro extension connection state, protocol compatibility, active document context, suggested next steps). An agent can tell this is a health-check tool, but the description never distinguishes it from overlapping siblings such as easyeda_live_status and easyeda_get_context.

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

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

Use is only implied by the diagnostic framing (call it when the bridge or extension state is in question). There is no explicit when-to-use, when-not-to-use, or 'prefer this over easyeda_live_status / easyeda_get_context' routing guidance, which matters given how many sibling tools report related state.

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, destructiveHint=false and openWorldHint=false, and the description is consistent with that safe-read profile. Beyond the annotations it adds real content: the four concrete checks performed and the note that it 'documents engine limits and platform boundaries', which tells the agent what evidence the evaluation surfaces. It stops short of describing failure modes or what the audit output looks like.

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 whose clauses are a legitimate enumeration of the audit steps rather than filler. It is dense but every clause corresponds to a distinct check; slightly more structure (e.g. separating what is inspected from what is reported) would improve scanning.

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 no-required-parameter, read-only audit with no output schema, the description explains what is inspected but not what the agent receives back — a pass/fail verdict, a per-component issue list, or free-text notes — nor what happens when checks fail. That omission matters because there is no output schema to fall back on.

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

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

Schema description coverage is only 33% — only groundNet is documented in the schema. The description partly compensates by stating it 'verifies Node 0 / GND reference', which explains why a groundNet exists, but the nested `target` object and `timeoutMs` receive no explanation anywhere. Baseline 3 for partial compensation.

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 ('feasibility evaluation of analog SPICE simulation') and resource ('the active schematic'), then enumerates the checks (model availability, Node 0/GND reference, stimulus sources, engine limits). An agent can distinguish this from easyeda_generate_spice_netlist by the audit wording, though it never names that sibling to sharpen the contrast.

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 'feasibility evaluation... readiness' framing implies this is a pre-simulation gate, so usage is inferable. However, there is no explicit when-to-use/when-not-to-use statement and no routing to the sibling easyeda_generate_spice_netlist, which is the obvious next step once feasibility passes.

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, non-destructive, non-open-world behavior, so the safety profile is covered. The description adds what geometry is included (board plus component bodies), but says nothing about the fact that a file is written to disk, what happens if destinationPath is omitted, or how timeoutMs affects the operation. No contradiction with the readOnlyHint since the board design itself is not mutated.

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 the verb, the resource and the formats first, then the purpose clauses. Slightly dense with the parenthetical format list, but 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?

Eight optional parameters and no output schema mean the description must carry the return contract, and it does not: nothing says whether a file path, a job handle, or raw data comes back, nor where the file lands without destinationPath. For an export tool the agent cannot predict the result of the call from this definition.

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 88%, so the schema already documents format, quality, fileName, destinationPath, includeCopper, includeSilkscreen and includeComponents3D; the description only restates the format list. The single undocumented parameter, timeoutMs, is not explained in the description either, so no real meaning is added beyond the schema.

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

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

The description gives a specific verb plus resource ('Exports 3D mechanical CAD geometry ... of the board and mounted component bodies') and enumerates the four output formats, so the agent can tell this apart from export_dxf, export_gerber, export_pdf and get_pcb_3d_view. It does not name a sibling explicitly as the alternative, which keeps it below 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?

Three intended uses are named (MCAD integration, 3D printing, thermal/clearance analysis), which implies when to reach for this tool. There is no guidance on when not to use it, no mention of the related 3D inspection/view siblings, and no prerequisites such as requiring an open PCB document.

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, destructiveHint=false, openWorldHint=false, and idempotentHint=false, so safety is covered. The description adds nothing about the notable side effect of this tool: it produces a file (where it is written, whether an existing file is overwritten, or what happens on timeout). Given idempotentHint=false, an agent would benefit from knowing why repeated calls may behave differently.

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 filler, so it is concise and front-loaded. However, that brevity leaves the definition under-specified rather than efficient, since space that could carry parameter or output detail is unused.

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

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

For a four-parameter export tool with no output schema and no documented parameters, the description should say where the export goes and what the result contains. It answers neither, so an agent cannot predict the outcome of a call beyond 'a BOM happens.'

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 all four parameters (scope, format, fileName, timeoutMs) are undocumented in both schema and description. The description does not explain what 'auto' scope resolves to, the output format tradeoffs, or the fileName/timeout behavior, leaving the agent to guess from bare enums.

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 ('Exports') plus resource ('BOM') and scopes it to the active EasyEDA Pro project. This clearly separates it from other exporters such as export_gerber, export_cpl, and export_netlist, though the description itself doesn't name those alternatives.

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

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

There is no guidance on when to choose a BOM export over the other export tools, nor on prerequisites (e.g., whether a project must be open or a schematic generated first). The agent must infer usage entirely from the title.

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, destructiveHint=false, and openWorldHint=false, so safety is covered. The description adds that the source is the currently active PCB document, but says nothing about where the file is written by default, whether an existing file is overwritten, or that the operation produces a local artifact despite the read-only hint — the kind of context that would matter for a file-producing 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 sentence with the artifact and source front-loaded and no filler. Nothing is repeated from the title or schema, and the parenthetical use case is compact rather than redundant.

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

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

With five optional parameters and no output schema, the description should tell the agent what the call yields (a file path or status) and what happens when fileName/destinationPath are omitted. It identifies the source document context but leaves output handling and default write location unspecified, which is a notable gap for a file-export 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 80%, with unit and format already documented as enums with defaults, so the schema does the heavy lifting. The description adds no extra meaning about unit/format choices or the file-naming and destination behavior implied by fileName and destinationPath, leaving the undocumented timeoutMs entirely unexplained. Baseline 3 applies.

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

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

"Exports the Pick and Place / Centroid (CPL) file from the active EasyEDA Pro PCB" gives a specific verb plus a clearly named artifact and its domain (SMT assembly, JLCPCB). It stops short of distinguishing itself from the adjacent export/report siblings such as easyeda_get_pcb_placement_report or easyeda_export_bom, so an agent must infer which output each produces.

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 clause "for SMT assembly (e.g. JLCPCB)" implies the intended situation, which is real usage context. There is no explicit when-not guidance, no mention of prerequisites beyond an active PCB, and no pointer to the closest alternative (get_pcb_placement_report) for agents that only want to inspect placement data rather than export a file.

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=true and destructiveHint=false, but the description leaves the key behavioral question unanswered: does this write a file to disk at destinationPath or return DXF content to the caller? Nothing is said about overwrite behavior, whether an existing file is replaced, or how timeoutMs (default 30s, max 120s) affects a long export. With idempotentHint=false on a file-producing operation, this gap is material rather than cosmetic.

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: verb and artifact first, then content options, then use cases. No filler or repetition. The use-case tail is slightly marketing-flavored but still aids tool selection, so it earns its place.

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

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

For a 7-parameter, zero-required export tool with no output schema, the description covers what is exported but omits what comes back (file path, DXF text, or status) and how scope values "auto"/"schematic" behave. It is adequate to pick the tool, but an agent still has to guess at the result contract before invoking it.

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

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

Schema description coverage is 86%, so the schema already documents unit, scope, fileName, dxfVersion, and destinationPath. The description's mention of outlines, traces, and drilling holes gives a hint about plausible values for the otherwise loosely typed `layers` array (items just "string", no enum), but it adds no syntax or naming convention for those layer names. Baseline 3 is appropriate since the schema carries most of the load.

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 artifact ("Exports 2D CAD DXF drawings") and enumerates what can be included (PCB outlines, copper traces, drilling holes, schematic drawings). That is much clearer than a bare name restatement, but it never distinguishes itself from sibling exporters like easyeda_export_gerber, easyeda_export_pdf, easyeda_export_image, or easyeda_export_3d_model, so the agent must infer the split from external knowledge.

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 downstream use cases (mechanical enclosures, CNC routing, laser cutting, AutoCAD integration) implicitly tell the agent when DXF is the right format versus Gerber or PDF. However, no sibling is named, no exclusions are given (e.g. "not for fabrication output — use export_gerber"), and prerequisites such as an open document are unstated.

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, destructiveHint=false, idempotentHint=false and openWorldHint=false, so the safety profile is covered and the description is not contradicting it — exporting does not mutate board data. The description adds the useful constraint that the target is the *active* PCB reached 'through the extension', but it does not say where files land, whether existing outputs are overwritten (consistent with idempotentHint=false), or what happens on timeout given the 120s cap.

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 a clear verb-resource-source structure and no filler. It is efficient, though the brevity comes at the cost of the parameter and prerequisite information noted elsewhere.

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

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

With no output schema and 0% schema description coverage, the description is the only place to explain the two parameters and the return shape, and it explains neither. For an export tool whose result is a set of files, at minimum the output destination and the meaning of fileName should be stated.

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 both parameters and does not: 'fileName' (naming/path of the output archive or files) and 'timeoutMs' (default 60000, max 120000) are never mentioned or explained. An agent gets no signal on what fileName should look like or how the timeout affects a multi-file fabrication export.

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 ('Exports Gerber fabrication files') and qualifies the source ('from the active EasyEDA Pro PCB'), which distinguishes it from the PDF/BOM/CPL/DXF export siblings. It stops short of explicitly naming which sibling to use for which deliverable, but the output format makes the split obvious.

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

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

No when-to-use or when-not-to-use guidance, no mention of prerequisites such as needing an active PCB document or completed DRC, and no pointer to alternatives like easyeda_export_pdf or easyeda_export_cpl. The only contextual cue is the word 'Gerber', leaving the agent to infer the lifecycle position of 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, destructiveHint=false, and idempotentHint=false, so safety is covered. The description adds useful rendering context (high resolution, vector vs raster, transparent background, layer visibility), but it omits the behaviorally important question of whether the output is written to a filesystem path or returned inline, which matters for a non-idempotent export.

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

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

A single front-loaded sentence with the verb and resource first, followed by the capability modifiers. Every clause carries information and there is no filler, though the trailing list of options is somewhat dense and mirrors schema parameters.

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 9 parameters and no output schema, the description should explain what the call returns or where the artifact lands, and it does not — an agent cannot tell whether it gets a file path, a base64 payload, or a URL. It also does not mention timeoutMs or the default 300 dpi / png behavior, so material gaps remain for a fairly complex 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 89%, so the schema already documents dpi, format, layers, transparentBackground, and the rest. The description still adds meaning the schema does not: it clarifies that layer selection relates to the PCB layer stack, that scaling applies to raster output, and that vector output (SVG) is supported. The only untouched parameter is timeoutMs, so this is slightly above baseline.

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

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

States a specific verb and resource ('Exports a high-resolution visual rendering or vector graphic... of the active schematic sheet or PCB layer stack') and names the concrete output formats. It is clear what the tool produces, but it never distinguishes itself from siblings that also produce document output, such as easyeda_export_pdf, easyeda_render_document_view, or easyeda_schematic_snapshot.

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 'active schematic sheet or PCB layer stack' implies the operating context, and the mention of PNG/SVG/JPG implicitly signals a raster/vector-image use case rather than a print/PDF one. However, there is no explicit when-to-use or when-not-to-use guidance and no routing to the competing export/render siblings.

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, destructiveHint=false and non-idempotent behavior, so safety is covered. The description adds only that the operation goes 'through the extension'; it never says whether a file is written to disk, where it lands, whether an existing file of the same name is overwritten (notable given idempotentHint=false), or what the call returns.

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

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

A single front-loaded sentence with no wasted words. Its brevity works against it only in that the space saved is not used for any of the missing behavioral or parameter detail.

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

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

For an export tool that takes three undocumented parameters, produces no output schema, and presumably writes a file, the description is far too thin. An agent cannot determine output destination, return value, or the effect of 'auto' scope from what is provided.

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 says nothing about scope, fileName or timeoutMs. Parameter names are largely self-explanatory, but the meaning of the 'auto' scope value and the interaction between fileName and the on-disk output are left entirely 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 ('Exports') and resource ('a netlist') scoped to the active EasyEDA Pro schematic or PCB, so the operation is immediately identifiable. It does not, however, separate itself from nearby siblings such as easyeda_generate_spice_netlist or easyeda_export_bom, leaving the agent to infer that this is the plain connectivity netlist export.

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

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

There is no when-to-use or when-not-to-use guidance, no mention of prerequisites beyond 'the active ... schematic or PCB', and no routing to alternatives. The agent gets no help deciding between this and easyeda_generate_spice_netlist, nor any guidance on when 'auto' scope is appropriate.

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, destructiveHint=false and openWorldHint=false, so safety is covered; the description adds only "through the extension", hinting at a required bridge but never confirming it. It does not say where the PDF is written, whether an existing file is overwritten, whether a UI dialog blocks the call, or why idempotentHint is false despite the read-only hint. For a long-running export with a tunable timeout, these omissions matter.

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 clean, front-loaded sentence with no filler, which is good structural economy. However, brevity here comes at the cost of under-specification rather than serving clarity, so it does not earn more than a mid score.

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

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

With no output schema, no annotation coverage of side effects, and zero parameter documentation, the description is too thin for the tool's complexity. An agent cannot tell from this text what it will receive back (a file path? bytes?), whether the export is synchronous, or how scope and timeout interact.

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 three parameters, so the description carries the full burden and delivers nothing: no explanation of what "auto" scope does, no statement of the fileName format or default naming, and no guidance on when to raise timeoutMs. The schema's enum and defaults provide mechanical structure, but the semantics of each argument remain undefined.

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 definition states a specific verb ("Exports") and resource ("a PDF") and names the source explicitly ("the active EasyEDA Pro document"), which distinguishes it from the many sibling tools that are also exports (gerber, image, dxf, bom, netlist). It stops short of naming which export sibling handles which case, but the PDF target is unambiguous.

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

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

There is no statement of when to pick this over easyeda_export_image, easyeda_export_dxf or the other export siblings, and no prerequisites such as the extension needing to be connected. The scope enum (pcb/schematic/auto) is never explained in terms of which one to choose, leaving the selection of key arguments 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=true, destructiveHint=false, idempotentHint=false and openWorldHint=false, so the safety profile is covered. The description adds one real behavioral detail — 'with integrity validation' — but says nothing about where the archive is written, whether an existing file at destinationPath is overwritten, or what a validation failure looks like, which matters for a tool that produces output on disk.

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 leads with the action and resource, then layers the archive contents and integrity guarantee. No filler, no 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?

Six optional parameters, no output schema and no description of what is returned (a path, a blob, a status object), plus zero required parameters means an agent gets no signal about defaults or the result shape. With annotations carrying the safety story it is adequate, but the omission of return/output location leaves a real gap for an export 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 83%, so the schema already documents format, fileName, includeHistory, destinationPath and includeLibraries. The description only repeats the format values (epro, zip, json) that the enum already lists and adds no semantics for timeoutMs or the interaction between fileName and destinationPath; baseline 3 applies.

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

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

Names a specific verb (exports) and a precise resource (the entire EasyEDA Pro project archive) and enumerates its contents — schematic sheets, PCB layout, layer configs, netlists, metadata. That cleanly separates it from the artifact-specific export siblings such as export_gerber, export_pdf, export_bom and export_netlist.

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 'entire project archive' implies a full-project backup/transfer scenario, which is enough for an agent to prefer this over the single-artifact exporters, but there is no explicit when-to-use statement, no exclusion, and no named alternative. Guidance is inferred 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 destructiveHint=false, so the safety profile is covered. The description adds one useful scope fact — the search is confined to the active EasyEDA Pro project, not the library or other documents — but says nothing about match semantics (substring vs exact, case sensitivity), result truncation, or ordering, which matter for a search 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 the resource first and the matching criteria after; there is no padding or boilerplate. It is terse to the point of underspecification, but nothing in it 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?

No output schema exists, so the description should explain what a match looks like and how `limit` truncates results — it does neither. Against annotations that already cover read-only safety and a simple three-parameter schema, it is adequate but leaves meaningful gaps for an agent that must decide how many results to expect.

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 only 33%: only `query` is documented in the schema, and the description's field list largely restates that same text. The `limit` and `timeoutMs` parameters are left undocumented in both places, so the description 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+resource ("Finds a component") and enumerates the searchable attributes (designator, name, value, footprint, property), which is enough to distinguish it from easyeda_find_net or easyeda_get_component_pins. However, it never names easyeda_list_schematic_components or easyeda_navigate_component, so the boundary with the closest siblings must be inferred.

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

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

There is no explicit when-to-use guidance: nothing says to use this rather than easyeda_list_schematic_components (enumerate all) or easyeda_navigate_component (jump to a known one). Only the implicit framing "by designator, name, value..." hints that this is for text-driven lookup.

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, destructiveHint=false and openWorldHint=false, so the safety profile is covered and the description only needs to add context. It adds the 'active project' scoping, but leaves the notable idempotentHint=false unexplained, says nothing about result size, paging, or how limit/timeout affect 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 front-loaded sentence with no filler, which is the right size for this tool. The trailing phrase "available connections or metadata" is hedged and could be made concrete without adding length.

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

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

There is no output schema, so the description carries the burden of describing return values, and it does so only vaguely ("connections or metadata"). With two of three parameters undocumented anywhere, an agent cannot predict what it will get back or how to bound the query.

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 33%: only 'query' is documented (as a full or partial net name). Neither the description nor the schema explains what 'limit' bounds (matching nets? returned connections?) or what 'timeoutMs' means for an editor RPC call, so the description 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?

"Finds a net by name and returns available connections or metadata" states a specific verb (finds) and resource (net) plus a partial statement of the return. It is distinguishable from aggregation siblings such as easyeda_get_schematic_nets or easyeda_get_pcb_net_report, though it never names easyeda_trace_net, the closest-looking alternative.

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

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

The only usage context is the phrase "from the active project"; nothing says when to pick this over easyeda_trace_net, easyeda_highlight_net, or easyeda_get_schematic_nets. No prerequisites, no exclusions, and no statement about whether the project must have a document open.

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

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

Annotations already establish readOnlyHint=true and destructiveHint=false, so the safety profile is covered. The description adds that scanning is scoped to 'active schematic sheets', which is useful, but it does not explain the result format, how the limit truncates findings, or why idempotentHint is false for a pure scan.

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 tight sentence with the scanning action front-loaded and the diagnostic value trailing. No padding, though it compresses away details an agent would need.

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 five parameters at 20% schema coverage, no output schema, and no annotations describing returns, the description should clarify what a 'report' contains and how paging/limits interact. It leaves the return shape and parameter behavior entirely unspecified.

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

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

Schema description coverage is only 20%: only `query` is documented. The description says nothing about `limit`, `allPages` (which notably defaults to true and thus blurs the 'active sheets' claim), `timeoutMs`, or `includeRaw`, so it fails to compensate for the undocumented parameters.

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

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

The description states a concrete verb and resource: scanning active schematic sheets for unconnected component pins. It is distinguishable from neighbors like easyeda_verify_connections or easyeda_run_schematic_erc, 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 phrase about 'reporting potential schematic omissions or dangling inputs' implies a schematic QA use case before ERC, but there is no explicit guidance on when to prefer this over easyeda_run_schematic_erc or easyeda_verify_connections, and no exclusions 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 cover the safety profile (readOnlyHint=true, destructiveHint=false, openWorldHint=false), so the bar is lower; the description does add behavioral detail about normalization, model-card inclusion, and supported analyses. However, it never says whether the netlist is returned inline or written to destinationPath/fileName, nor what happens on timeout, which is important given the non-idempotent hint on an ostensibly read-only operation.

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

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

A single front-loaded sentence that leads with the verb and resource then layers the capability list; dense but every clause carries information. Slightly unwieldy as one sentence, but no wasted wording.

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 nine parameters including a nested target object and no output schema, the agent needs to know what the artifact is and what knobs affect it; the description names the file formats (.cir/.sp), the normalization rule, and the analysis directive families, which is sufficient 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 78%, so the baseline is 3. The description usefully ties 'ground-to-0 normalization' to groundNet and the listed directives to analysisType/analysisParams, but it says nothing about fileName, destinationPath, timeoutMs, includeSubcircuits/includeDefaultModels, or the nested target object beyond what the schema already states.

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

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

The description names a specific verb and resource ('Generates a syntactically valid SPICE circuit netlist') and enumerates the content of the output (ground normalization, RLC primitives, semiconductor models, analysis directives). It is clearly distinguishable from most siblings, though it never contrasts itself with the closely related easyeda_export_netlist or easyeda_evaluate_spice_support.

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

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

Usage is only implied: the target simulators (ngspice, LTspice, Xyce) and the listed analysis types hint at when the tool applies, but there is no explicit 'use this when…' statement, no exclusion versus easyeda_export_netlist, and no stated prerequisite (e.g. an active schematic document or populated target).

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, destructiveHint=false and openWorldHint=false, so the safety profile is covered. The description adds value by naming the computed outputs (perimeter, area, loop closure status), which tells the agent this is an analysis call rather than a raw dump. It does not disclose units, behavior when no outline exists, or the meaning of a non-closed loop.

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 a clear verb and a parenthetical enumerating the bounding box fields; nothing is padded or repeated. The enumeration is long but each item carries information about the return payload, so it earns its space.

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

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

With no output schema, the description correctly takes on the burden of listing returned fields, and it does so thoroughly. However, for an inspection tool with a nested target object and four parameters, it omits units, failure modes (no outline present, wrong document type), and the implication of non-idempotent reads, leaving meaningful gaps.

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

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

Schema coverage is 75%, with includeRaw and includeSegments described in the schema and "Expected active PCB target" documented on the nested object, so the schema does most of the work. The description's mention of "segments" loosely signals the includeSegments toggle but adds no syntax or format detail, and target/timeoutMs receive no clarification. Baseline 3 is appropriate.

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

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

The description names a specific verb ("Inspects") and resource ("board outline boundary" on the active PCB), and enumerates exactly what is reported: bounding box fields, perimeter, area, loop closure, segments. That is far more concrete than a tautology. It stops short of distinguishing itself from the sibling easyeda_prepare_board_outline, which the agent must infer is the mutation counterpart.

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

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

There is no explicit when-to-use statement, no prerequisites, and no mention of the adjacent easyeda_prepare_board_outline tool that an agent would likely confuse this with. The only usage signal is the phrase "on the active PCB," which implies an active-document requirement but does not tell the agent when to pick this over alternatives.

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

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

Annotations already declare readOnlyHint=true and destructiveHint=false, so safety is covered; the description adds the useful qualifier 'when available', warning that net data can be missing. It does not explain why a read is marked idempotentHint=false (results change as the design is edited) or how the allPages/includeRaw switches affect cost and output volume.

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 that leads with the action and follows with the returned fields. It is efficient, though it spends its one sentence on return values while omitting higher-value guidance.

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

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

With no output schema and 75% of parameters undocumented, the description carries most of the burden and delivers only the return-field list. An agent still cannot tell how to scope pages, what to expect on timeout or on ambiguous queries, or when this tool should replace a 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 only 25% - just 'query' is documented - yet the description mentions no parameters at all. The three undocumented switches (allPages, timeoutMs, includeRaw) carry meaningful behavioral implications (page scope, latency budget, payload bloat) that the description leaves entirely unaddressed.

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

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

The description names a specific verb and resource ('Returns all known pins for a schematic component') and enumerates the payload fields (pin number, name, position, net), which clearly separates it from PCB-side siblings like easyeda_get_pcb_pads and from aggregate siblings like easyeda_get_schematic_nets. It does not explicitly name an alternative, but the scope is unambiguous.

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

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

Usage is only implied: an agent must infer that this is the drill-down step after easyeda_find_component or easyeda_list_schematic_components. There is no statement of when to prefer easyeda_trace_component, easyeda_find_unconnected_pins, or easyeda_verify_pin_pad_mapping instead, and no prerequisites or failure conditions 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, destructiveHint=false, openWorldHint=false, and idempotentHint=false, so the safety profile is covered. The description adds the useful constraint that it reads from 'the open EasyEDA Pro instance' (implying a live editor must be connected), but says nothing about what happens when no instance is open or how large/volatile the payload is.

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, repetition, or hedging. Every clause (project, document, selection, editor context) carries information about the return payload.

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

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

There is no output schema, so the description carries the burden of describing return values; it names the four categories of context but not their structure, whether selection may be empty, or how they are nested. For a simple single-parameter read tool this is adequate but leaves the agent guessing about result shape and failure modes.

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

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

The single parameter timeoutMs has 0% schema description coverage and the description never mentions it, so its units, default behavior, and the 120000 ms ceiling are undocumented anywhere beyond the bare JSON Schema constraints. With low coverage the description is expected to compensate, and it does not.

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

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

The description uses a specific verb ('Summarizes') and enumerates the concrete resources returned: active project, active document, selection, and editor context. It is clear what the tool does, but it never distinguishes itself from the overlapping sibling easyeda_get_selection, which a naive agent might pick instead for the selection portion.

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

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

There is no explicit when-to-use guidance, no mention of prerequisites beyond 'the open EasyEDA Pro instance', and no routing to alternatives such as easyeda_live_status, easyeda_get_selection, or easyeda_list_documents. The agent must infer that this is an orientation/state-read tool called before other operations.

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, destructiveHint=false, and openWorldHint=false, so the safety profile is covered. The description adds the useful detail that returned zones carry net, layer, clearance, fillType, vertices, and bounding box, but says nothing about limit/pagination behavior, what happens with an empty or inactive document, or raw-data inflation from includeRaw.

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

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

A single front-loaded sentence with the resource and scope first and the returned attributes trailing as a compact list. Nothing is redundant with the title or annotations.

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

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

For a read-only listing tool with no output schema, the enumerated return fields plus the "active PCB layout" scope are largely sufficient to call it correctly. The gap is limited: the multi-field target object and the semantics of limit/timeout are left entirely to the schema.

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

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

Schema coverage is 71%, so the schema already explains net, layer, limit, includeRaw, and primitiveId filters. The description adds no parameter-level meaning beyond the schema — notably nothing about the nested target object that selects which document is inspected — so the baseline of 3 applies.

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

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

"Lists and inspects copper zones (copper pours/areas) on the active PCB layout" gives a specific verb and resource, and the parenthetical synonym disambiguates it from adjacent concepts like keepouts or tracks. It never names a sibling tool explicitly, so it stops short of the top mark.

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 or when-not-to-use guidance: nothing tells the agent to pick this over easyeda_get_keepouts, easyeda_get_pcb_tracks, or easyeda_get_pcb_net_report. Read-only intent is only implied by "lists and inspects," and no prerequisites or document-state requirements 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 cover the safety profile (readOnlyHint=true, destructiveHint=false), so the description is not carrying that burden. It adds the useful notion that a complete cross-domain payload (symbol + footprint + mapping) comes back in one call, but says nothing about behavior when the target is ambiguous, when a designator is not found, or why idempotentHint is false for a read.

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

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

A single front-loaded sentence with no filler; the verb and lookup keys come first and the payload enumeration follows. It is dense — the comma-separated payload list is harder to scan than a short structured breakdown would be — but 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?

With no output schema, the description usefully enumerates what is returned, which is the main compensating strength. But for a 7-parameter tool with a 10-field nested target object and zero required parameters, it leaves the contextual anchor (how the active tab/page/project is resolved) and the multi-key disambiguation behavior unexplained.

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 71% and the schema already documents lcscCode, designator, deviceUuid, includeRaw and includePinPadMap, so the description's restatement of the three keys adds little beyond examples. The nested target object (tabId, pageId, projectId, documentType, fingerprint, etc.) and timeoutMs receive no explanation in either place.

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 (fetches) and precisely enumerates the returned resource set: device definition, schematic symbol pinout, PCB footprint pad geometry, and pin-to-pad mapping. It also names the three lookup keys, which lets an agent separate it from siblings like easyeda_get_component_pins or easyeda_verify_pin_pad_mapping 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?

The three accepted key types (device UUID, LCSC code, placed designator) imply when the tool is applicable, and the designator example hints it is used against the active schematic/PCB. However, there is no explicit when-to-use vs. when-to-use-a-sibling guidance and no statement about key precedence or exclusivity.

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, destructiveHint=false, and openWorldHint=false, so safety is covered. The description adds genuinely new behavior: results are retained and exist only in this extension instance. However, it doesn't say how long results are retained, what error surfaces for an expired or unknown editId, or why idempotentHint is false for a read.

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 with the action, the safety rule, and the retention constraint, in that order. No filler and the most important constraint (do not reapply) is front-loaded.

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

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

For a two-parameter read-only query tool with no output schema, the description covers purpose, the caution rule, and the ephemeral-retention caveat, which is the key operational risk. The remaining gap is the timeoutMs parameter and the shape of the returned result, but overall it is sufficient to call 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 neither of the two parameters is mentioned in the description. 'editId' is weakly inferable as the handle for the retained edit, but 'timeoutMs' (default 10000, max 120000) is entirely unexplained — the agent cannot tell whether it bounds the DRC wait or the query itself, or what happens on timeout.

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: query a retained DRC edit result. The temporal qualifier 'after execution or timeout' tells the agent this is a post-hoc status read, distinguishing it from the mutation path. It never names easyeda_prepare_drc_edit or easyeda_get_mutation_result as related siblings, so sibling differentiation is left implicit.

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

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

'Query a retained DRC edit after execution or timeout' plus 'Never reapply an uncertain edit' together give a clear when-to-use rule and an explicit prohibition. What's missing is an explicit alternative route (e.g. compare to easyeda_get_mutation_result) or the case where no editId is retained at all.

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

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

Annotations already declare readOnlyHint=true and destructiveHint=false, so 'Does not mutate the board' largely restates structured data. The description adds nothing about how the different scopes behave, whether results are cached/live, what idempotentHint=false means for repeated reads, or how timeoutMs affects the call.

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 with the core purpose front-loaded and no filler. The second sentence is largely redundant against the annotations, costing a little efficiency but not clarity.

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

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

With no output schema, zero schema description coverage, and a five-value enum whose members are undocumented, the description is too thin for an agent to pick a scope confidently or understand what comes back. It covers the safety profile only because annotations already do.

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 both parameters, so the description must carry the burden and does not. It gestures at 'current or configured scopes' but never explains netRules, netByNetRules, or regionRules, and timeoutMs is not mentioned at all.

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: 'Read native EasyEDA Pro PCB design rules', scoped to 'current or configured scopes'. This clearly separates it from easyeda_run_drc (which executes checks) and easyeda_prepare_drc_edit (which edits rules). However, it never names those siblings explicitly, so the differentiation is inferred rather than stated.

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

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

The phrase 'for current or configured scopes' implies a read-inspection use case, but there is no explicit when-to-use guidance, no prerequisites, and no statement about when to prefer easyeda_run_drc or the DRC edit tools instead. An agent must infer the workflow position 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, destructiveHint=false and openWorldHint=false, so the safety profile is covered. The description adds return-field context (layer, keepoutType, vertices, bounding box), but it does not explain the odd idempotentHint=false on a pure read, nor does it mention truncation behavior tied to the default limit of 100. Useful but not rich.

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

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

A single front-loaded sentence with no filler; the operation and scope arrive first. It is efficient, though the trailing field enumeration is the weakest part and would be better spent on distinguishing inputs from outputs.

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

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

For a read-only listing tool with annotations and a mostly documented schema this is adequate, but with no output schema the description should clarify what a keepout record actually contains and how limit/default truncation affects results. The nested target object and timeout semantics are also untouched anywhere in prose.

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 a middling 67%, and the description contributes essentially no parameter meaning beyond the schema. Worse, the field list "layer, keepoutType, vertices, and bounding box" reads as returned data, which could confuse an agent into thinking keepoutType or vertices are inputs. Filters like primitiveId, includeRaw and timeoutMs get no elaboration in 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?

Names a specific verb pair ("Lists and inspects") and a specific resource ("keepout areas on the active PCB layout"), which is enough to separate it from sibling readers like easyeda_get_copper_zones. It does not, however, explicitly contrast itself with easyeda_prepare_copper_keepout, the mutation-side counterpart, so the read/write distinction is left to inference from the verb.

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 signal is the phrase "on the active PCB layout," which implies a PCB document must be active, but there is no statement of when to reach for this tool versus easyeda_prepare_copper_keepout or easyeda_get_copper_zones. No exclusions, prerequisites, or alternatives are mentioned.

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 largely given. The description does add real value with 'never automatically replays a mutation', clarifying that repeated polling has no side effects. It stays silent, though, on whether the call blocks or polls, what a pending mutation returns, and how timeoutMs affects 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?

Two sentences, front-loaded with the verb and resource, followed by the safety caveat. No filler, and the most important scoping detail (by mutationId) arrives first.

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

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

With no output schema, the description does tell the agent what comes back: status, readback evidence, and verification. Combined with annotations covering the safety profile, the only meaningful omission is the polling/timeout behavior, which matters for a status-query tool with a 120s maximum timeout.

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

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

Schema coverage is 50%: mutationId is documented in the schema as 'returned during preparation', and the description only restates that it keys the query. timeoutMs is entirely undocumented in both schema and description, leaving the agent to guess whether it enables long-polling or just bounds the call; given the mid-range coverage, a baseline 3 is appropriate.

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

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

The description gives a specific verb ('Queries') and a concrete resource set: status, readback evidence, and verification of a mutation, keyed by mutationId. It is distinguishable from the prepare_* siblings because it is a retrieval step rather than a mutation, though it never names a specific sibling it complements or replaces.

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?

'any prepared or applied mutation' implies the tool is called after a preparation or application step, which is useful context. However, there is no explicit instruction such as 'call after easyeda_prepare_* or easyeda_confirmed_action', and no when-not guidance (e.g., what to do instead for DRC edit results, which has its own sibling).

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

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

Annotations already establish this is a non-destructive, local, read-only inspection, so the safety profile is covered. The description adds genuine value beyond that by disclosing the report contents - substrate thickness, top/bottom max heights, enclosure fit status, criticality-ranked missing models, and collision detection - which tells the agent what evidence it will get back. It does not mention performance cost or the need for models to exist, keeping it from 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?

A single front-loaded sentence with the verb first and the payloads listed in descending specificity; no filler or restated title. It is dense but every clause maps to a real output category, though the nested parenthetical list makes it slightly hard to scan.

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

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

With no output schema, the description carries the return-value burden and does name the main result categories, which is adequate for a read-only analysis tool. However, it omits the result shape, how fit/tight/exceeded statuses are reported, and what happens when interference checking is disabled, leaving gaps an agent would want closed.

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 60%, with maxHeightMm, checkInterference and enclosureHeightMm already documented in the schema. The description reinforces the concepts ('vertical board envelope', 'total enclosure clearance', 'spatial interference collisions'), which helps map parameters to intent, but adds no format, units or default behaviour beyond what the schema states, and says nothing about target/timeoutMs.

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

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

The description opens with a specific verb and resource ('Inspects 3D models') and then enumerates the concrete artifacts produced: board envelope, missing STEP/OBJ models ranked by criticality, and spatial interference collisions. That distinguishes it reasonably well from easyeda_get_pcb_3d_view and easyeda_export_3d_model, though those siblings are never named 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?

There is no when-to-use guidance, no prerequisites (e.g. that 3D models must be assigned), and no mention of when to prefer this over easyeda_get_pcb_3d_view or easyeda_export_3d_model. The agent must infer the selection rule from the name and sibling set.

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, destructiveHint=false, and openWorldHint=false, so safety is covered. The description usefully enumerates what kinds of data come back (camera angles, layer visibility, export capability), which matters since there is no output schema, but it does not explain the idempotentHint=false signal or whether the viewport shortcuts mutate view state.

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

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

A single dense sentence with no filler, front-loading the returned data categories. The list structure is readable, though the mixed bag of items (view data plus export support plus shortcuts) slightly muddles what the tool primarily does.

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

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

For a read-only tool with a nested target object, no required parameters, and no output schema, the description covers return-value categories but omits how 'target' selects the document and what the 'shortcuts' actually are or do. Adequate but with clear gaps given the complex nested 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 description coverage is only 33%: only viewAngle carries a schema description, while the entire nested 'target' object (tabId, pageId, projectId, documentId, fingerprint, etc.) and timeoutMs are undocumented. The description adds nothing about any parameter, so it fails to compensate for the low coverage.

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

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

States a specific verb ('Retrieves') and enumerates concrete resources: 3D camera angles, layer visibility, STEP/OBJ export support, and viewport shortcuts. However, it never distinguishes itself from close siblings like easyeda_get_pcb_3d_inspection or easyeda_export_3d_model, so an agent cannot tell from the description alone which one 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 when-to-use guidance at all — no condition indicating whether this is for inspecting the live view versus exporting a model, and no reference to the similarly-named 3D inspection sibling. The agent must infer intent purely from the name overlap.

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, destructiveHint=false and openWorldHint=false, so safety is covered. The description usefully adds that results carry an inference method and tolerances and that scope is the active PCB layout, but says nothing about cost, performance, or how the limit truncates results.

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

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

A single front-loaded sentence with no filler; resource scope comes first and returned fields follow. Nothing is wasted, though it is dense rather than structured into scannable clauses.

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?

Five optional parameters with no output schema, and the description compensates by enumerating the returned fields (endpoints, coordinates, lengths, inference method/tolerances). Combined with annotations covering the safety profile, an agent has enough to invoke 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 coverage is 60%, so some parameters (net, limit, the nested target object, timeoutMs) are undocumented or only lightly described. The description only implicitly references padSnapTolerance via 'tolerances' and does not explain the net filter or limit semantics beyond what the schema already says.

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

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

The description names a specific verb ('inspects') and a specific resource ('unrouted ratsnest airwire lines on the active PCB layout'), and lists the returned fields, so it is clearly distinct from siblings such as easyeda_get_pcb_tracks or easyeda_get_copper_zones. It stops short of explicitly contrasting with easyeda_get_routing_status, the closest alternative.

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

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

There is no when-to-use or when-not-to-use guidance, and no sibling is named. An agent must infer on its own whether this or easyeda_get_routing_status / easyeda_prepare_pcb_routing is the right tool for diagnosing unrouted connections.

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

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

Annotations already establish this is a non-destructive, closed-world read, so the safety profile needs no restating. Because there is no output schema, the sentence carries real weight by naming the returned fields (impedance, width, gap, actual lengths, skew compliance). It does not say whether results come from live editor state, whether unrouted/newly created pairs appear, or how toleranceMm changes the 'compliance' verdict beyond the schema default.

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, then a tight enumeration of returned fields with no filler or hedging. Every clause contributes information an agent cannot get from the schema.

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

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

For a read-only list tool with no output schema, describing the payload is the key obligation and the description meets it. The remaining gap is the 'target' context object, which determines which document is read and goes unexplained in both schema and description. With zero required parameters and a stated default tolerance, an agent can otherwise call this correctly on the first try.

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 60%, so the schema does most of the work; the description adds the concept of skew-tolerance checking, which gives toleranceMm (and its 0.15 mm default) practical meaning. Against that, the nested 'target' object (project/page/document targeting), includeRaw, and timeoutMs get no explanation in the description, leaving roughly half the surface to be inferred from property names alone. Baseline 3 is appropriate.

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

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

Opens with a specific verb+resource ('Lists differential pairs') and enumerates exactly what each entry carries: positive/negative net assignments, target impedance, trace width, gap, routed lengths, skew compliance. That is enough to distinguish it from neighbours like easyeda_get_pcb_length_groups or easyeda_get_pcb_net_report, but the description never names those siblings, so the differentiation is inferred rather than stated.

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

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

No when-to-use or when-not-to-use guidance. The reader has to infer whether this is the right tool versus get_pcb_length_groups, get_pcb_net_classes, or get_pcb_tracks when checking impedance or length-matching problems. The only conditional language ('Optional filter by specific differential pair name') is about a parameter, not about choosing 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 destructiveHint=false, covering the safety profile. The description adds useful scope detail (what is included: copper layers, mechanical layers, colors, visibility) and the fact that it targets the *active* PCB, which is a behavioral constraint beyond the annotations. It does not describe return shape or any failure/timeout 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 front-loaded sentence with the resource named first and the content enumeration following. No filler or redundancy.

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

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

With no output schema, the description carries the burden of saying what comes back, and it does list the categories returned. It is adequate for a simple read tool, though it could note the active-document requirement more explicitly as a precondition.

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?

Only one optional parameter (timeoutMs) and schema coverage is 0%, but the parameter is a self-explanatory timeout with a default, maximum, and exclusive minimum already encoded in the schema. The description adds no meaning to it, but the omission is low-cost here.

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 ('Returns') and resource ('layer stackup and configuration of the active EasyEDA Pro PCB') plus the enumerated contents. An agent can distinguish it from siblings like easyeda_get_board_outline or easyeda_get_copper_zones by the stackup framing, though no sibling is named 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?

No when-to-use guidance, no preconditions, and no mention of alternatives among the many PCB getter siblings. The agent must infer that this is the tool for layer/stackup questions rather than outline, net classes, or zones.

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

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

The read-only, non-destructive, closed-world annotations already establish the safety profile, and "Lists" is consistent with them. The description adds useful reporting context (skew, reference length, tolerance compliance) but says nothing about how toleranceMm affects results or when includeRaw/timeoutMs matter.

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

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

A single front-loaded sentence with no filler; the result fields are packed efficiently. It is appropriately sized, though brevity comes at the cost of any operational guidance.

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

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

For a read-only query the description adequately sketches the returned data, which matters since there is no output schema. However, with a five-parameter schema containing an undocumented nested target object and no explanation of document targeting, an agent still lacks information needed to invoke it 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 coverage is 60%: name, includeRaw, and toleranceMm are documented in the schema, while the nested target object and timeoutMs are undocumented in both places. The description's mention of "tolerance compliance" loosely ties to toleranceMm but adds no syntax or default guidance beyond the schema, so it neither compensates for nor worsens the 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?

"Lists equal length matching groups" names a specific verb and resource, and the enumerated return fields (member net lengths, reference length, max skew, tolerance compliance) make the domain unambiguous. It is distinguishable from nearby siblings such as get_pcb_differential_pairs and get_pcb_net_report, though it never explicitly positions itself against them.

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

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

There is no when-to-use or when-not-to-use guidance, no mention of alternatives for related length/matching analysis, and no stated prerequisite (e.g., that a PCB document must be open). The agent must infer the use case 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, destructiveHint=false and openWorldHint=false, so the safety profile is covered. The description adds useful content about what data is exposed (net assignments and routing rules), but says nothing about scoping, pagination, or the active-document targeting behavior implied by the nested target object.

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 listing the verb, resource, and returned data with no filler. Slightly dense parenthetical but every element earns its place.

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

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

For a read-only query with no output schema, the description should indicate the shape of returned net-class entries; it mentions categories of data but not structure or volume. Adequate but leaves gaps an agent would need to discover by calling.

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

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

Schema description coverage is only 50%: 'name' and 'includeRaw' are documented in the schema, but the nested 'target' object (8 fields including documentType enum) and 'timeoutMs' carry no descriptions. The tool description adds no parameter meaning at all, 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 and resource ('Lists net classes') plus what is included: member net assignments and routing rules (trace width, clearance, via size). It is fairly distinguishable from siblings like easyeda_get_pcb_net_report or easyeda_get_pcb_differential_pairs, though it never explicitly contrasts 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?

There is no explicit when-to-use guidance, no exclusions, and no named alternatives among the many PCB-query siblings. 'On the active PCB' only weakly implies the operating context.

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

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

Annotations already declare readOnlyHint=true, destructiveHint=false, and openWorldHint=false, so the safety profile is covered. The description contributes the useful constraint that it operates on the 'active PCB', but it says nothing about why idempotentHint is false or whether results reflect a captured snapshot versus live board state, which matters for a reporting 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 the resource stated before the metric enumeration, and no filler wording. The parenthetical metric list is long but each item is informative rather than redundant.

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

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

For a 6-parameter read tool with a nested target object and no output schema, the description usefully enumerates the returned metrics, which partly substitutes for the missing output schema. However it omits filtering behavior, result-size limits, and target/page scoping requirements, leaving real gaps for an agent invoking it.

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

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

Schema coverage is 67%, so roughly a third of parameters (the nested target object and timeoutMs) are undocumented anywhere. The description mentions no input parameters at all, leaving the meaningful filter levers (net name, status, category) and the limit/pagination behavior to be discovered only from the schema, adding no semantic value over the structured fields.

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 ('Generates detailed physical metrics for nets on the active PCB') and enumerates the exact metrics produced (pad counts, track length, via count, zone coverage, completion percentage). This clearly distinguishes it from raw-entity siblings like easyeda_get_pcb_tracks or easyeda_get_pcb_vias, which return primitives rather than per-net aggregates, though it does not name the nearby easyeda_get_routing_status alternative 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?

There is no when-to-use or when-not-to-use guidance, and no alternative is named. The agent must infer from the metric list that this is for per-net routing completeness audits, but nothing tells it whether to prefer this over easyeda_get_routing_status, easyeda_get_pcb_airwires, or easyeda_run_drc.

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

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

Annotations already declare readOnlyHint=true and destructiveHint=false, so safety is covered; the description usefully adds that each pad carries net connection, layer, drill size, shape, and coordinates. It says nothing about result volume, default truncation at limit=200 (max 1000), timeout behavior, or whether the response is paginated, which matters for a board-wide dump.

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 a clarifying parenthetical - no filler or repetition. It is efficient, though the space saved is spent on return fields rather than the filtering behavior an agent needs to invoke it well.

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 10-parameter, nested-target, read-only query tool with no output schema, the description gives an adequate picture of the returned pad fields. It leaves out filtering semantics, pagination/limit behavior, target resolution, and any differentiation from similar PCB/schematic query tools, which is enough gap to keep it at minimum-viable.

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 70%, and the description adds nothing about any parameter - it never mentions net, layer, component, or padNumber filtering, nor the includeComponentPads/includeStandalonePads toggles. Three parameters (limit, timeoutMs, includeRaw) are undocumented in both schema and description, so the description does not compensate for the coverage gap; baseline 3 is appropriate, not higher.

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

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

The description uses a specific verb ('Inspects') with a concrete resource ('PCB pads') and clarifies scope by naming both component footprint pins and free/standalone pads. It does not name any sibling tool, so the agent must infer the boundary versus easyeda_list_pcb_components, easyeda_get_component_pins, or easyeda_get_pcb_vias on its own.

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

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

There is no when-to-use guidance, no prerequisites, no exclusions, and no mention of the alternative pad/pin tools in the sibling set. The sentence describes what is returned rather than when an agent should reach for this tool instead of list_pcb_components or get_component_pins.

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, destructiveHint=false, and openWorldHint=false, so the safety profile is covered; notably idempotentHint=false is declared but the description never explains why repeated calls might differ (e.g., a snapshot of live editor state). The enumeration of report sections adds useful output context but no cost, latency, or document-state caveats.

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, naming the deliverable first and then its sections. Nothing is wasted, though the sentence is purely descriptive and could have spent some of its length on usage or eligibility context.

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

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

With four parameters, a nested target object, and no output schema, the description should carry more weight on what the returned report contains and how the target scopes it. Listing the report sections partially compensates, but the meaning of target, the effect of timeoutMs, and the report's shape/interpreting of warnings remain unexplained.

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

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

Schema coverage is 50%: collisionTolerance and boardMarginTolerance are documented in the schema itself, while the nested target object and timeoutMs are not. The description's mention of "collision/clearance warnings" loosely connects to the tolerance parameters but adds no unit, default, or behavior detail beyond what the schema already states.

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 ("Generates") and resource ("component placement report") and enumerates the report's contents: density, bounding boxes, layer distribution, and collision/clearance warnings. It does not, however, differentiate itself from siblings that also surface clearance problems, such as easyeda_run_drc or easyeda_get_pcb_3d_inspection.

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: nothing says whether to run this before or after easyeda_run_drc, whether it complements easyeda_list_pcb_components, or what prerequisites (an open PCB document, a populated target) are needed. The agent must infer usage entirely from the tool name and the sibling list.

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

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

Annotations already declare readOnlyHint=true, destructiveHint=false and openWorldHint=false, so the safety profile is covered. The description does add value by naming the returned attributes (net, layer, geometry coordinates, width, calculated length), which matters since there is no output schema. It omits the limit default of 100 / cap of 500 and any truncation behavior, which is the main gap.

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

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

A single front-loaded sentence with no filler: the resource and scope come first, followed by the fields inspected. Slightly list-like but 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?

For a 7-parameter, zero-required read tool with a nested target object and no output schema, the description covers purpose and returned fields but leaves filter interplay, default paging and truncation unstated. Adequate but with clear gaps.

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

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

Schema coverage is 71%, with net, layer, limit, includeRaw and primitiveId all documented in the schema itself, so baseline 3 applies. The description adds nothing about parameters, and the two undocumented fields (target and timeoutMs) receive no explanation here either.

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

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

Concrete verb plus resource: 'Lists and inspects copper tracks and traces on the active PCB layout.' That cleanly separates it from nearby PCB readers such as easyeda_get_pcb_vias, easyeda_get_pcb_pads and easyeda_get_copper_zones, 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 only usage cue is 'on the active PCB layout', which implies a PCB context but says nothing about when to pick this over easyeda_get_routing_status, easyeda_get_pcb_net_report or easyeda_trace_net. No when-not conditions, no mention of how the net/layer filters should be used for targeted inspection.

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, destructiveHint=false and openWorldHint=false, so the safety profile is covered. The description adds useful context by naming the returned fields (coordinates in mm, outer/hole diameter, layers), which matters because there is no output schema. It omits pagination/limit behavior and what happens with the target object, so it is only moderately informative.

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. It is efficient, though the phrasing blurs the line between returned fields and input filters.

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 six-parameter read tool with a nested target object and no output schema, the description covers the resource and the return fields but leaves the target/scoping object and limit semantics unexplained. Adequate, but with clear gaps an agent would have to resolve from the schema alone.

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

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

Schema coverage is 67%, so the baseline is 3. The description's field list reads as returned properties rather than explaining the net or primitiveId filters, and it says nothing about the nested target object or includeRaw, so it does not compensate for the undocumented parameters.

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

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

States a specific verb pair (lists/inspects) and a specific resource (vias on the active PCB layout), which clearly separates it from siblings like easyeda_get_pcb_pads and easyeda_get_pcb_tracks. It does not explicitly name a sibling it is not, so it stops short of a 5.

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

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

There is no guidance on when to use this versus related tools such as easyeda_get_pcb_tracks, easyeda_get_routing_status, or easyeda_get_pcb_net_report. It also doesn't mention that filters are optional or when inspecting a single via by primitiveId is appropriate.

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, destructiveHint=false, and openWorldHint=false, so safety is covered. The description adds real value by stating what the tool reports back (net count, completion %, ratsnest, optional lengths) in the absence of an output schema; it stops short of mentioning prerequisites (an open PCB document) or that a timeout parameter governs execution.

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

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

One front-loaded sentence with no filler; each listed item is distinct information. The parenthetical "(ratsnest)" is slightly redundant jargon, but overall the sentence earns its place.

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

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

For a read-only status/report tool with no output schema and zero required parameters, the description gives a usable inventory of returned metrics. It omits preconditions (active PCB document), the meaning of the timeout budget, and any hint of result shape, which is thin but acceptable given the low complexity.

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

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

Schema coverage is 50%: includeNetLengths is already documented in the schema, and the description's "optional net lengths" merely echoes it. The other parameter, timeoutMs (default 30000, max 120000), is undocumented in both places, so the description does not fully 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?

The description states a specific verb ("Analyzes") and a specific resource (PCB routing status), then enumerates the concrete outputs: total nets, completion percentage, unrouted connections (ratsnest), and optional net lengths. It does not distinguish this from near-neighbors such as easyeda_get_pcb_airwires or easyeda_get_pcb_net_report, so it is clear but not sibling-differentiating.

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

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

There is no explicit when-to-use or when-not-to-use guidance and no named alternative. An agent reading a board checklist could guess this is a progress/summary tool, but nothing in the description tells it whether to prefer this over easyeda_get_pcb_airwires, easyeda_get_pcb_net_report, or easyeda_run_drc.

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, destructiveHint=false, and openWorldHint=false, so the safety profile is covered. The description adds useful semantic context by clarifying that these are native EasyEDA schematic nets rather than inferred geometric connectivity. It does not disclose whether results are paginated, what form the net data takes, or how timeout/raw-data behavior works.

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?

It is two compact sentences with no filler, and the tool's purpose and scope are front-loaded. Every phrase contributes to identifying the resource and the key distinction from geometric inference.

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 six-parameter query tool with a nested target object and no output schema, the description covers purpose and scope but leaves the target object semantics and result shape unexplained. The annotations adequately cover safety, but the absence of return-value information and limited parameter detail leaves some gaps 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 83%, so most parameters are already documented. The description reinforces per-sheet versus project-wide querying, which maps to pageId/allPages, but adds no detail about the nested target object, timeoutMs, or includeRaw beyond the schema. Baseline 3 is appropriate when the schema does most of the work.

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

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

The description gives a specific verb and resource: queries native schematic nets from EasyEDA Pro, with per-sheet or project-wide scope. It also distinguishes the result from geometric inferences, which helps separate it from connectivity derived from layout geometry. It does not name a specific sibling such as easyeda_find_net or easyeda_trace_net, so it falls just short of full sibling differentiation.

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

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

The phrase 'per-sheet or project-wide' implies the main scoping choice, and 'native net connectivity' versus 'geometric inferences' hints at when this tool is preferable. However, there is no explicit instruction naming alternatives like easyeda_find_net or easyeda_trace_net, nor any stated exclusions for when not to use it.

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

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

Annotations already declare readOnlyHint=true, destructiveHint=false, openWorldHint=false, so the safety profile is covered. The description adds genuine behavioral context beyond that: it performs connection validation and signal range diagnostics, meaning the call does analysis rather than a plain dump. It does not say how validation failures or range violations are surfaced, which is the remaining gap.

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

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

A single dense sentence with the inspected resource types front-loaded before the active-schematic scope and the diagnostic capabilities. Nothing is wasted, though the parenthetical about hierarchical/global connectors slightly interrupts the front-loading.

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 six parameters, a nested target object and no output schema, the description should say more about what comes back, e.g. whether ports are grouped by sheet, how connection validation results are shaped, and how bus width mismatches are reported. The target/document-drift guard is only explained in the schema, so overall the definition is adequate but leaves the return contract undisclosed.

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

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

Schema description coverage is 83%, so the schema already documents target, timeoutMs, includeRaw, includeBuses, includePorts and includeBusEntries. The description's mention of ports, buses and bus entry taps loosely maps to three include flags but adds no semantics about defaults or when to disable them, so it is a baseline-3 case with the schema doing the heavy lifting.

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

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

The description names a specific verb ('Inspects') and enumerates three concrete resources (net ports, hierarchical/global sheet connectors, multi-bit buses, bus entry taps) scoped to the active schematic. This makes it distinguishable from nearby siblings such as easyeda_get_schematic_nets and easyeda_find_net, 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?

There is no when-to-use or when-not-to-use guidance and no named alternative. An agent must infer from 'in the active schematic' alone that this is a read of connection primitives rather than a netlist-level query, and has no signal about whether to prefer easyeda_get_schematic_nets or easyeda_trace_net instead.

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

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

Annotations already declare readOnly, non-destructive, closed-world and crucially idempotentHint=false; the description's 'currently selected by the user' explains why results vary between calls, which adds some context. However, it never says what happens when nothing is selected, whether the selection must be in the foreground document, or why a timeout exists — gaps the annotations cannot fill.

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 information-dense sentence with no filler, and the key discriminator (user-selected objects) is front-loaded. It is efficient, though its compression is partly what leaves the behavioral questions unanswered.

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

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

With no output schema, the description does carry responsibility for shape and does name the three possible kinds of returned objects (components, pins, primitives). It is still incomplete for a tool whose result depends on live UI state: empty-selection behavior and the timeout semantics are the main omissions.

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, timeoutMs (default 10000, max 120000), is entirely unmentioned. Its presence suggests the call may wait or poll for a user to make a selection, which is a materially different behavior from an instantaneous read, and the description gives no help in interpreting it.

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 ('Returns') and a precisely scoped resource: the objects 'currently selected by the user on the active schematic or PCB canvas'. That user-selection scope distinguishes it from the many sibling listing tools (easyeda_list_schematic_components, easyeda_get_pcb_tracks, easyeda_list_documents), though no sibling is named explicitly.

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

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

Usage is only implied: an agent can infer this is the tool for resolving 'the thing the user just selected'. There is no explicit when-to-use statement, no guidance on when to prefer a canvas snapshot or context call instead, and no note on what to do if the selection is empty or spans multiple documents.

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

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

Annotations already declare readOnlyHint=true and destructiveHint=false, and the description usefully confirms the effect is confined to canvas display rather than persistent board data. However, it leaves out meaningful behavioral questions: does highlighting a new net replace the previous highlight or accumulate, is the highlight transient, and does the operation fail on an unknown net name (relevant given idempotentHint=false).

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

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

A single front-loaded sentence with no filler; the two modes are stated efficiently. Slightly terse for the behavioral ambiguity it leaves, 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?

For a 3-parameter, annotation-covered, non-destructive tool with no output schema, the essentials are present, but the agent is left unsure about highlight accumulation vs replacement, handling of unknown net names, and the interaction between net and clear. These gaps are small but relevant to 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 coverage is 67%: the net and clear parameters are already documented in the schema, and the description only restates them ("specified net", "clears all highlighted nets"). timeoutMs is undocumented in both places, so the description adds little beyond the schema and does not specify whether net is ignored when clear=true.

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?

"Visually highlights a specified net on the EasyEDA Pro PCB canvas" names a specific verb (highlight), resource (net), and scope (PCB canvas), plus the inverse mode "clears all highlighted nets." The visual/UI nature implicitly separates it from data-reading siblings like easyeda_find_net or easyeda_get_pcb_net_report, though no sibling is named 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 description explains the two modes but gives no when-to-use guidance, no prerequisites (e.g., whether an open PCB document is required), and no alternatives such as navigating to a net versus highlighting it. An agent must infer the calling 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 already declare readOnlyHint=true, idempotentHint=true, destructiveHint=false and openWorldHint=false, so the safety profile is covered without description help. The description adds useful context by specifying what the listing includes (open/active status and tab layout, not just project documents), but says nothing about ordering, pagination, or what happens when no project is open.

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?

It is a single front-loaded sentence that puts the resource scope first and the returned details second, with no filler. Slightly dense packing of four returned attributes into one clause keeps it from a 5.

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

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

For a read-only listing tool with no output schema, the description usefully enumerates the fields an agent will receive, which compensates for the missing return-value documentation. The remaining gap is the undocumented timeout parameter and any statement of behavior when no project/tabs exist.

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 timeoutMs (with default 30000 and max 120000) is not mentioned at all in the description. Even though the parameter is optional and low-risk, the description does nothing to explain its units, default behavior, or what a timeout implies for this call.

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

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

The description uses a specific verb plus resource ('Lists all documents belonging to the current EasyEDA Pro project and open editor tabs') and enumerates the returned fields (identity, type, open/active status, tab layout). It is clear what the tool does, but it never contrasts itself with siblings such as easyeda_open_document or easyeda_get_context, which an agent could confuse it with.

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

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

There is no explicit when-to-use or when-not-to-use guidance and no named alternative. The scope phrase 'current project and open editor tabs' only implies the situation in which it applies, leaving the agent to infer whether to call this before easyeda_open_document or instead of easyeda_get_context.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=false and destructiveHint=false, so the safety profile is covered. The description adds that results are 'normalized' and lists the returned fields, which is meaningful since no output schema exists. It does not disclose the default/capped result count (limit 100, max 500) or any pagination behavior, which matters for a non-idempotent list call.

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 resource and returned fields front-loaded and no filler. It is arguably too terse for an 8-parameter tool with a nested target object, but nothing in the sentence 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?

For a tool with no output schema, 8 parameters including a nested target object, and a broad sibling set, the description covers only the return-field list. It omits the active-document targeting requirement, result limiting, and the optional pad/property expansions, leaving an agent to infer targeting and pagination from the schema alone.

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

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

Schema coverage is only 63%: layer, query, includePads and includeProperties are documented in the schema, while limit, timeoutMs, includeRaw and the nested target object are not. The description adds nothing about any parameter—no mention of layer filtering, text query, pad/property expansion, or that target identifies the expected active tab/page. It enumerates output fields rather than explaining 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 and resource ('Lists normalized PCB components') and enumerates exactly which attributes come back (designator, footprint, layer, coordinates, rotation). It is clear what the tool does, but it never distinguishes itself from the similarly-named easyeda_list_schematic_components or from easyeda_get_pcb_pads, so sibling differentiation is left to the PCB/schematic wording.

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 or when-not-to-use guidance, no mention that the tool operates on the active PCB document, and no routing to alternatives such as easyeda_get_pcb_pads for pad-level detail or easyeda_find_component for lookup. The 'pcb' in the name implies context but the description provides none.

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, destructiveHint=false, openWorldHint=false, so the safety profile is covered. The description adds that components are 'normalized' and which fields are present, which is useful context, but it says nothing about pagination, truncation, or the cost of a full enumeration despite limit/allPages parameters.

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

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

A single front-loaded sentence with no filler; every clause carries information. It is efficient, though its brevity is partly the source of the missing parameter and usage guidance.

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

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

With five optional parameters, no output schema, and only 20% schema description coverage, the definition leaves the agent guessing about pagination defaults (allPages=true), the meaning of includeRaw, and how limit interacts with full listing. For a list tool with this many knobs, more explanation is required.

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

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

Schema description coverage is only 20%: just the 'query' parameter is documented, while limit, allPages, timeoutMs, and includeRaw have no descriptions in either the schema or the tool description. The description's field list refers to return values, not inputs, so it 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?

The description gives a specific verb and resource ('Lists normalized schematic components') and enumerates the returned fields (designator, value/name, footprint, position, key properties), so an agent knows exactly what comes back. It does not explicitly contrast itself with easyeda_list_pcb_components or easyeda_find_component, so sibling differentiation is left implicit.

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

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

There is no statement of when to use this listing tool versus easyeda_find_component, easyeda_schematic_snapshot, or easyeda_get_schematic_nets. No prerequisites, no exclusions, and no guidance on whether this is a full-enumeration tool or a filtered lookup.

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

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

Annotations already declare readOnlyHint, idempotentHint, non-destructive, and closed-world, so the safety profile is fully covered. The description adds that the call reports active document and 'capability information', but the latter is left undefined, and nothing is said about latency, failure modes when the extension is disconnected, or whether it errors versus returning a negative status.

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

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

A single front-loaded sentence with no filler. The only weakness is the vague noun phrase 'capability information', which does little work but costs few tokens.

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

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

With no output schema, the description carries the burden of conveying what comes back, and 'active document/capability information' is only a gesture at the return payload. For a zero-parameter status probe this is close to adequate, but an agent still cannot predict the response shape or how a disconnected extension is reported.

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, which is the baseline-4 case. The description correctly implies a parameterless probe and does not invent inputs, so nothing more is needed here.

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

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

The description gives a specific verb-and-resource pair: it checks extension connectivity and reports active document/capability information. This is clearly distinct from data-query siblings like easyeda_get_context or easyeda_get_selection, though it never names an alternative such as easyeda_doctor, which likely overlaps in diagnostic intent.

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 implied usage — verifying the extension is connected before relying on other EasyEDA tools — is reasonably obvious from the phrasing, but there is no explicit when-to-use statement, no precondition guidance, and no indication of when easyeda_doctor or easyeda_get_context would be preferred instead.

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

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

Annotations already declare a safe, read-only, non-destructive, non-open-world operation, so the bar is lower. The description does add one useful behavioral fact beyond them — that navigation only succeeds 'when the extension can locate it' — but it never says what failure looks like, whether the view is restored on failure, or why idempotentHint is false for a repeat-navigation action.

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

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

One front-loaded sentence with no filler, and the action is stated before the caveat. It is efficient, though the extreme brevity is part of why other dimensions are thin rather than a virtue in itself.

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

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

For a simple two-parameter navigation tool with annotations covering safety, the description is close to complete about what it does. With no output schema, however, it should have said what a successful call returns or how a 'couldn't locate it' outcome is surfaced, and it leaves timeoutMs behavior completely unexplained.

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

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

Schema description coverage is only 50%: 'query' is documented in the schema but 'timeoutMs' has no description anywhere. The description mentions no parameter behavior at all, so it fails to compensate for the undocumented timeout or to clarify accepted query formats (designator vs free-text match).

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

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

The description names a specific verb pair (navigates/highlights), the resource (a component), and the environment (the EasyEDA Pro editor), so an agent can tell this is a viewport navigation action rather than a data query. It does not explicitly distinguish itself from near neighbors like easyeda_navigate_region, easyeda_highlight_net, or easyeda_find_component, which is the only thing keeping it from 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?

Usage is only implied: an agent can infer it should call this when it wants to move the view to a component rather than fetch its data. There is no explicit when-to-use, no mention of easyeda_find_component as the lookup alternative, and no statement of prerequisites such as having the document open.

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, non-destructive, and closed-world, so the safety profile is covered. The description adds the useful scope detail that navigation applies to the 'active' document, but it says nothing about units, whether the viewport only changes, or what timeoutMs governs.

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, which is the right shape. It is short to the point of under-specifying rather than being bloated.

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 seven undocumented parameters, zero required fields, and no output schema, the definition leaves too much implicit for an agent to call it reliably. It needs at minimum the coordinate/rectangle mode semantics and the timeout behavior.

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

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

Schema description coverage is 0%, so the description must carry the parameter burden and does not. It only hints that x/y mean a point and top/left/right/bottom a rectangle, leaving units, whether the two modes are mutually exclusive, and the meaning of timeoutMs entirely 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?

Names a specific verb ('Navigates to') and resource ('coordinates or a rectangular region in the active EasyEDA Pro PCB/document'), so the action is unambiguous. It does not distinguish itself from near-siblings such as easyeda_zoom_board or easyeda_navigate_component, which also move the viewport.

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 choose this over easyeda_zoom_board or easyeda_navigate_component, nor any preconditions such as requiring an active PCB document. The agent must infer selection 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=false, idempotentHint=true and destructiveHint=false, so the safety profile is covered. The description adds valuable side-effect context beyond that: it changes input focus and the canvas viewport, and it returns readback confirmation of the focus transition. It does not say what happens when the expected target identity mismatches, which is the main remaining behavioral gap.

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

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

Two compact sentences with the action front-loaded and no filler. The second sentence ('Provides readback confirmation and reports focus transition') is slightly redundant with the first's viewport/focus statement, but it is not wasteful enough to hurt.

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 tool with a nested identity object and no output schema, the description covers the action and its visible side effects but not the interaction between parameters or the mismatch/failure behavior. An agent still has to infer whether to pass documentId, tabId, or a full target object.

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

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

Schema description coverage is 83%, so the schema already documents tabId, documentId, activate, timeoutMs and splitScreenId, which sets a baseline of 3. The description adds nothing about the parameters and notably does not explain the nested 'target' object, how it differs from top-level documentId/tabId, or how identity matching is used.

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

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

The description names a concrete verb and resource ('Opens a document or activates an open tab in EasyEDA Pro') and covers both modes of the operation, so the agent can distinguish it from list/navigation siblings. It stops short of naming a specific sibling (e.g., easyeda_list_documents as the source of a documentId) that would remove remaining ambiguity.

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

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

Usage is implied by 'opens a document or activates an open tab', which suggests the two situations the tool covers. However, there is no explicit guidance on when to prefer this over easyeda_render_document_view or easyeda_navigate_component, and no mention of prerequisites such as first resolving a documentId via easyeda_list_documents.

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=true and destructiveHint=false, which could mislead an agent into thinking this writes to the PCB; the description usefully corrects that by making clear this only stages a mutation and that execution happens elsewhere, so it adds real value beyond the annotations. However, it does not warn that clearExisting defaults to true (i.e., the staged action will delete existing outline primitives) or that idempotentHint=false means repeated prepares produce new mutationIds. With annotations already carrying the safety profile, a 3 fits.

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 operation and resource, then the required follow-up call. No filler, though the phrase 'Prepares creation, rectangular/polygonal sizing, clearing, or segment modification' is slightly clunky compared to just naming the actions.

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 15-parameter, nested-target, prepare-style tool with no output schema, the description still tells the agent what comes back (mutationId and confirmation phrase) and where to take it, which is the critical missing piece. Gaps remain around target validation and the destructive effect of clearExisting=true, but the schema covers most parameter detail.

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 93%, so the schema already documents every parameter's meaning and per-action applicability. The description only loosely maps operation names to the action enum and adds nothing about the target object, timeouts, or how primitiveId selects a segment. Baseline 3 is appropriate when the schema does the heavy lifting.

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 (Prepares) and resource (board outline on the active PCB) and enumerates the operation families matching the action enum (rectangular/polygonal sizing, clearing, segment modification). It never names the read-side sibling easyeda_get_board_outline, so the differentiation from that tool is left implicit rather than stated.

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

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

The second sentence gives the essential workflow rule: the returned mutationId plus exact confirmation phrase must be passed to easyeda_confirmed_action for execution. It does not state when to choose this over a read-only outline inspection or when not to use it (e.g., if the board is locked or a target is missing).

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