uniwire

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

Annotations already declare readOnlyHint=false, idempotentHint=true, and destructiveHint=false; the description goes beyond them by disclosing op ordering semantics, null-means-remove, and the failure contract (ok=false with errors naming the failing op index, null meaning result validation). It does not state atomicity — whether one bad op aborts the whole batch — or any size limits, which keeps it below 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?

Front-loaded purpose sentence followed by a compact, scannable catalogue of op forms; nearly every clause carries information. Some shorthand ('or "at":"sources"', 'path "installation.earthing"') is left unexplained, making the payload dense rather than wasteful.

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

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

Return values are covered by an output schema and the description still names the success payload and error shape, so the failure contract is complete. What is missing is how an agent obtains valid node ids and how edits relate to validation/normalization siblings, which matters for a mutation tool with a free-form ops payload.

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

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

Schema coverage is 100%, but the 'ops' parameter is an untyped anyOf array/string whose schema explicitly defers to the description, so the description is the only source of the operation grammar (set/add/remove/move/rename/link/unlink with their key shapes). That is genuine meaning added beyond the schema, not repetition of 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, resource, and editing medium ('Edit an electrical diagram by node id') with concrete examples of the edit kinds (change a rating, add a circuit, move a load) and names the return value (the new document). An agent can separate this from siblings like validate, normalize, or render purely from the description.

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 tool is for editing an existing document via ops, and the validate flag hints at a check step, but the description never says when to prefer it over normalize, validate, or a full re-authoring flow, nor when NOT to use it. No prerequisites (where node ids come from) are given, so the agent must infer the workflow.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true and destructiveHint=false, so the safety profile is covered. The description adds meaningful behavioral context beyond that: what each output row represents and the special 'spec'/'length_m' fields, which is what an agent needs to interpret results. It does not mention performance or limits, but for a pure computation that is minor.

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?

Front-loaded with the verb and resource, then the output composition, then the routing sentence. The enumeration of row types is dense but each element carries information an agent needs; no filler sentences. Slightly long, but appropriately sized for the detail conveyed.

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

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

With an output schema present, the description need not restate the full return contract, and it still explains the semantic meaning of the rows (manufacturer/part number, spec, length_m). Parameter, annotation, and output coverage are all adequate; only edge cases like malformed documents are unaddressed.

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

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

Schema coverage is 100% and the 'document' parameter is fully documented in the schema (JSON object or JSON text, as returned by get_example/apply_patch/normalize, file path accepted locally). The description only says 'from its document' and adds no syntax or format detail beyond the schema, 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?

States a specific verb and resource ('Compute the bill of materials ... of an electrical installation from its document') and describes the exact output shape in domain terms (one row per manufacturer/part number, spec, length_m). It also contrasts itself with the sibling 'wiring', so the agent can distinguish the two without opening schemas.

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

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

Explicitly states the use case ('Use it to prepare a quote or an order') and names the alternative sibling ('wiring gives the wire list and cable schedule'), which tells the agent which tool produces what. It lacks an explicit when-not condition or prerequisites, but the routing guidance is clear.

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

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

Annotations declare readOnlyHint=false and idempotent=true, and the description usefully adds that a side effect is produced (viewer_url in the web editor, pdf_url of the drawn document), which explains the non-read-only hint. It also discloses an important limitation — 'automatic checks of the document data, not a conformity certificate' — though it says nothing about permissions, cost, or whether the viewer document is persisted.

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 verb and resource are front-loaded, and the synonym list (single-line diagram, panel, schéma unifilaire, tableau électrique) aids retrieval rather than padding. The return-value enumeration is somewhat long and partly redundant with the output schema, keeping it just below the top 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?

Given an output schema exists, the description did not need to enumerate the finding fields, but it goes beyond by characterizing the findings' severity levels and the 'scope' caveat that results are not a conformity certificate. The only gap is the absence of any guidance on choosing between this and the sibling `validate`.

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

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

Schema coverage is 100%, so both parameters are already documented in the schema, including the enum-like profile names and the 'core' always-applies note. The description largely repeats that and adds only marginal value (naming 'enedis' as the French grid connection profile, mentioning 'PLC' without giving its identifier), so the 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?

The description gives a specific verb+resource ('check an electrical installation') and enumerates what is validated (breaker ratings vs cable sections, RCDs, circuits per protection, selectivity). It also implicitly distinguishes itself from the sibling `validate` by saying it 'validates the document, then applies the rule profiles', but it never names that sibling explicitly, so the boundary 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?

