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

Annotations already indicate mutation (readOnlyHint=false) and non-destructiveness (destructiveHint=false). The description adds that the operation is gated by direction, type, and duplicate checks, which is useful behavioral context beyond the annotations. However, it does not explain what happens if checks fail, whether the connection is reversible, or any side effects. The added value is moderate but not rich.

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

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

The description is a single sentence with no filler, front-loading the action. It is efficient and easy to parse. However, it sacrifices necessary detail for brevity, so it is not a perfect 5; it earns a 4 for being concise without being 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?

For a tool with 5 required parameters, a nested graph reference, and an output schema, the description is severely under-specified. It does not explain the graph structure, the meaning of the properties, or the expected outcome. While it mentions validation checks, it leaves too much to inference for the agent to use the tool correctly.

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

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

Schema description coverage is 0%, and the description provides no parameter-level explanations. It does not elaborate on 'graph', 'source_node', 'target_node', 'source_property', or 'target_property'. The phrase 'explicit runtime properties' loosely relates to source/target properties, but an agent cannot determine expected values or how the graph reference is constructed. This is a critical gap for a 5-parameter tool.

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 core action ('Connect') and the resource ('explicit runtime properties'), and mentions that it occurs after validation checks, which hints at a more specific scope than just any connection. However, it is somewhat vague about what 'runtime properties' means and does not explicitly name the node-based context (source/target). It partially distinguishes from siblings like sd_disconnect_nodes and sd_create_node but could be more precise.

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 'after direction, type, and duplicate checks' implies a usage context: this tool should be invoked after performing (or in the context of) these validations. However, it does not explicitly state when to use this tool versus alternatives, nor does it mention exclusions or prerequisites beyond those checks. The guidance is implied 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?

Annotations are all negative hints, so the description carries the burden of behavioral disclosure. It adds only the vague phrase 'explicit official usage metadata' and does not explain side effects, permissions, or impact on an existing graph. No contradiction with annotations, but significantly under-discloses for a mutating create 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?

The description is a single, front-loaded sentence with no filler or redundancy. It is concise and immediately states the action, though the brevity contributes to missing details.

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 complex nested types (GraphRef, UsageSpec) and 7 parameters, but the description only states the basic creation action. It does not explain what an Output node represents, how `usages` should be structured, or how `position`/`group` behave, making it incomplete for reliable agent 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%; the description does not explain any of the 7 parameters, including required `graph`, `identifier`, `label`, `usages`, and `position`. The phrase 'usage metadata' vaguely hints at the `usages` parameter but adds no concrete semantic value beyond the schema definitions.

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 the specific verb 'Create' and identifies the resource as 'an Output node', making the core purpose clear. It does not explicitly contrast with sibling tools like sd_create_node or sd_create_instance_node, so it stops short of full sibling differentiation.

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

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

The description gives no guidance on when to use this tool versus alternatives such as sd_create_node or sd_set_node_parameter. It lacks prerequisites, exclusions, or any recommended context beyond the bare capability.

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

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

The description aligns with annotations: 'Create' implies a write operation (readOnlyHint=false) and is consistent with non-idempotent and non-destructive status. It adds the behavioral context that the operation depends on a previously searched resource. However, it does not disclose other important behaviors like whether an active graph is required or how failures are handled, leaving moderate 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 a single, focused sentence that front-loads the action and source. Every word earns its place, with no redundancy or extraneous 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?

Despite having an output schema, the description is too sparse for a complex creation tool with 3 required nested parameters. It omits prerequisites like needing an active graph, the significance of the position, and resource validation. For a tool with 0% schema coverage and multiple nested objects, more context is needed for correct invocation.

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

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

