advancedrawio

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

It discloses that the tool builds a diagram with ELK layout/layers/legend and returns paths plus a PNG, which is useful without annotations. However, it does not mention side effects such as writing files to out_dir, overwriting behavior, or failure modes, so the behavioral burden is only partially met.

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

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

The description is one compact sentence with no filler; the verb, key diagram features, and return value are all front-loaded. It is appropriately sized for the information it provides.

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 a required free-form spec, optional formats/out_dir, no output schema, and several sibling build/lint/render tools, this short description leaves too much unspecified for correct invocation. It provides the return shape but not enough context to construct a valid spec or choose among siblings.

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 does not explain the required spec object, formats choices, out_dir, or name. The only implicit hint is PNG as an output format, which does not compensate for the completely 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 uses a specific verb ('Construye') with the diagram resource and names concrete traits (ELK layout, layers, legend, PNG output), so an agent can tell it apart from search/lint/doctor tools. However, it does not differentiate from sibling builders like build_from_mermaid or build_from_example.

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

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

No guidance is given for when to choose this tool over build_from_mermaid, build_from_example, or lint_diagram/render. There are no usage conditions, prerequisites, or exclusions.

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

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

There are no annotations, so the description must fully disclose behavioral traits. It mentions 'copia' and 'reemplaza' but does not state what the output is, whether it creates files, any side effects, or whether it requires a prior call to find_examples to get an example_id. This is a significant gap for a tool that likely produces artifacts.

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 with a clear, front-loaded purpose. The inline replacement format is compact and useful. It is efficiently worded, though it could have added parameter hints without becoming verbose.

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

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

Given four parameters, no output schema, and no annotations, the description is far from complete. It does not explain how to obtain an example_id, what 'name' and 'out_dir' control, or what the tool returns. An agent would likely need external knowledge or trial and error 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 description coverage is 0%, so the description must compensate. It clarifies the format of 'replacements' with an inline example ({"texto viejo": "texto nuevo"}), which adds meaning beyond the schema's generic object type. However, it leaves 'example_id', 'name', and 'out_dir' semantically unexplained, so the compensation is only partial.

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

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

The description states a clear action: 'Copia un ejemplo oficial y reemplaza sus textos', which identifies the verb and the resource. It also provides a domain distinction ('diseño y no del layout') that helps separate it from layout-focused siblings, though it does not name any sibling 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?

It gives concrete usage contexts (planos, infografías, wireframes, canvases de negocio) and a heuristic about design vs. layout, which implies when to prefer this tool. However, it lacks explicit exclusions or mentions of alternative tools, so an agent must infer the boundary with siblings like build_diagram or build_from_mermaid.

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

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

With no annotations, the description carries the behavioral disclosure burden. It does disclose that Mermaid is converted into native editable draw.io shapes and arranged, which is useful. However, it does not mention side effects such as file creation, out_dir behavior, or whether the result is returned or written.

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 concise, with two sentences that both earn their place: one for the input format and supported types, and one for the conversion behavior. It is front-loaded and contains no filler.

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

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

The tool has three parameters, no annotations, and no output schema, so the description needs to be more complete. It fails to explain output behavior, the purpose of out_dir, or what the agent should expect after invocation, making it insufficient for correct usage.

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 compensate. It only implicitly clarifies that 'code' is Mermaid source, but it provides no meaning for 'name' or 'out_dir', leaving key parameters unexplained.

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

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

The description clearly states the verb 'Construye' and the specific resource 'desde Mermaid', listing the supported diagram types. It also differentiates from sibling tools like build_diagram and build_from_example by specifying the Mermaid source format and the draw.io conversion behavior.

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

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

The description implies the tool should be used when the input is Mermaid code and lists supported diagram types, giving reasonable context. However, it does not explicitly name alternatives or provide exclusion criteria for when to choose build_diagram or build_from_example instead.

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

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

No annotations are present, so the description must disclose behavior. It only says it checks availability, but it does not state whether the tool is read-only, what happens if components are missing, or what the return value is. This leaves significant ambiguity for a tool that likely returns a status or boolean.

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

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

The description is a single, front-loaded sentence with no filler. It is appropriately terse for a zero-parameter tool, though it could be slightly more informative without becoming verbose.

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

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

With no output schema and no annotations, the description should explain what the tool returns or what 'available' means, but it does not. An agent cannot predict the output format or error behavior, making the tool under-specified for a health-check operation.

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

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

The tool has zero parameters, so per the rubric the baseline is 4. There is nothing to add beyond the schema, and the description correctly does not invent 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 clear verb ('verifica' / verifies) and the specific resources (draw.io Desktop and the icon index). It distinguishes this tool from all siblings, which are about searching, building, or linting, so an agent can easily identify it as a health check.

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

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