Usage is implied by the two-step pipeline (validate then apply profiles) and the default-profile rule is spelled out, but there is no explicit 'use this instead of X' guidance against siblings like `validate`, `render`, or `normalize`. An agent must infer when a full rule-based check is warranted versus a plain validation pass.

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 value by framing the tool as a read/inspect step that yields stable node ids needed for a later mutation, which is workflow context the annotations do not provide. No auth, rate-limit, or failure-mode detail is offered.

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 return payload and followed by the usage rule. The content enumeration is dense but each item earns its place by telling the agent what the outline contains.

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

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

With an output schema covering the return shape, full schema coverage for parameters, and annotations carrying the safety profile, the description supplies the one thing structured fields cannot: why and when to call it (node-id discovery before apply_patch). Nothing an agent needs to invoke it correctly is missing.

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

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

Schema description coverage is 100%, so both parameters (document, lang) are already fully documented in the schema, including accepted formats and language values. The description adds no parameter-level meaning beyond that, so the baseline 3 applies.

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

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

States a specific verb (return a text outline) and resource (electrical diagram), and enumerates the exact contents: installation, panel tree with stable ids, ratings, cables, links, interlocks, boards, findings. This distinguishes it from siblings like render, bom, or validate that operate on the same document.

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

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

Explicitly names the workflow and the sibling: 'find the node ids before apply_patch', which tells the agent when this tool belongs in a sequence. It stops short of stating exclusions (e.g. when to prefer render or viewer_link instead), so it is clear context without full when-not guidance.

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

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

Annotations already declare readOnlyHint, idempotentHint, destructiveHint=false and openWorldHint=false, so the safety profile is covered. The description adds useful workflow behavior (the document is meant to be a template mutated via apply_patch), which is context annotations cannot express. It does not elaborate on document size or format, but the output schema presumably covers return shape.

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

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

Two sentences, zero filler, with the core action front-loaded and the workflow/alternative trailing. Every clause carries information an agent needs.

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

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

With an output schema present, return values need no explanation, and annotations carry the safety profile. What remains — how to obtain a name, what to do with the result, what tool mutates it — is all stated, so nothing needed to invoke it correctly is missing.

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

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

Schema description coverage is 100% and the schema already documents that the name comes from list_examples and may be a number prefix. The description's "by name" adds no format detail beyond the schema, so the baseline 3 applies.

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

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

States a specific verb and resource ("Return an example installation document") plus the lookup key ("by name"). An agent can distinguish it from list_examples, which is named as the source of names, without opening a schema.

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

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

Gives explicit when-to-use ("as a starting point for a similar installation") and the follow-on action ("edit it with apply_patch"), and routes to the sibling that supplies valid names (list_examples). This is a complete workflow instruction, not vague 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=true, openWorldHint=false and destructiveHint=false, so the safety profile is fully covered by structured data. The description adds the workflow signal that this is a one-time prerequisite read, but discloses nothing about cost, rate limits, or the practical weight of the call beyond what the schema's 'compact/full' level already implies. Adequate but not additive.

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

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

Two sentences, zero filler. The purpose and content inventory come first and the sibling routing note is deferred to the end where it belongs.

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

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

An output schema exists, so return-value documentation is unnecessary. Combined with complete schema coverage and full annotations, the description supplies everything an agent needs: what it returns, when to call it, and which sibling to use for a narrower question.

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

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

Schema description coverage is 100% – both 'lang' (en/fr) and 'level' (compact ~3k tokens vs full every field) are fully documented in the schema with defaults. The description adds no parameter syntax or behavior beyond that, so the 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?

Specific verb+resource ('Return the reference card of the uniwire format for electrical diagrams') followed by an enumeration of the actual contents: document skeleton, node types, fields, enums, links, pitfalls, examples. It explicitly contrasts itself with the sibling type_info, so an agent can route between the two without opening a schema.

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

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

States both the timing ('Read it once before writing a document') and the alternative with its distinguishing scope ('type_info gives the fields of one type in detail'). When-to-use and when-to-use-something-else are both explicit.

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

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

Annotations already declare readOnly, idempotent, non-destructive and closed-world, so safety is covered. The description adds real context beyond that: the catalog is a fixed set of 53 curated examples spanning dwellings, shops, offices, PV, EV, UPS, substations and PLCs.

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, the count and the resource, followed by the return fields. No filler, no 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?

An output schema exists, so return fields need not be enumerated, and annotations cover the safety profile. The description plus structured data is sufficient to call it correctly; only the sibling relationship is unaddressed.

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

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

Zero parameters, so there is nothing to disambiguate; baseline of 4 applies. The description correctly signals a parameterless listing rather than leaving the agent guessing about filters.

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

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