With 0% schema description coverage, the description must compensate for the 3 required parameters, but it only references 'resource' from the search result. It does not explain the 'graph' parameter (target graph reference) or 'position' (coordinates), nor the structure of GraphRef or LibraryResourceRef. The description adds minimal meaning beyond what the schema field names imply.

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 ('Create one instance') and the specific source ('a resource returned by sd_search_library'). This distinguishes it from sibling tools like sd_create_node or sd_create_graph, which create different entities. The phrasing is precise and non-tautological.

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 explicitly ties usage to a precondition: use a resource from sd_search_library. This provides clear context on when to use the tool and implies a workflow (search first, then create). However, it does not explicitly mention alternatives or exclusions, so it falls slightly short of a 5.

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

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

With all annotations false, the description carries the burden of behavioral disclosure. It adds useful context: 'one verified atomic node' implies validation, and 'without auto-connecting it' explicitly states a key behavior. However, it does not disclose potential side effects (e.g., overwriting an existing node at that position), any permissions/requirements, or the nature of verification. The description adds some value beyond annotations but leaves significant behavioral 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 a single, concise sentence that is front-loaded with the main action ('Create one verified atomic node') followed by key constraints. Every word earns its place, with no redundant 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?

Given the tool's complexity (3 parameters, graph reference, position type) and the presence of an output schema, the description is somewhat under-specified. It lacks usage guidance, clear parameter explanations, and caveats about verification. For a create operation in a rich domain with many sibling tools, a one-sentence description is minimally viable but 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%, so the description must compensate. It loosely hints at 'position' (explicit position) and 'definition' (atomic node), but does not clarify the format of position (array of two numbers), the meaning of definition_id (which definition, how referenced), or what 'graph' refers to. The description adds minimal semantic value over the raw 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 ('create') with a clear resource ('verified atomic node') and explicit scope ('at an explicit position without auto-connecting it'). It distinguishes itself from sibling tools like sd_create_instance_node (which creates instance nodes) and sd_connect_nodes (which handles connections) by highlighting the atomic nature and no auto-connection.

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 no guidance on when to use this tool vs alternatives. It does not mention that sd_create_instance_node should be used for instance nodes, nor does it explain prerequisites like the graph needing to exist or whether 'verified' implies a validation step. The only implied usage is for creating atomic nodes, but no explicit context or exclusions are given.

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

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

Annotations already indicate destructiveHint=true and readOnlyHint=false. The description adds behavioral context: deletion is gated by confirm, and it operates on a single graph. This goes beyond the annotation but does not detail side effects like cascading deletion of edges.

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, front-loaded with the action and key constraint. No redundant or filler content.

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 mutation tool, the description is minimal. It does not cover what happens if confirm=false, how errors are reported, or the impact on related nodes/edges. However, the output schema and annotations provide some structural and safety context, so it is borderline adequate.

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 links 'confirm true' to the confirm parameter and 'explicit nodes' to node_identifiers, but doesn't explain the format of identifiers or the GraphRef structure. Some semantic value is added, but gaps remain.

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 tool deletes explicit nodes from one graph, with a specific condition (confirm=true). This distinguishes it from siblings like create or move tools, and the phrase 'explicit nodes' clarifies that only listed nodes are affected.

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 condition 'only when confirm is true' gives clear context for when the deletion actually occurs, implying the tool is safe to call with confirm=false for validation. However, it does not mention alternatives or explicitly state when not to use it.

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

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

Annotations provide limited safety info (all false). The description adds context that the tool handles only 'one explicit existing' connection, which is useful behavioral information. It does not disclose side effects such as whether the operation is reversible or what happens if the connection does not exist.

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 under-specified for a tool with 5 required parameters. It is concise but not appropriately sized; it omits necessary context and reads more like a title than a useful description.

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 5 parameters, 0% schema coverage, and no guidance on side effects or return values (despite an output schema), the description is incomplete. It does not explain what 'explicit' means, prerequisites, or the operation's outcome, leaving significant gaps for an agent 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%, and the description does not explain the parameters. While parameter names like source_node, source_property, target_node, target_property are fairly self-explanatory, the description adds no additional meaning about how they relate or any requirements, so it fails to compensate for the lack of schema descriptions.

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 action ('Disconnect') on a specific resource ('one explicit existing property connection'). It distinguishes from siblings like sd_connect_nodes and sd_delete_nodes by focusing specifically on disconnecting an existing connection.

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 'explicit existing property connection' implies the tool is intended for disconnecting connections that already exist and are explicit, providing an implied usage context. However, it does not explicitly mention when to use it over alternatives or any 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?