There is no guidance on when to call this tool relative to the siblings. For a health-check tool, one would expect a note like 'run before building or rendering to ensure the environment is ready,' but the description provides no such 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?

With no annotations provided, the description carries the full burden of behavioral disclosure. It does reveal useful behavioral traits: the corpus size (770 examples), the no-argument behavior of returning available types, and the list of valid pattern values. However, it does not describe the return format, how limit affects results, or whether the search is read-only, leaving meaningful gaps.

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

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

The description is compact: two sentences, with the main action front-loaded and the pattern list in a single terse line. It avoids filler and is easy to scan. It sacrifices some completeness, but it remains well-structured and appropriately short for a search tool.

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

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

The tool has five parameters, no output schema, and no annotations, yet the description only covers the 'patron' values and the no-args return behavior. It does not explain how parameters interact, what a typical result looks like, or the role of 'libreria' and 'query'. Given the sibling context and parameter count, this is incomplete for confident invocation.

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

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

Schema description coverage is 0%, so the description must compensate. It explains the 'patron' parameter by listing suggested values and mentions the no-argument behavior, but it does not clarify 'query', 'limit', 'tipo', or 'libreria'. With five parameters, the agent has insufficient meaning for most of them.

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: 'Busca entre los 770 ejemplos oficiales de jgraph', identifying it as a search tool over the official JGraph example corpus. It also adds a distinctive behavioral note that with no arguments it returns available types. However, it does not explicitly differentiate it from siblings like get_example or build_from_example, so it falls just short of a 5.

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

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

No explicit when-to-use or when-not-to-use guidance is provided relative to sibling tools. The description only implies a possible workflow: call without arguments to discover types, then use 'patron' to filter. It never states that get_example should be used for retrieving a specific known example or that build_from_example is for building from an example, leaving the selection to agent inference.

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

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

With no annotations, the description must carry the full transparency burden. It discloses the kind of content returned (styles, layers, replaceable texts, image) but does not state that this is a read-only retrieval, does not indicate any authentication or error behavior, and does not describe the response format. This is a significant gap for a tool with zero structured behavioral hints.

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

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

The description is a single compact sentence that front-loads the core concept and then packs the relevant content areas into a list. It is not bloated, though the colon-separated list is dense and could be structured more cleanly.

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 get-by-id tool with no output schema and no annotations, the description provides useful context about what the recipe contains and how to use it (copy styles to spec). However, it omits how example_id selects the example, what the exact output structure looks like, and any edge cases or limitations, so it is not fully complete.

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

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

Schema description coverage is 0% and the description never mentions example_id, its meaning, or how to obtain a valid value. The agent is left to guess that the ID selects a specific example; no semantic enrichment is provided.

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 resource ('a recipe of an example') and enumerates its contents: styles by role, layers, replaceable texts, and image. This makes the tool's purpose reasonably clear, though it relies on the tool name 'get' for the action verb and does not explicitly differentiate it from siblings like find_examples or build_from_example.

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

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

It gives an actionable directive: 'Copy the styles to the spec instead of inventing them,' implying this tool is a style reference when building schemas. However, it does not state when to prefer this tool over alternatives such as find_examples or build_from_example, nor does it provide explicit exclusion criteria.

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

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

No annotations exist, so the description carries the full burden. It communicates that this is a non-mutating review and lists what is checked, but it does not disclose the result format, whether failures are reported, or any side effects. An agent cannot predict what the tool returns after invocation.

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 purpose, followed by a compact list of the exact checks. No filler words or redundant schema 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?

The tool has no output schema and no annotations, so the description must cover both invocation and expected result. It adequately names the checked aspects, but it leaves a critical gap by not describing what the agent receives after the review is complete, such as a report, exit codes, or detailed issues.

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?

With schema description coverage at 0%, the description must compensate. It only vaguely implies that 'path' refers to a .drawio file via 'de un .drawio'; it does not specify path resolution, absolute vs relative, or any constraints. The single parameter is just barely covered.

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

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

The description clearly states a specific verb and resource: it performs an 'objective review of a .drawio' and enumerates the exact checks (overlaps, edges crossing nodes, isolated nodes, proportion). This distinguishes it from the diagram-generation siblings like build_diagram and render, though 'doctor' may overlap.

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

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

The description implies usage by naming the validation concerns, so an agent can infer when to run it. However, it does not explicitly state when to use this tool over alternatives such as 'doctor', and it gives no exclusions or preconditions.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. It only says 'renders to PNG for visual review' without mentioning side effects, output location, permissions, error cases, or any constraints. This is a minimal statement that omits critical behavioral details an agent would need.

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

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

The description is a single concise sentence with no redundancy. It front-loads the action and purpose, making it easy to parse quickly.

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

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

