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

With no annotations, the description carries the full burden. It usefully discloses what the operation does NOT touch (frames and comments) and that it is a custom, non-API layout, but it says nothing about mutation semantics, permissions, idempotency, or what happens to nodes outside the target area.

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

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

Two short sentences, front-loaded with the core behavior and followed immediately by the constraint on ordering. No filler, though the layout could be tightened and parameter defaults are not addressed.

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 state-mutating layout tool with four undocumented, optional parameters and no annotations or output schema, the description says too little. An agent cannot tell whether omitting graph/package applies the layout to the current graph, nor how spacing values are interpreted.

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

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

Schema coverage is 0%, so the description must compensate for four undocumented parameters (graph, package, spacing_x, spacing_y). It never mentions any of them or explains what null/default means, leaving only the faint implication that column layout involves spacing.

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 and resource: it orders nodes into left-to-right columns, and explicitly notes it is a custom layout the API does not provide. It also hints at scope by saying it does not move frames or comments, though it never names a sibling tool it competes with.

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

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

Gives an explicit ordering instruction: run it before creating frames, since it will not reposition frames or comments afterward. It does not name an alternative tool or spell out when not to use it, but for a tool with no direct sibling equivalent the context 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?

With no annotations, the description carries the full burden and does disclose non-obvious traits: it runs headless without Designer, writes to a predictable output_dir/<sbsar>/<name> layout, and continues past failures with results reported in 'failed' and 'jobs'. It omits overwrite behavior, concurrency, and what the 'jobs' entries actually contain, so it stops short of full transparency.

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

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

Four short sentences, front-loaded with the core capability, then the data shape, output location, failure semantics, and the resolution caveat. Nothing is padding, though the ordering could put the resolution note closer to the parameter discussion.

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 seven-parameter mutation tool with no annotations and no output schema, the description covers the critical behaviors (headless execution, partial failure, output layout) but leaves the return payload underspecified – 'jobs' is referenced but never explained – and never mentions bit_depth or output_format, which an agent would otherwise have to guess.

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, and it does for part of the surface: it defines parameter_sets as a list of {name, parameters} and explains the resolution default for width/height. The other parameters – bit_depth, output_format, sbsar_paths, output_dir beyond the path template – get no added meaning, leaving several of seven parameters undocumented in both places.

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

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

The description names a concrete verb and resource – batch-rendering multiple .sbsar packages with multiple parameter sets – and the note 'No necesita Designer abierto' implicitly separates it from the graph-bound render_outputs sibling. It never names that sibling outright, so the differentiation is inferred rather than stated.

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

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

The guidance is implied rather than explicit: it says Designer need not be running, which suggests this is the offline/headless path, and it tells the agent to supply width/height to avoid the 256x256 default. There is no direct statement of when to prefer this over render_outputs or export_sbsar, and no prerequisite list (e.g. sbsrender availability).

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 at all, the description carries the full behavioral burden and falls short. It does not say whether an existing connection on to_input is replaced or causes an error, whether graph/package select the working context, or what the tool returns on success or failure. For a graph-mutating tool that is a significant gap.

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

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

Three short sentences, front-loaded with the core action and no filler. But the telegraphic style, plus Spanish text against an English schema, makes some sentences ambiguous (e.g. 'usa la primera salida' without saying whose output).

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 six-parameter mutation tool with no annotations and no output schema, the definition is too thin: it omits mutation side effects, error conditions, and the meaning of graph/package. It does at least cover the one non-obvious default and route the agent to get_node_info for ids.

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

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

Schema description coverage is 0% across six parameters, so the description must compensate and only partly does: it explains the from_output default (first output is used when omitted). The graph, package, from_node, to_node and to_input parameters are only named in the schema, with no added meaning about formats, optional context selection, or how ids are obtained beyond the get_node_info pointer.

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 operation: connecting an output of one node to an input of another. This is clearly distinguishable from siblings like create_node or set_node_parameter. It loses a point because it never says what a 'node' or 'graph' context is here, leaving the resource scope fuzzy.

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?