Annotations declare destructiveHint=true, so the write nature is already known. The description adds the prerequisite that the package must already be saved ('one saved package') and that publication settings are explicit, which is useful context. However, it does not reveal overwrite behavior, side effects, or failure modes beyond what the parameters suggest.

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 concisely conveys the core action and key differentiator. However, its extreme brevity leaves out necessary nuance that would make it more helpful, slightly reducing the score from perfect.

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?

Despite having an output schema and complex input requirements, the description does not explain parameter semantics, usage context, or side effects. For a tool with 9 required parameters and a destructive hint, this level of detail is inadequate for an agent to select and invoke it correctly without additional documentation.

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 0% schema description coverage and 9 required parameters, the description should compensate by explaining parameter roles. It only mentions 'explicit publication settings' in a general sense, providing no specific meaning for compression_mode, expose_output_size, or other fields. The agent would have to infer parameter semantics entirely from names and enums.

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

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

The description clearly states the tool exports a saved package to .sbsar with explicit publication settings. This distinguishes it from siblings like sd_save_package, which saves in the native format, and sd_save_package_as, which likely saves without the .sbsar export focus.

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 for exporting to .sbsar with publication settings, but it does not explicitly contrast with alternatives or state when not to use it. No clear prerequisites or exclusions are provided, so guidance is inferred 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?

Annotations already declare this as read-only, idempotent, and non-destructive. The description adds the qualifier 'editable' and specifies the items counted, which provides some context beyond annotations. However, it does not disclose potential edge cases (e.g., behavior when no graph is active) or return format details, but the output schema covers return details.

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 unnecessary words. It captures the essential purpose efficiently, earning a perfect score for conciseness.

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 (no parameters), rich annotations, and presence of an output schema, the description is sufficiently complete. It clearly states what is read, and the output schema handles return value details, so no additional explanation is needed.

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 description is not required to explain parameter meanings. The baseline for no-parameter tools is 4, and the description accurately reflects the tool's no-input nature.

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 tool's function: 'Read the current editable graph, package, node count, and selection count.' The verb 'Read' and specific resources (editable graph, package, node count, selection count) distinguish it from sibling tools like sd_get_graph_snapshot or sd_get_selection, which have different scopes.

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 no guidance on when to use this tool versus alternatives. It does not mention prerequisites, exclusions, or alternative tools. Given the many sibling tools, explicit usage context would be valuable but is absent.

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 (readOnlyHint, idempotentHint, destructiveHint) already declare this as a safe, read-only operation. The description adds value by specifying precisely what data is read (version, Python, platform, etc.), which goes beyond the annotations and gives the agent a clearer behavioral picture.

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 that lists all key data categories without filler or redundancy. It is appropriately sized for a parameterless read 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?

Given zero parameters and the presence of an output schema, the description only needs to convey what the tool returns. It does so by listing the data categories, making it complete for this simple read operation. No additional context is necessary.

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 no parameters, so there is nothing to document. The input schema is empty (100% coverage), and the description naturally cannot add parameter details. A score of 4 aligns with the baseline for zero-parameter tools.

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 the specific verb 'Read' and enumerates a clear list of resources (version, Python, platform, open packages, graph, capabilities), making the tool's purpose unambiguous. This distinguishes it from sibling tools like sd_get_capabilities or sd_get_active_graph, which target narrower subsets.

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 is for reading overall application info, giving clear context for when to use it. However, it provides no explicit guidance on when not to use it or which alternatives (e.g., sd_get_capabilities) might be more appropriate for specific needs.

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

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

Annotations already declare readOnlyHint, idempotentHint, and destructiveHint, covering the safety profile. The description adds 'runtime-probed' and 'verification status,' hinting at dynamic data, but does not disclose additional traits like performance, error behavior, or data freshness. With annotations present, this is adequate but minimal.

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

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