States a specific verb (List) and resource (the 53 example installations), and enumerates the domain categories covered. It is distinguishable from get_example (single item) by implication, but never names or contrasts its siblings list_types/get_example 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 enumeration entry point before calling get_example, but there is no explicit when-to-use/when-not or pointer to alternatives such as list_types or get_reference_card.

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, idempotent and non-destructive, so the safety profile is covered. The description adds value by disclosing the return tuple format and the role this call plays in the authoring workflow, though it says nothing about pagination or error 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 tight sentences, front-loaded with what the tool returns and followed by the usage rule. No filler and nothing redundant with the structured fields.

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

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

Output schema exists, so return-value documentation is not required, and the annotations handle the safety profile. For a two-optional-parameter read-only list tool, the description plus schema plus output schema leaves nothing an agent needs missing.

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

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

Schema coverage is 100% — both lang and category (with its enumerated values) are fully documented in the schema. The description only paraphrases the category filter as "optionally for one category" and never mentions lang, so it adds little beyond the schema. Baseline 3 applies.

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

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

States a specific verb and resource ("List the node types") and even specifies the returned tuple shape (type, category, label). It distinguishes itself from the sibling type_info by assigning that tool the job of returning fields.

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

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

Explicitly prescribes the when: use it to find a device's or load's type name before writing a node. It also names the follow-on alternative (type_info) and what that tool provides, leaving no routing ambiguity.

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, idempotent, non-destructive, and closed-world, so the safety profile is covered. The description adds value beyond that by disclosing what the resolution actually does (templates via 'use', id assignment, canonical numbers) and by stating what it does NOT do (electrical rules). It doesn't mention determinism caveats or performance, but the annotation-covered safety plus the transformation semantics make this strong.

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 dense clauses with zero filler; the transformation list is front-loaded, usage conditions follow, and the exclusion is last. Every phrase carries information.

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

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

An output schema exists, so return values need not be explained, and the description appropriately focuses on behavior and usage instead. Combined with the annotations, an agent has everything needed to call this correctly.

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

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

Only one parameter (document) and schema coverage is 100%, so the schema already documents accepted forms (JSON object, JSON text, file path when local). The description adds nothing about the input format beyond the schema, 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?

States a specific verb (return the resolved form) and enumerates the three transformations it performs: template expansion, id assignment, and number canonicalization. It clearly distinguishes itself from check (electrical rules) and apply_patch (which consumes the stable ids).

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

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

Explicitly names two use cases ('read a document exactly as the rules and drawings see it' and 'get stable ids before apply_patch') and an exclusion ('it does not apply the electrical rules (see check)'). This routes the agent to the correct sibling without 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?

Beyond the annotations (idempotent, non-destructive, open-world), the description discloses non-obvious behaviour: PDF writes to 'path' when given (a side effect), otherwise returns base64, requires the uniwire[pdf] extra, and the hosted server returns pdf_url instead. That local-vs-hosted split is genuinely useful context an agent cannot infer from annotations alone.

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

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

Front-loaded with the core action, then organized parameter-by-parameter. It does repeat some schema content (the enum values for kind and color), but the density of useful detail keeps it efficient overall.

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

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

Given eight parameters, file-writing behaviour and hosted/local divergence, the description covers what an agent needs to invoke it correctly. An output schema exists, so return values needn't be explained, though the SVG/PDF return notes are a helpful bonus. Missing only explicit sibling routing.

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

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

Schema coverage is 100%, so the baseline is 3. The description earns a step up by adding meaning the schema lacks: view is tied to a wire-marking view id, SVG returns every sheet or a specific 1-based 'sheet', PDF's path/base64/pdf_url branching, and the colour legend and IEC 60445 convention.

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 and resource: 'Draw the electrical diagram (schéma unifilaire / multifilaire)'. The agent knows exactly what output this produces, distinct from validation/normalisation siblings. It doesn't explicitly name a sibling to contrast with, which keeps it just 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?

Usage is only implied: you call this when you want a diagram. There is no explicit guidance on when to prefer this over viewer_link or when a diagram is not appropriate, and no prerequisites or exclusions are stated.

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

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

Annotations already declare readOnlyHint, idempotentHint, and destructiveHint=false, so safety is covered. The description adds behaviorally relevant context the annotations do not: this is a schema-introspection call that should precede any write, and it discloses the shape of the returned data (fields, units, enums).

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 zero filler; the primary purpose is front-loaded and the usage cue plus sibling reference follow immediately.

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

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

With an output schema present, the definition need not describe return values, and it already covers purpose, preconditions, and the content categories returned. Nothing an agent needs to invoke this two-parameter read tool correctly is missing.

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

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