Implies usage (wire nodes together) and points to get_node_info as the way to obtain the ids needed. However, it gives no explicit when-not guidance, no mention of prerequisites such as an open graph, and no statement about what happens if the input already has a connection.

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 at all, the description carries the full behavioral burden, and it does disclose one genuinely useful trait: the cook runs headless without Designer open. It says nothing about overwriting an existing .sbsar, expected duration, failure modes, or that sbscooker must be installed — gaps that matter for a mutation/build operation.

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

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

Two short sentences, front-loaded with the core action and followed by the key constraint. Nothing is wasted, though the terseness leaves little room for the missing parameter and behavioral detail.

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

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

No annotations, no output schema, and 0% parameter coverage mean the description is the only source of semantics, and it does not supply them: output location, naming/default behavior, and overwrite semantics are all unaddressed for a 2-required-parameter build tool.

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

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

Schema description coverage is 0%: input_path, output_dir, and output_name have no meaning in the schema beyond their titles. The description only implies that the input file is .sbs and that a .sbsar is produced somewhere, but never explains which parameter carries which, or what output_name defaults to.

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 a concrete transformation: 'Cocina un .sbs a .sbsar con sbscooker' — the agent knows exactly the input and output artifact types and the underlying tool used. It does not name the closest sibling (export_sbsar) explicitly, so differentiation is inferential rather than stated.

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

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

'No necesita Designer abierto' implies the condition that selects this tool over export_sbsar (headless / Designer closed), but the description never names that alternative or states when to prefer each. The guidance is implied rather than spelled out.

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

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

No annotations are supplied, so the description carries the full burden. It does disclose a genuinely non-obvious behavioral trait — that x and y become node-relative when node_id is given — which structured fields cannot express, but it says nothing about permissions, whether a graph context is required, or what comes back after creation.

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

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

One compact sentence with the conditional mode stated up front and no redundant phrasing. It is efficient, though it is so terse that qualifiers had to be dropped, leaving graph and package uncovered.

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 core call path (text, optional node_id, optional coordinates) is adequately described for a tool with no output schema and no annotations. However, with 6 parameters and 0% schema coverage, the missing meaning of graph and package leaves an agent guessing on a non-trivial subset of the inputs.

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

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

Schema description coverage is 0% across 6 parameters, so the description must compensate. It clarifies text, x, y and node_id semantically (including the coordinate frame switch), which is real value, but leaves the graph and package parameters completely unexplained.

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

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

States a specific verb and resource ("Crea un comentario") and immediately distinguishes two creation modes: a free-floating comment versus one bound to a node via node_id. That covers what the tool does in one clause 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?

The description implies the selection rule: pass node_id to attach the comment to a node, omit it for a loose comment. It does not address when this tool is appropriate versus siblings like create_node, nor any prerequisites (must a graph or package be open first?).

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 supplied, so the description carries the full behavioral burden. It does disclose one genuinely important trait — that the API does not associate nodes with frames, so grouping is cosmetic only — which prevents a costly misunderstanding. But it omits whether the frame is persisted, what is returned (no output schema exists), and whether coordinates are relative to the canvas origin.

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

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

Two short sentences with the core definition front-loaded and the caveat second — no filler. The second sentence mixes a behavioral fact with an instruction, which is slightly muddled but still earns its space.

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

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

For a 9-parameter mutation tool with no annotations, no output schema, and zero schema description coverage, the definition is far too thin. It addresses one behavioral nuance well but leaves the agent guessing about parameter meaning, return value, and graph context.

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?

There are 9 parameters with 0% schema description coverage, so the description must compensate and it largely does not. It hints at positioning via 'colocalo alrededor' but says nothing about title (required), x/y defaults, width/height, color array format, or the graph/package scoping 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 first sentence gives a specific verb and resource ('Crea un frame') and immediately clarifies what a frame is conceptually — a purely visual grouping. It distinguishes the tool from node-creation siblings implicitly by describing frame semantics, though it never names an alternative like create_node or create_comment.

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

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

The phrase 'colocalo alrededor de ellos' implies the intended workflow: draw a frame around existing nodes for visual grouping. However, there is no explicit when-to-use vs. when-not guidance, no mention of prerequisites (does a graph need to be open?), and no reference to the sibling create_node or create_graph tools.

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

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