A single, well-structured sentence that front-loads the action ('Read') and clearly identifies the resource. No wasted words or redundancy.

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

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

Given zero parameters, strong annotations, and an output schema, the description provides enough context for a simple read-only operation. The output schema handles return-value details, so the description's brevity is appropriate and 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 schema is trivially complete. Baseline 4 applies because there is nothing for the description to clarify about parameter usage.

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 the specific verb 'Read' and names the resource as the 'runtime-probed capability matrix and verification status.' This clearly distinguishes it from sibling tools like get_application_info or get_active_graph, which target different resources. The purpose 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 offers no guidance on when to use this tool versus alternatives. It does not mention a typical use case, prerequisites, or which sibling tools to prefer for other needs. Given the large list of getter siblings, this is a clear gap.

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

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

Annotations already declare read-only, idempotent, and non-destructive behavior. The description adds some context ('bounded', 'versioned', 'explicit connections') but does not disclose additional behavioral details such as default limits or the meaning of 'explicit connections' beyond what the annotations imply.

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, front-loaded with the action verb, and contains no redundant or filler content. Every word contributes meaning.

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 presence of strong annotations and an output schema, the description does not need to explain return values. However, terms like 'versioned' and 'explicit connections' are domain-specific and not elaborated, which could leave an agent uncertain about the tool's exact scope. The description is adequate but not highly 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 does not explain any of the three parameters (graph, limit, include_values). The word 'bounded' hints at the limit parameter, but the nested GraphRef and include_values remain undocumented in the description, leaving the schema to carry full semantic weight.

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 ('Read') and resource ('a bounded versioned graph snapshot') and adds a distinguishing detail ('including explicit connections'), which differentiates this from sibling tools like sd_get_active_graph or sd_list_graph_nodes.

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 a use case (read a versioned snapshot with connections) but does not explicitly state when to prefer this tool over alternatives or when not to use it. No exclusions or alternative tool mentions are present.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true, and destructiveHint=false, so the safety profile is covered. The description adds useful context about the reference being 'current-session', which clarifies that the node must reside in the active session, complementing the annotations without redundancy. No contradiction with annotations.

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, tightly worded sentence with no filler. It front-loads the key action ('Read one node') and scoping information. It could arguably be expanded, but for the purpose of concise clarity it is efficient and well-structured, earning a 4.

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?

Despite having an output schema and strong annotations, the description is too thin given the tool's complexity and the large sibling set. It does not explain prerequisites (e.g., needing an active session), how a node reference is obtained, or how this tool relates to the many other node-related tools. The description alone would not sufficiently guide an AI to correctly select and invoke the tool in varied contexts.

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 enumerate or explain any parameters besides referencing 'structured current-session node reference', which vaguely hints at the 'node' parameter but says nothing about 'detail' or the specific fields within NodeRef (e.g., package_url, graph_identifier). The schema property names are self-explanatory but the description does not compensate for the 0% coverage, leaving parameter meaning underspecified.

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 (Read) and the resource (one node), with an explicit scope qualifier ('by a structured current-session node reference'). It distinguishes from sibling tools like sd_list_graph_nodes (listing multiple nodes) and sd_get_active_graph (reading the active graph), making it unambiguous that this fetches a single 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 description implies usage: when you need to read exactly one node and have a structured reference within the current session. However, it does not explicitly name alternative tools or state when not to use it, leaving some ambiguity versus siblings like sd_get_graph_snapshot (which might also retrieve node data in a different form).

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

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

The description adds 'bounded result size' beyond the annotations, hinting at the limit parameter. However, it does not elaborate on limit behavior, detail semantics, or response format. Annotations already cover read-only and idempotent aspects.

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 filler. Every word contributes meaning, and the main idea is front-loaded.

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

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