Schema coverage is 100% and both parameters (lang, type) are documented in the schema, including the en/fr values and example type names. The description adds no syntax or format detail beyond the schema, 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?

States a specific verb+resource ('Return every field of one node type') and even enumerates the payload ('description, unit and allowed values (enums)'). It names the sibling list_types as the source of type names, so an agent can separate it from other read tools without opening a schema.

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

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

Gives a clear precondition for use: call it before writing or editing a node of that type, and points to list_types for obtaining valid type names. There are no explicit exclusions or when-not-to-use notes, but the workflow context is unambiguous.

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

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

The description adds real behavioral context beyond the annotations: it enumerates the validation dimensions, clarifies the non-overlap with check, and notes that issues name the node id and field where possible. The return-value detail (valid + issues, viewer_url, pdf_url) is somewhat redundant given an output schema exists, and nothing is said about cost or failure modes, keeping it below 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?

Front-loaded with the scope constraint and the sibling exclusion, which is the most decision-relevant information. The trailing sentence about return values is largely duplicated by the output schema and could be trimmed.

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

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

For a one-parameter, read-oriented validation tool with an output schema and annotations, the description covers purpose, scope boundaries, the alternative tool, and the shape of results. Nothing an agent needs in order to call it correctly is missing.

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

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

Schema description coverage is 100% and the single 'document' parameter is fully documented in the schema (object or JSON text, sources such as get_example/apply_patch/normalize, local file path). The description adds no parameter-level detail, so the baseline 3 applies.

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

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

States a specific verb (validate) and resource (uniwire document / electrical diagram JSON) and enumerates exactly what is checked: structure, types, ids, references, links. It explicitly contrasts the scope with the sibling tool 'check', so an agent can distinguish the two without opening schemas.

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

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

Explicitly says 'format only ... without the electrical rules (use check for those)', naming the alternative and the condition that selects it. The only minor omission is that no input-source prerequisites are restated, but the schema's parameter description already covers those.

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

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

The description adds real context beyond annotations: on the hosted server the document is retained 30 days so short links work and anyone with a link can open it, while elsewhere the payload travels in the URL fragment and is stored nowhere. That explains the privacy/persistence trade-off and implicitly why readOnlyHint is false; it does not mention auth requirements or rate limits, 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?

The output is front-loaded ('Links to a document:') and every clause carries information about link types or hosting behavior. The nested parenthetical listing editor capabilities is slightly dense but not wasteful.

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

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

With an output schema present, return values need not be explained, and the single parameter is covered by the schema. The description fills the remaining gap that matters — where the document lives and who can open it. Only failure behavior for a malformed document is unaddressed.

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

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

Schema description coverage is 100% and the single 'document' parameter is fully documented in the schema, including accepted forms and the producing tools. The description only says 'a document', so it adds nothing beyond the schema; 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?

The description states a concrete output: a viewer_url that opens the document in the uniwire web editor and a pdf_url for the drawn PDF. The resource (a document / electrical installation) is specific enough to distinguish it from siblings like render or validate, though it never explicitly names a sibling for 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?

Usage is only implied: the reader infers this is the tool to call when they need a shareable link or a PDF rather than a rendered image. There is no explicit when-to-use statement, no exclusion naming render or normalize as alternatives, and no prerequisites 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, idempotentHint, and destructiveHint=false, so safety is covered. The description adds real behavioral context beyond that: marks follow the wire_marking rules of a view, and the view defaults to the first one that declares them. It also notes columns are stable, hinting at output stability. This is useful context on defaults and derivation rules.

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

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

One compact paragraph that front-loads the core purpose and then the mode options, with no filler sentences. The awkward line breaks and inline French glosses cost a little readability but do not bloat the text.

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

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

For a 3-param, read-only export tool with an output schema present and full annotation coverage, the description supplies the derivation rules and default-selector behavior an agent needs. Return-value format need not be explained given the output schema. Nothing critical is missing.

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

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

Schema description coverage is 100%, so the schema already documents all three parameters, including the what enum values and the view default. The description largely restates the what semantics without adding format or syntax detail (e.g., how the view id is obtained). 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?

States a specific verb and resource: exports an installation's wiring as rows with stable column names, and enumerates the three output kinds (markers, wires, cables). The mode enumeration clearly delineates what the tool produces. It does not, however, explicitly differentiate itself from siblings such as bom or render, which also derive outputs from a document.

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 what values ('markers' for label printers, 'wires', 'cables') imply which use case each selects, giving implied rather than explicit guidance. There is no statement of when to prefer this tool over siblings like bom or list_types, and no exclusions. Adequate but leaves selection largely to inference.

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