With no annotations, the description carries the full burden and does reasonably well: it discloses that omitting package produces an unsaved new package, and that width/height are Designer-only and do not persist into the exported .sbsar. It still omits what is returned (a graph handle/id), whether the graph is persisted, and any auth or application-state requirements.

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 short and front-loads the primary action plus the package caveat, then tacks on parameter notes. The sentences are terse, though the width/height note is split awkwardly and the format value list is dumped without framing.

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 5-parameter creation tool with no annotations and no output schema, the description covers most parameter semantics but says nothing about the return value (the caller likely needs a graph identifier to chain into create_node/connect_nodes) and nothing about required application state.

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

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

Schema description coverage is 0%, so the description must compensate, and it explains width/height (Designer canvas size in powers of 2, re-specified at render time) and enumerates the four format values, plus the null-package behaviour. The required 'name' parameter is left entirely unexplained, which is the main gap.

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

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

The description opens with a specific verb+resource ('Crea un grafo de composicion y lo abre'), and the note about the package parameter distinguishes a create-new-package case from adding to an existing one. It does not explicitly name open_graph as the alternative for existing graphs, so sibling differentiation is only implicit.

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

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

Usage is implied by the creation semantics and the package behaviour, and it usefully routes the agent to render_outputs when width/height matter at render time. There is no explicit statement of when not to use this tool (e.g. to open an existing graph, use open_graph) or of prerequisites such as an active Designer session.

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 supplied, so the description carries the full behavioral burden. It discloses only that a node is created and its id returned; it says nothing about side effects on the active graph, permission or auth needs, what happens when all parameters are omitted (all seven are optional), or whether the new node is auto-connected.

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

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

Three short sentences, front-loaded with the action and closed with the return value; no filler. It is arguably too terse for a seven-parameter tool, but nothing is wasted.

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

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

For a mutation tool with seven optional parameters, zero schema descriptions, and no annotations or output schema, the definition leaves large gaps: positioning (x, y), target graph selection, and package scoping are undocumented. An agent could not confidently construct a call beyond the definition-vs-library case.

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

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

Schema description coverage is 0% across seven parameters, so the description must compensate and it only partly does. It usefully clarifies the mutually exclusive definition-vs-library choice and the role of library_graph, but x, y, graph, and package remain completely undefined.

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

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

The description names a specific verb and resource ("Crea un nodo") and states the return value ("Devuelve el id del nodo"), so the action is unambiguous. It does not distinguish itself from siblings such as create_graph or create_output_node, so it stops short of a 5.

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

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

It gives real guidance on which parameter family to use: 'definition' for atomic nodes and 'library' for Adobe library filters, with 'library_graph' when a package holds several. That informs how to invoke the tool, but there is no guidance on when to choose this over create_output_node or how it relates to the currently open graph.

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. It implies a mutation (creating a node) and hints that source_node wires it to a source, but never says which graph is affected when 'graph' is null, whether an existing node is replaced, or what identifier the caller receives back.

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

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

Two short sentences with the core action front-loaded and no filler. The line break before the source_node sentence is slightly disjointed but costs nothing.

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 9-parameter mutation tool with no annotations and no output schema, the description is far too thin: most parameters are unexplained and there is no indication of return value or side effects. The only compensating strength is the implicit enumeration of valid usage 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% across 9 parameters, and the description only explains two of them: it turns the free-form 'usage' string into an implicit enum of six values and clarifies that source_node links the output to a source. Position (x, y), graph, label, package, identifier and especially the pairing of source_node with source_output remain undefined.

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

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

The description gives a specific verb and resource ("Crea un nodo de salida") and even names the accepted usage categories, so the agent knows exactly what is being produced. It does not, however, distinguish this from the sibling create_node, leaving ambiguity about which tool to pick for a generic node.

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

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

The second sentence implies the connection workflow via source_node, which is useful context. There is no explicit when-to-use versus create_node/connect_nodes, and no stated prerequisite that a graph must be open or supplied.

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 supplied, so the description carries the full behavioral burden. It usefully discloses that connected edges are destroyed along with the node, which is non-obvious cascade behavior, but it omits irreversibility, permission requirements, and how the graph/package scoping affects what gets deleted.

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

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

A single short sentence with zero waste and the key information front-loaded. The brevity is appropriate stylistically, though it borders on under-specification for a destructive operation.

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

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