For a simple read tool with annotations and an output schema, the description is adequate but has a gap: the 'detail' parameter is not explained. It also doesn't clarify what 'selection' encompasses, but sibling context helps.

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 mentions 'bounded result size' which relates to the limit parameter, but completely ignores the 'detail' parameter and its summary/full enum, leaving it 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 tool's function: reading the current graph node selection. It uses a specific verb ('Read') and resource ('current graph node selection'), and the 'selection' scope differentiates it from siblings like sd_get_node or sd_list_graph_nodes.

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 provided on when to use this tool versus alternatives. There are no explicit 'use this when' or 'instead of' statements, nor any mention of prerequisites or contexts.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true, and destructiveHint=false, so the safety profile is clear. The description adds 'bounded page', which communicates pagination behavior beyond the annotations. However, it does not describe other behavioral traits such as default ordering or whether the graph must be open.

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

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

The description is a single concise sentence that immediately conveys the core action and resource. Every word contributes value; no filler or redundancy.

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

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

Despite having an output schema, the tool requires a GraphRef with package_url and graph_identifier, and has parameters like detail and offset. The description does not explain how to construct the graph reference or what detail levels mean. For a tool with a nested input object and zero schema descriptions, this is too minimal.

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 mentions 'bounded page' which hints at limit/offset, but does not explain the meaning of 'detail', the structure of 'graph', or how limit/offset interact. Parameters like detail (summary/full) are left entirely 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 uses the specific verb 'List' with a clear resource 'nodes' and scope 'from a structured graph reference' with 'bounded page' indicating pagination. This distinguishes it from siblings like sd_get_node (single node) and sd_list_node_properties (properties of a 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 description provides no guidance on when to use this tool versus alternatives. It does not mention suitable scenarios, exclusions, or refer to sibling tools like sd_get_graph_snapshot or sd_list_node_properties. The 'bounded page' hint is the only implicit usage 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?

The annotations already declare readOnlyHint=true, idempotentHint=true, and destructiveHint=false, so the safety profile is known. The description adds context by specifying it lists 'runtime' properties and 'connection state,' which goes beyond the schema. However, it does not disclose return format, pagination, or other behavioral details, so it is modestly useful.

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 that is precise and free of filler. Every word contributes to the meaning, making it highly efficient and easy to parse.

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 presence of an output schema and annotations that cover safety, the description is minimally sufficient for a simple read-only listing tool. However, it lacks usage context and differentiation from siblings, and the parameter semantics are not addressed. It is adequate but not comprehensive.

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 description does not mention the 'node' parameter at all, and schema description coverage is 0%. The schema itself provides a detailed NodeRef structure, but the description adds no guidance on how to identify the target node or what 'node' refers to in this context. The agent must rely solely on the schema, which is a 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 clearly states the tool's purpose with a specific verb ('List') and resource ('runtime input and output properties, types, values, and connection state'). It is distinct from generic node retrieval tools, though it does not explicitly call out sibling tools. The qualifiers make the scope clear, but the lack of differentiation from sd_get_node prevents 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 description provides no guidance on when to use this tool versus alternatives like sd_get_node or sd_list_graph_nodes. It states what it does but not the intended scenarios or any exclusions. This leaves the agent to infer usage context, which is insufficient for optimal tool selection.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true, and destructiveHint=false, covering the safety profile. The description adds context by noting 'currently open' (state dependency) and 'structured references' (return format), but does not go beyond that. No contradiction with annotations.

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 sentence that conveys the essential purpose and output format without any filler. Every word is meaningful, and it is front-loaded with the verb and resource.

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, strong annotations, and an output schema, the description is appropriately sized. It clearly states what the tool lists and the output form. The term 'structured references' is slightly vague, but the output schema likely clarifies it. For a simple list tool, this is sufficiently 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 there is nothing for the description to explain. The baseline for no-parameter tools is 4, and the description does not need to compensate for any schema coverage gaps.

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 the specific verb 'List' with the clear resource 'packages currently open in Designer' and specifies the output form as 'structured references'. This clearly distinguishes it from sibling tools like sd_search_library (search) and sd_get_application_info (app info).

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 context—when you need to enumerate open packages—but does not explicitly state when to use it versus alternatives such as sd_search_library or sd_get_application_info. Given multiple sibling tools, explicit exclusion guidance would improve this.

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

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

The description adds the constraint of one to one hundred nodes and the requirement for explicit identification, which are useful behavioral details. However, annotations already indicate it is a write operation (readOnlyHint=false) and idempotent, so the description does not need to repeat those. It does not disclose error behavior or prerequisites beyond node existence.

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 sentence, front-loaded with the primary action, and contains no extraneous words. It efficiently captures the core behavior and key constraints.

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

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

With an output schema present and annotations clarifying mutability and idempotency, the description provides a baseline of understanding: what the tool does, a count limit, and the requirement for explicit node references. However, it lacks any explanation of the graph parameter or how to structure the move specifications, making it incomplete for a tool with nested parameters and no parameter descriptions in the schema.

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

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

The description gives minimal parameter insight: 'one to one hundred' hints at the size of the moves array, and 'explicitly identified nodes' maps to node_identifier. However, with 0% schema coverage, the description fails to explain the graph parameter or the structure of each move (node_identifier + position). The schema carries the burden, but the description does not compensate adequately.

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 tool's purpose with a specific verb ('Move') and resource ('nodes'), and provides a concrete scope ('one to one hundred'), distinguishing it from sibling tools like sd_create_node or sd_delete_nodes. The mention of 'explicitly identified nodes' reinforces that this is about repositioning existing nodes.

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 alternatives. It does not mention that this is the tool for repositioning nodes, nor does it exclude cases like using sd_apply_graph_patch for bulk position changes. The description only states what it does, not the context in which it should be chosen.

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

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

The description does not disclose any side effects, such as changing the current view, closing unsaved work, or requiring specific permissions. Annotations are present but all hints are false, so they provide no positive safety profile. The description adds no behavioral context beyond the basic action.

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

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

The description is a single concise sentence with no redundant words, making it easy to read. However, it is arguably too terse, providing only the bare minimum of 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?

Given that this tool likely mutates the editor state by opening a graph, the description lacks important context about what counts as a 'graph resource', whether the operation is reversible, or what the output schema indicates. The presence of an output schema reduces the need to describe return values, but the description still misses critical behavioral 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?

Schema description coverage is 0% and the description does not mention the 'graph' parameter or its sub-fields (package_url, graph_identifier, graph_type). The schema provides some structure but the description adds no meaning to help an agent construct valid arguments.

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 identifies the action (open) and the resource (a graph resource) in a specific context (Designer's editor). It is distinguished from siblings by using the verb 'open' which is unique among the listed tools, though it doesn't explicitly contrast with alternatives.

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

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

No guidance is provided about when to use this tool versus alternatives such as sd_get_active_graph or sd_get_graph_snapshot. The description implies a single use case but offers no exclusions or context.

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

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

Annotations already declare readOnlyHint, idempotentHint, and destructiveHint false, so the safety profile is covered. The description adds context by naming the specific status categories reported, but does not disclose additional behaviors such as error conditions, whether it requires an active bridge connection, or how compatibility is determined.

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, grammatically complete sentence that leads with the action verb 'Report'. Every term is meaningful, and there is no redundancy or unnecessary detail.

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

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

For a zero-parameter status tool with an output schema, the description provides sufficient scope of what is reported. It could explicitly state that it is a health check or suggest when to call it, but the name and content are adequate for most purposes.

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 no parameters, so the description does not need to explain inputs. The schema already fully covers this (no properties), and the baseline for zero-parameter tools is 4, which is appropriate here.

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

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

The description uses the specific verb 'Report' and lists concrete items (MCP, bridge, plugin, Designer version, session, compatibility status), making the tool's purpose clear. It distinguishes itself from sibling tools like sd_get_application_info by covering a broader scope of statuses.

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 no guidance on when to invoke this tool versus alternatives. It does not mention typical use cases, prerequisites, or exclusions, so agents may not know if this should be called at startup, before other operations, or when debugging connectivity issues.

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

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

Annotations already indicate destructiveHint=true and readOnlyHint=false. The description adds valuable context that the save overwrites in place and is restricted to already-saved packages, clarifying the exact mutating behavior beyond the raw hints. No additional side effects are mentioned, but the in-place nuance is useful.

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 sentence that front-loads the core action ('Save one already-saved open package in place') and adds a critical exclusion in a second clause. Zero waste, every word 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 has an output schema and simple parameters, so the description need not explain return values. However, it omits the purpose of the required confirm parameter, which is crucial for a destructive operation. The description tells what the tool does but not what the confirm boolean is for, leaving a gap for correct invocation.

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

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

Schema description coverage is 0%, meaning the description must compensate for parameter meaning, but it does not. The schema defines package and confirm, but the description gives no hint about what confirm means (likely a safety acknowledgment) or how package should reference an already-saved open package. This is a major 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 clearly states the tool saves an already-saved open package in place, using a specific verb and resource. The explicit 'never performs Save As' directly distinguishes it from the sibling sd_save_package_as tool, making the purpose 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 provides clear context: use for existing open packages that already have a save location. 'Never performs Save As' is an explicit when-not condition, implying alternatives exist for save-as scenarios. It could have named the alternative tool explicitly, but the guidance is sufficient.

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

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

The description adds a behavioral detail beyond the annotations: that the tool reads and validates the runtime SD type before setting. However, it doesn't disclose what happens if validation fails, whether the change is persisted, or any side effects beyond the set operation. Annotations already indicate idempotent and non-destructive, so the description's contribution is modest but non-contradictory.

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 sentence with a clear verb phrase and is front-loaded with the action. It avoids filler and is appropriately sized for a simple tool, but it sacrifices some clarity for brevity. Overall, it is concise and structured well, though it lacks details that would make it more useful.

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 complexity (a nested NodeRef with 7 fields) and the lack of annotations describing side effects, this one-sentence description is incomplete. It doesn't explain the 'supported simple parameter' constraint, how the value should be structured, or how the node is identified beyond the schema. The output schema exists, but the description still leaves critical usage aspects ambiguous.

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 any of the parameters (node, property_id, value). It merely says 'Set a supported simple parameter' without describing what the value should be, how to reference the node, or what property_id expects. The presence of a complex NodeRef object with many fields is also left 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 action 'Set a supported simple parameter' and implies the resource is a node parameter. However, 'simple parameter' is not clearly defined, and it doesn't differentiate from other node-related tools, but the verb+resource pairing is specific enough. It distinguishes itself from sibling tools by focusing on setting, which no other tool does.

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 no guidance on when to use this tool versus alternatives, nor does it mention prerequisites or exclusions. The phrase 'after reading and validating its runtime SD type' hints at a precondition, but it doesn't explain who should do the reading or what tool to use. No alternative tools are referenced, leaving the agent without context for appropriate use.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true, and destructiveHint=false, so the safety profile is covered. The description adds context by specifying the patch is 'additive' and 'versioned', which are behavioral constraints not fully captured by annotations alone.

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

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

The description is a single, concise sentence that front-loads the most important information: dry-run, additive patch, and no side effects. Every word contributes meaning, with no redundancy or 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 description gives a high-level purpose but omits details about the patch structure constraints (e.g., version '1.0', node count limits) that are present in the schema. However, the output schema and annotations partially compensate, and the tool's core validation behavior is clear. More guidance on validation results or typical use cases would improve completeness.

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 provides no parameter-level explanation. While parameter names ('graph' and 'patch') are self-descriptive and the schema is rich, the description does not compensate for the lack of schema descriptions or clarify how to construct the patch object.

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 ('Dry-run') with a clear resource ('a versioned additive graph patch') and outcome ('without changing Designer'). This clearly distinguishes it from sibling tools like sd_apply_graph_patch, which presumably applies changes.

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 'without changing Designer' clearly implies this tool is for validation/preview before applying a patch, giving the agent context for when to use it. It does not explicitly name the alternative sd_apply_graph_patch, but the dry-run/no-change framing is a clear usage signal.

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