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 real value beyond that by disclosing that ops are applied in order and that failures return ok=false with errors naming the failing op index (null meaning result validation failed). It doesn't explicitly confirm that edits are non-persisting (returned rather than saved), which the readOnly annotation implies but the text never states outright.

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?

Purpose and return value are front-loaded in the first clause, and the dense op examples each carry required information rather than filler. The block is long and the inline JSON snippets are syntactically crowded, but every line earns its place given the schema defers op detail to 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?

With an output schema present, return values need not be explained, yet the description still covers the failure shape, which is genuinely useful. The document and validate parameters are documented in-schema. A brief note on non-persistence/idempotency would round it out, but 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?

The ops parameter's own schema is an opaque array/string with additionalProperties:true and defers with 'see the description', so the description is the only source of the op grammar — set/add/remove/move/rename/link/unlink, their fields, ordering, and the null-value-removes and no-id-equals-root conventions. That is substantive semantics no structured field provides.

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

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

States a specific verb and resource ('Edit an electrical diagram by node id'), enumerates representative edit kinds (rating, circuit, load), and says the new document is returned. This cleanly separates it from read-only siblings like normalize, validate, render and viewer_link without needing their 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?

Usage is implied by the op grammar rather than stated: an agent can infer 'use this to make edits' but the description never says when to prefer apply_patch over normalize/render/validate, nor any ordering or prerequisite for getting a document first. Mentions get_example/apply_patch/normalize only as document sources, which is a weak routing hint.

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 already declare readOnlyHint/idempotentHint/non-destructive, so the safety profile is covered. The description adds genuinely useful context beyond that: the finding shape (level, rule, node id, message, source), the returned viewer_url/pdf_url, and the important caveat that 'scope' means automatic document-data checks, not a conformity certificate.

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 rule application, then the return shape — a sensible order. It is somewhat dense with parenthetical enumerations ('schéma unifilaire, tableau électrique') and repeats the profile identifiers already in the schema, which costs a little efficiency but does not obscure the point.

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 need not detail return values, yet it usefully characterises the findings, scope caveat, and URLs. It is complete enough to call correctly (accepted document forms, profile defaults), with the only real gap being no relationship to the sibling 'validate' 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 100%, so the schema already documents both parameters. The description's profile details ('nfc15100', 'enedis', 'iec60364', default behaviour, 'core' always applies) largely duplicate the schema's own wording, so the added meaning over structured data is marginal — 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?

States a concrete verb (check/validate) and resource (an electrical installation document: single-line diagram, panel, schéma unifilaire, tableau électrique) and names the rule profiles applied. It is clear what the tool does, but it never distinguishes itself from the sibling 'validate' tool, which sounds like an overlapping validation step.

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

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

It explains profile defaults ('default: the document's profiles', 'core always applies') and clarifies scope, which implies the tool's place in the workflow after get_example/apply_patch/normalize. However, it gives no explicit when-to-use guidance or contrast with the sibling 'validate', so the choice between the two is left to inference.

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

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

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?

Annotations already declare readOnly, idempotent, non-destructive, closed-world, so the safety profile is covered. The description adds genuinely useful operation context beyond that: the uniwire[pdf] extra requirement, the hosted-server pdf_url behavior, and that certain color modes add a legend.

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 purpose is front-loaded, but the body is a dense multi-clause run-on with embedded line breaks and a parenthetical example ('e.g. a wire-marking view') that adds little. Several clauses duplicate schema content rather than adding new 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, yet the description still usefully clarifies the return shape differences (SVG text vs written PDF vs base64 vs pdf_url), which is the main ambiguity for an 8-parameter render call. Combined with the annotations, an agent has what it needs to invoke correctly.

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

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

Schema description coverage is 100%, so every parameter (kind, view, format, color, sheet, conductor_colors, path, document) is already documented in the schema. The description largely restates those definitions verbatim, adding only the legend note and the 'numbered from 1' sheet detail, so the 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?

States a specific verb ('Draw') and resource ('the electrical diagram', with the domain terms schéma unifilaire/multifilaire), and immediately scopes it to the two variants via 'kind'. An agent can distinguish this rendering tool from siblings like viewer_link, wiring, or bom without opening the 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 clear conditional guidance for invocation: 'pdf' writes to 'path' if given, else returns base64, and on the hosted server returns pdf_url instead; 'svg' returns SVG text of every sheet or of 'sheet'. It never explicitly names an alternative sibling (e.g. viewer_link for interactive viewing), so it stops short of full when/when-not routing.

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?

Annotations already declare readOnlyHint=true, idempotentHint=true, destructiveHint=false, so the safety profile is covered. The description still adds real context: validation is format-only, each issue names the node id and field, and it returns viewer_url and pdf_url. It does not contradict any annotation, though the return details overlap with the output schema.

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

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

Two sentences, front-loaded with the core action and scope, then the return contract. Slightly dense and the trailing URL descriptions overlap with the output schema, 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?

An agent has everything needed to select and call it: scope boundary vs. 'check', accepted input forms via the schema, and an output schema covering return values. Complete, with the description's return-value exposition being mild redundancy rather than a gap.

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

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

Only one parameter and schema description coverage is 100%; the schema already explains that 'document' accepts a JSON object, JSON text, or a file path and where such values come from. The description adds no additional parameter meaning, 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 (a uniwire document), and immediately narrows the scope to 'format only: structure, types, ids, references and links' while naming what it is not ('without the electrical rules'). This lets an agent distinguish it from the sibling 'check' without opening either schema.

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

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

Explicitly routes the agent: use this for schema/format validation, use 'check' for electrical rules. That is an explicit when-to-use paired with a named alternative, which the calibration rubric reserves for a 5.

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

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

Annotations already declare readOnly, idempotent, non-destructive, and closed-world, so the safety profile is covered. The description goes further with genuinely non-obvious context: on the hosted server documents are retained 30 days so short links resolve and anyone with a link can open them, whereas elsewhere the document travels in the link after '#' and is stored nowhere.

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 'Links to a document' and each clause carries weight, covering viewer_url contents, pdf_url, and the storage/retention difference. It is dense and slightly run-on, but no sentence is 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?

An output schema exists, so return values need not be re-explained, and the description adds the retention and privacy context an agent would otherwise lack. For a simple read-only link generator with one fully documented parameter, this is nearly complete.

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

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

Schema description coverage is 100% and the single 'document' parameter is fully documented in the schema (accepts a JSON object, its JSON text, or a local file path). The description adds no syntax or format detail beyond the schema, so the baseline of 3 is appropriate.

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

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

States a specific verb and resource: it produces links (viewer_url and pdf_url) to open a uniwire document in the web editor and as a PDF. This is clearly distinguishable from siblings like render, wiring, or bom, which perform different functions.

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 what the returned links do and where the document is stored, which implies the use case (obtain openable/downloadable links). However, it never explicitly states when to prefer this over render, wiring, or bom, nor any prerequisites for calling 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, 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.