For a destructive tool with no annotations, no output schema, and three undocumented parameters, one sentence is not enough. An agent cannot tell whether the deletion is reversible, what happens to dependent nodes, or how graph/package disambiguate the target.

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

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

Schema description coverage is 0% across three parameters. The description only maps loosely to node_id and hints at connections; it says nothing about the 'graph' or 'package' parameters, which are the ones an agent would most need explained since they determine which node is targeted.

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

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

The description names a specific verb and resource ('Borra un nodo') plus a scope detail ('y sus conexiones'), so an agent knows exactly what the tool does and that deletion cascades to edges. It does not explicitly contrast with siblings like create_node or connect_nodes, but the verb makes the distinction obvious.

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

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

There is no guidance on when to delete versus alternatives such as disconnecting or modifying a node, no stated prerequisites, and no exclusion conditions. The agent must infer usage entirely from the name.

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

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

No annotations are supplied, so the description carries the full behavioral burden and largely drops it. It says nothing about whether this writes/overwrites an existing file at output_path, whether the export consumes or mutates the open package, what happens if Designer is mid-cook, or how failures surface. For a mutating file-writing tool this is a significant gap.

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

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

Two short sentences, zero filler, with the primary action front-loaded and the fallback routing immediately after. Nothing is padded or restated.

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

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

There is no output schema and no annotations, so the description must cover both behavior and return expectations; it covers the routing decision but not overwrite semantics or the result of the export. For a three-parameter export tool that is minimally viable rather than 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% across three parameters, so the description must compensate and does not. The word 'paquete' hints that the optional 'package' argument defaults to whatever is open, but output_path format/constraints and the overwrite flag (default false) are never explained, leaving the most consequential parameter undocumented.

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

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

States a specific verb and resource (export the open package to .sbsar) plus the execution context (from Designer), which is enough to tell it apart from generic cooking siblings. It stops short of 5 only because 'paquete abierto' is left implicit rather than tied to the optional 'package' parameter.

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: if Designer is not open, use cook_sbs instead. That is a genuine when-not/alternative rule, unusual at this level. It does not state any prerequisite beyond an open Designer session, nor when to prefer this over saving the package first.

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 load; it does disclose meaningful behavior about binding and the no-default fallback, which goes beyond the bare schema. It omits whether the new parameter persists without save_package, what happens on duplicate identifiers, reversibility, and error conditions for a 13-parameter mutation tool.

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

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

Short and front-loaded: the creation action comes first, followed by binding semantics and the type enumeration. No filler sentences, though the enumeration of types is a dense tail rather than 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?

With 13 parameters, zero schema descriptions, no annotations and no output schema, the definition leaves most of the call surface unexplained, including scoping (graph/package), UI metadata (group/label/description) and numeric bounds. It is adequate for the core action only.

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

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

Schema coverage is 0% and 13 parameters are undocumented, while the description explains only three of them: node_id/node_parameter as a binding pair, the absent-default behavior, and the valid type values. Identifier, graph, package, group, label, description, min, max and step get no explanation anywhere.

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 concrete verb plus resource ('Crea un parametro del grafo') and explains the distinctive twist: the new parameter can be bound to a node's parameter via node_id + node_parameter. This separates it from sibling set_node_parameter well enough, though it never names the 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 conditional semantics: if node_id and node_parameter are supplied, the graph parameter controls that node parameter, and without a default the linked parameter inherits the node's current value. There is no explicit guidance on when to prefer this over set_node_parameter or how to handle an already-bound parameter.

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 behavioral burden. It does disclose the key prerequisite (Designer must be running) and what is returned, but it never states that the call is read-only, whether it fails or degrades when no package/graph is active, or what the response looks like.

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

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

Two tight sentences: the return payload is front-loaded and the precondition follows. No filler or redundant restatement of the name.

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

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

For a no-input, no-output-schema status tool, the description covers the essentials by enumerating the returned fields. The only gap is ambiguity around what 'herramientas detectadas' means and what happens when no graph or package is active.

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

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