Given the tool's simplicity (one parameter, no output schema), the description covers the basic function but omits details like where the PNG is produced, return format, or any prerequisites. It is minimally complete for a straightforward render operation, but not rich enough to fully guide an agent without additional assumptions.

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

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

The input schema has a single 'path' parameter with 0% description coverage. The description implies 'path' points to an existing .drawio file but does not explicitly define the parameter's format, allowed values, or required structure. It provides marginal implied meaning but fails to adequately compensate for the lack of schema documentation.

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 ('Renderiza'), resource ('.drawio'), and output (PNG) with a clear purpose (visual review). It implicitly distinguishes itself from sibling tools that focus on searching, building, or linting, making its role unambiguous.

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

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

The purpose is clear enough to infer when to use it (when you want to visually inspect an existing drawio file), but it does not explicitly mention when not to use it or point to alternative tools. Since the context is self-evident and the sibling list provides indirect alternatives, a 4 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?

With no annotations, the description carries the full burden of behavioral disclosure. It discloses that the result includes a title to be used as 'product', which is a useful trait, but it omits details about search matching behavior, result limits, error cases, or any constraints. It adds some context but remains thin.

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

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

Two short, efficient sentences. The purpose is front-loaded, and the second sentence provides a key usage hint. There is no fluff or repetition, making it appropriately concise and well-structured.

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

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

The tool is simple (2 params, 1 required), and an output schema exists, so the description need not detail return values. It covers the purpose and a key usage instruction, but lacks guidance on query formulation and limit semantics, which are needed for correct invocation. It is minimally adequate but has clear gaps.

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

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

Schema description coverage is 0%, so the description must compensate by explaining the parameters. It does not mention 'query' or 'limit' at all, leaving the agent to infer their meaning from names and types. The instruction about the returned title pertains to output, not input parameters, leaving a significant gap in guidance.

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

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

The description clearly states the action and resource: 'Busca iconos' (search icons), with examples of categories (GCP, AWS, Azure, brands). It distinguishes from sibling search_shapes by specifying icon types, and the instruction to use the returned title as 'product' adds functional clarity.

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

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

The description provides a specific instruction on how to use the returned title as 'product', but it does not explain when to prefer this tool over alternatives like search_shapes, nor does it mention any exclusions or conditions. Usage is implied by the name and purpose rather than explicit.

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

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

With no annotations provided, the description carries the full burden of behavior disclosure. It reveals that results are vector stencils with style and size suitable for node objects, which is useful, but it does not describe any limitations, output details, or whether the operation is read-only. The extra context about style/size adds some value beyond the bare tool name.

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 compact and front-loaded with the core resource and purpose. The second sentence is a useful routing instruction with no wasted words; every phrase earns its place.

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

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

The tool is simple, has an output schema, and the description covers the main use case and the GPC icon alternative. However, it leaves parameter semantics to inference, which is a real gap for an agent trying to invoke search_shapes correctly with query values.

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 does not explain the query parameter or the limit parameter. The list of stencil families gives a rough sense of what query terms might be, but there is no explicit guidance on query format, accepted values, or how limit behaves.

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 identifies the resource (vector stencils for AWS, Azure, Cisco, BPMN, UML, networks, P&ID) and how results are meant to be used (as a node with style, w, and h). It does not state an explicit search/return verb, but the tool name and the provided use context make the operation clear. It also differentiates from search_icons by routing GCP icon needs to that sibling.

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

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

It gives explicit guidance to use search_icons for GCP icons, which is a clear when-not-to-use-this-tool signal. The listed stencil categories imply the intended use cases, though it does not mention other sibling alternatives or broader exclusion conditions.

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 are absent, so the description carries the full burden. It implies a read-only or informational reference by saying 'Formato...' but does not state that explicitly, nor does it disclose what the tool actually returns or how it behaves. This is minimal behavioral disclosure.

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

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

The description is extremely short and has no fluff, which is good for conciseness. However, it is under-specified to the point of being almost a bare label; it offers no introductory phrase or structured context that would help an agent consume it.

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

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

With no parameters and an output schema present, the missing return-format detail is acceptable. Still, the description lacks practical context such as when to open this reference, how it relates to build_diagram, and what kind of information the reference contains beyond a vague 'spec JSON format.' It is minimally viable but not complete.

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

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

The tool has zero parameters, so the baseline of 4 applies. The description adds no parameter detail, which is fine because no parameters exist and the schema trivially covers them.

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 identifies the subject (the JSON spec format used by build_diagram) but never states an action or verb: it reads as a label rather than a tool purpose. It is somewhat distinguishable from siblings because it names build_diagram, but an agent cannot tell whether this tool returns, describes, validates, or edits that format.

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

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

No guidance is given for when to use this tool versus any alternative. The name and sibling list suggest it is a companion to build_diagram, but the description does not say 'consult this before calling build_diagram' or mention any exclusions.

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