The tool takes zero parameters, so semantics are trivially complete; the description correctly implies no input is needed and instead explains what is reported back. Baseline for zero-param tools 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 names a concrete verb (Devuelve) and enumerates the specific resources returned: Designer version, the active graph and package, and detected tools. An agent can tell this apart from siblings like get_node_info or list_graphs, though it never explicitly contrasts itself with them.

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

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

Usage is only implied: the precondition 'Requiere Designer abierto' signals when the tool will work, and the enumerated outputs suggest it is a state/environment check. There is no explicit when-to-use versus alternatives guidance 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?

No annotations exist, so the description carries the full burden. It does disclose the return payload (definition, inputs, outputs, parameter values, connections), which is genuinely useful behavioral context, but it says nothing about cost, error cases when a bad node_id/graph/package is supplied, or side effects.

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

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

A single front-loaded sentence that lists the returned fields without padding. Efficient, though the field dump could be grouped more readably and the language mismatch with the English schema titles is a minor friction.

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 does part of the job by enumerating return fields. However, for a three-parameter tool at 0% schema coverage it leaves the parameters and their interplay unexplained, so it is not fully sufficient.

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

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

Schema description coverage is 0% for three parameters, and the description explains none of them. The distinction between 'package', 'graph' and 'node_id' — including whether graph/package are needed to disambiguate a node — is left entirely undocumented.

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

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

States a specific verb ('Devuelve') and resource ('nodo') and enumerates the returned fields: id, definicion, entradas, salidas, parametros con valores, conexiones. This distinguishes it from the narrower sibling get_node_parameter, though it never names that 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?

No when-to-use guidance, no conditions, no alternatives. The agent must infer from the name alone whether to call this versus list_nodes or get_node_parameter; the description offers no routing signal.

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 disclosure burden. Saying it 'reads' implies non-mutation and it partially reveals the return shape (value plus type), but nothing is said about required permissions, whether 'graph'/'package' must match an open context, or what happens when the node or parameter is missing.

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

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

A single front-loaded sentence with no waste. It is arguably too terse rather than verbose, but structurally clean.

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

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

Wait — rescored: for a 4-parameter, zero-annotation, output-schema-less tool, the description must explain both the scope parameters and the return contract. It gestures at the return (value and type) but leaves graph/package and failure behavior invisible, and it is written in Spanish while every sibling name and the schema titles are English. Not adequate for the tool's complexity.

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

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

Schema description coverage is 0%, and the sentence only accounts for node_id and parameter in the vaguest terms. The optional 'graph' and 'package' parameters — which plausibly scope the lookup to a particular open graph or package — are entirely unexplained in both schema and description.

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

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

States a specific verb ('Lee') and resource ('valor y tipo de un parametro de un nodo'), which is enough to tell it apart from the sibling set_node_parameter (write counterpart) and get_node_info (whole-node info). It does not explicitly name those siblings, so differentiation is inferential 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?

There is no guidance on when to use this tool versus get_node_info, list_nodes, or get_app_info, and no exclusions or prerequisites are given. The agent must infer usage purely from the name.

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

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

With no annotations supplied, the description carries the full behavioral burden. It does add one genuinely useful trait beyond the schema: Adobe libraries are hidden from the listing, which affects what the agent will and won't see. It omits other relevant behavior such as read-only nature (only implied by 'Lista'), ordering, and what a returned entry contains.

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

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

Two short sentences with zero filler; the core action is front-loaded and the filtering caveat follows immediately. Nothing is redundant or padded.

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 zero-parameter list tool with no output schema and no annotations, the description covers what is enumerated and one important filtering behavior. It could say more about the shape of the returned package/graph entries, but the essential information for calling it correctly is present.

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

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

The tool takes zero parameters, so the baseline is 4; there is nothing for the description to disambiguate. The description does not introduce any parameter concepts that conflict with the empty schema.

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

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

The description uses a specific verb and resource ('Lista los paquetes abiertos y sus grafos de composicion'), so the agent knows it enumerates open packages together with their composition graphs. It does not, however, explicitly differentiate itself from siblings like list_nodes or get_app_info, which is the only thing keeping this from a 5.

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

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

There is no statement of when to use this tool versus alternatives such as list_nodes or open_graph. The word 'abiertos' implies a scope (only open packages), but that is inference rather than guidance, and there are no exclusions or prerequisites.

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

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

With no annotations, the description carries the full behavioral burden. It implies a read operation and discloses the default-to-active-graph behavior, but says nothing about permissions, result ordering, pagination, or whether nested frames are traversed recursively.

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

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

A single tight sentence with the resource list and the default behavior front-loaded. No filler, though the one sentence is doing a lot of implicit work.

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

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

For a two-parameter listing tool with no output schema and zero parameter documentation, the description should at minimum explain the graph vs package distinction and what the returned entries look like. Neither is addressed, so an agent must guess at invocation semantics.

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 weakly covers the "graph" parameter via "de un grafo (por defecto, el activo)", but the "package" parameter is entirely unexplained in both schema and description, leaving its meaning and interaction with graph unclear.

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 ("Lista") and concrete resources ("nodos, frames y comentarios de un grafo"), so an agent knows exactly what is enumerated. It does not explicitly contrast with siblings like list_graphs or get_node_info, which keeps it from a 5.

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

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

The parenthetical "(por defecto, el activo)" clarifies the default target graph, which implicitly tells the agent it can omit the graph argument. However, there is no guidance on when to choose this over list_graphs or get_node_info, nor any stated prerequisites.

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

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

With no annotations, the description carries the full behavioral burden. It usefully discloses that file_path requires a .sbs inside an allowed folder, which is a real constraint the agent needs, but says nothing about whether opening replaces the current editor state, what happens on failure, or permissions.

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, front-loaded with the core action, then per-parameter hints. Nearly zero waste; slightly terse to the point of omission on the graph parameter.

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

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

For a three-parameter, zero-annotation, no-output-schema tool, the description covers most of what an agent needs to attempt a call. It falls short by leaving 'graph' undefined and by not clarifying how the three selectors interact.

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

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

Schema coverage is 0%, so the description must compensate. It gives genuine meaning for two of three parameters (file_path loads a .sbs, package is a uid or path) but leaves 'graph' completely unexplained and does not state precedence or mutual exclusivity among the three.

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

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

The description states a specific verb and resource ('Abre un grafo en el editor'), which separates it from siblings like list_graphs and create_graph. It does not name those alternatives explicitly, so differentiation is implicit rather than stated.

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

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

There is no guidance on when to use this instead of list_graphs (to find a graph) or create_graph (to make one), nor any mention of prerequisites. The reader must infer the workflow entirely from the sibling names.

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 present, the description carries the full burden and does disclose genuinely non-obvious behavior: parameter validation ('Rechaza parametros que el archivo no exponga') and the fallback resolution of 256x256 when width/height are omitted — a silent failure mode an agent would otherwise get wrong. It stops short of stating overwrite behavior in output_dir, error modes, or what the call returns.

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

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

Front-loaded with the core action and the headless capability, then dense follow-up lines each carrying distinct facts about parameter format, validation, bit depth, and resolution defaults. No filler sentences; the only minor cost is that the fallback-resolution warning is buried at the end.

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

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

For a 10-parameter mutation-ish tool with no annotations and no output schema, the description covers the highest-risk unknowns (what gets rejected, what defaults apply). Gaps remain around 'usages'/'outputs' semantics and where/how files land in output_dir, but the essential calling information is present.

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

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

Schema description coverage is 0%, so the description must compensate and it partially does: it defines the 'parameters' map shape (identifier: value, vectors as lists), enumerates bit_depth values (8, 16, 16f, 32f), and constrains width/height to powers of two. It says nothing about 'graph', 'usages', 'outputs', or 'output_format', leaving four of ten parameters with no meaning beyond their titles.

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: 'Renderiza los mapas de un .sbsar con sbsrender', plus the notable constraint that Designer need not be open. This is clearly a rendering tool operating on an existing packed file, but it never contrasts itself with the sibling batch_render or cook_sbs, so an agent must infer which rendering path to pick.

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

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

Implies usage through the 'No necesita Designer abierto' remark and the note that unexposed parameters are rejected, which tells the agent it can run headless against a packaged file. However, it gives no explicit when-to-use vs. when-not-to-use guidance relative to batch_render, cook_sbs, or export_sbsar — the primary ambiguity for this toolset.

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 and does most of it: discloses main-thread execution, unrestricted read/write/delete over anything Designer can access, and the important fact that the allowed-folders restriction does not apply inside the code. Minor gaps remain (execution timeout, stdout/exception handling), so not 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 safety-critical constraint is front-loaded in capitals, and each sentence carries distinct information. Slightly verbose in places (the danger notice and the fallback notice overlap conceptually), but no wasted sentences.

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

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

For a tool with no annotations and no output schema, the description supplies the safety profile, the invocation gate, and the output convention (`result`). Only execution-environment details such as timeouts and error surface are unstated, which is acceptable but not exhaustive.

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

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

Schema coverage is 0%, so the description must compensate. It fully explains the `confirmed` gate protocol and gives the runtime contract for `code`: the `sd` and `app` objects are available and `result` is the return channel. It does not explain code format constraints (imports, entry point), so it stops short of a 5.

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 ('Ejecuta codigo Python arbitrario dentro de Designer') and adds execution context (main thread). It also differentiates itself from the 22 sibling tools with an explicit fallback rule ('Usala solo cuando ninguna otra herramienta sirva'), so an agent knows exactly where this sits in the toolset.

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 both a negative condition (only when no other tool suffices) and a mandatory workflow: display the code to the user, wait for approval, then call with confirmed=true. That is explicit when-to-use plus when-not-to-use, leaving nothing to inference.

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

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

No annotations are supplied, so the description carries the full behavioral burden and mostly fails it. It never states what happens to an existing package on disk, the effect of the undocumented overwrite flag, permission requirements for the 'allowed folder', or what a successful save returns.

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

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

Two short sentences, front-loaded with the action and followed by the one constraint worth knowing. Nothing is padded, though the brevity comes at the cost of the missing semantics noted elsewhere.

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

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

For a mutation tool with zero annotation coverage, three undocumented parameters, and no output schema, the definition is thin. The mention of a permitted-folder restriction is helpful, but an agent still cannot determine safe invocation from this alone.

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

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

Schema description coverage is 0% across three parameters, and the description only gestures at path (mentioning the .sbs extension and the folder restriction). The package parameter and especially the boolean overwrite flag receive no explanation, leaving a potentially destructive option undefined.

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

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

"Guarda un paquete" is a clear verb+resource, but it largely restates the tool name save_package. The added clause about a new package needing a .sbs path inside a permitted folder is the only information that distinguishes intent, and it does not separate this tool from siblings like export_sbsar or cook_sbs.

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 only through the phrase about a *new* package, suggesting it also applies to existing ones, but never says when to choose this over export_sbsar, cook_sbs, or any other save/serialize path. 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?

With no annotations at all, the description carries the full behavioral burden. It usefully discloses value encoding (vectors/colors as lists, enums by id, $outputsize as log2) and the non-obvious log2 scaling example, which is real added value. It says nothing about persistence (does the change save to the package or only mutate in memory?), required permissions, or failure modes for invalid parameter names — significant gaps for a mutation tool.

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

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

Three short, front-loaded statements with no filler; the operation is stated first and the encoding caveats follow. It is terse to the point of under-specification rather than verbose, which is the right side to err on.

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

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

For a 5-parameter mutation tool with zero annotations, no output schema, and 0% schema coverage, the description leaves too much unsaid: the optional graph/package scoping, whether the edit persists, and expected return/error behavior are all absent. An agent could call it, but not confidently predict its effect or recovery from failure.

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

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

Schema description coverage is 0% across 5 parameters, so the description must compensate. It clarifies the trickiest parameter (value: list for vectors/colors, id for enums, log2 for $outputsize) but leaves graph, package, and node_id completely unexplained — notably whether graph/package scope the operation to a non-active graph. Partial compensation only.

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?

"Cambia un parametro del nodo" states a specific verb (cambia) and resource (parametro del nodo), which clearly separates it from the read-side sibling get_node_parameter. It does not name that sibling explicitly, but the mutation scope is unambiguous.

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

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

The description gives value-encoding rules but no when-to-use guidance: it never says whether the graph must be open first, whether to prefer expose_parameter or create_node, or what to do when a parameter is not settable. The only usage context is implicit (the write counterpart of get_node_parameter).

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