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

With no annotations, the description carries the behavioral burden. It discloses that this is transport batching, not a transaction, that failures are reported per item, that abort_on_error defaults to false, and that response_format defaults to yaml. It does not describe execution order or concurrency, but the most important non-obvious behavior is covered.

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

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

The purpose and key caveat are front-loaded in the first sentence, and each parameter gets one compact line with defaults and allowed values. There is no filler, and every sentence adds operational value.

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 no output schema and no annotations, the description covers the parameters, defaults, failure semantics, and response formats. It stops short of specifying the exact response/report structure or which router methods are valid in ops, so it is complete for invocation 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 description coverage is 0%, so the description must compensate fully, and it does. It defines the ops shape as [{method, params}, ...], gives abort_on_error's default, lists detail values (full/summary/minimal), and response_format values (yaml/json). Every parameter is given actionable meaning beyond the bare 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 first sentence names a specific verb and resource: 'Run a list of router requests in ONE bridge round trip.' This clearly establishes what the tool does and separates it from the single-request sibling bridge_router_call. The transport-batching caveat further distinguishes it from a rollback/transactional batch.

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 clearly implies the use case: batch multiple router requests when you want a single round trip, and it warns that failures are per-item rather than rolled back. It does not explicitly say 'use bridge_router_call for a single request,' but the framing gives enough context for an agent to choose correctly.

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

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

With no annotations, the description carries the full burden of behavioral disclosure. It does reveal a side effect (opening the show) and a waiting behavior with a timeout, which is useful. However, it does not describe timeout/failure behavior, whether opening the show changes persistent TD state, or what 'alive status' concretely 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?

The main behavior is front-loaded in one clear sentence, followed by compact one-line parameter definitions. Every sentence earns its place, and there is no redundant or vague 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?

For a simple tool with three optional parameters and no output schema, the description covers the action, waiting behavior, parameter controls, and return concept. The main remaining gap is a precise specification of the alive-status result shape, though the detail and response_format options mitigate this.

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?

Even though schema description coverage is 0%, the description documents all three parameters with defaults and allowed values: timeout has max-wait seconds, detail explains full/summary/minimal behavior, and response_format explains yaml/json with a token-cheap note. This fully compensates for the empty 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 states a specific operation: open the show in TD if needed, wait for the bridge heartbeat, and return alive status. It is clearly about ensuring the bridge is alive, but it does not explicitly differentiate itself from sibling status/health tools like bridge_status or bridge_health.

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

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

No guidance is given about when to use this tool versus bridge_status, bridge_health, bridge_open_show, or other bridge_* alternatives. The phrase 'if needed' is a behavioral conditional, not a usage recommendation or exclusion.

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 handles it reasonably. It discloses that this is a read-only telemetry report pulling real-time data from TD's Perform CHOP, lists the affected metrics, and reveals the optional black/solid output-TOP check. It does not mention permissions or side effects, but the passive diagnostic nature is clear.

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 core value proposition is front-loaded in a single dense first sentence, followed by three compact, single-line parameter definitions. Every line earns its place, and the token-cheap annotation on response_format adds genuine utility without bloat.

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?

Covers the reported metrics, all three parameters with options/defaults, and response granularity via the detail levels. With no output schema, it hints at return structure (summary truncates lists, minimal gives scalar-only) rather than fully specifying it, which is a minor gap given the tool's aggregation 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%, so the description must fully compensate, and it does. Every parameter gets an explicit attainment: output (TOP path for black/solid check), detail (full/summary/minimal with cut-to-25 behavior), and response_format (yaml/json with the token-cheap note). Options and defaults are documented beyond the bare schema types.

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 ('Show health in one call') and enumerates exactly what is reported: bridge alive/TD frozen/TD gone, REAL fps vs cook rate, frame time vs budget, dropped frames, GPU memory/temp, and mode. This clearly differentiates it from the per-metric sibling tools (measure_fps, measure_gpu, measure_chain) by positioning it as the single aggregated health call.

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 'in one call' and the consolidated metric list imply this is the go-to aggregated diagnostic versus the granular measure_* tools, but the description never names alternatives or states when NOT to use it. Usage is implied rather than explicit, with no exclusion conditions or sibling routing.

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

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

With no annotations, the description carries the full behavioral disclosure burden. It explains the show-mode lock semantics, the allowlist, the since-when information, and the detail/response_format output options. It does not explicitly state that the tool is read-only, but 'Current' strongly implies it and no side effects are suggested.

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?

Every sentence earns its place. The core behavior is front-loaded first, followed by concise parameter documentation. There is no filler, repetition of schema fields, or irrelevant context.

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 getter with two optional parameters and no output schema, the description is complete. It explains what the tool returns, the meaning of the modes, the allowlist, and how detail and response_format shape the output.

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 fully explain both parameters, and it does. It defines all meaningful values for detail and response_format, including defaults and the practical effect of each choice, such as cutting long lists to 25 or choosing token-cheap YAML.

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 resource as the current bridge mode and defines the two possible values, prep and show, along with what show mode locks. It lacks an explicit verb like 'gets' or 'returns,' but 'Current bridge mode' and the tool name make the read intent unambiguous. It also distinguishes itself from bridge_set_mode by focusing on current state rather than changing it.

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 rather than stated: this is a query for the current bridge mode and its allowlist. The mode definitions help an agent understand what the values mean, but the description does not explicitly say when to prefer this over bridge_status, bridge_state, or bridge_set_mode.

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

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

With no annotations, the description carries the behavioral burden and does disclose a key trait: refusal when TD is running unless force is set. It also reveals response-shaping behavior via detail and response_format (yaml default, token-cheap). It stops short of describing exact error/return semantics, but the most decision-relevant behavior is explicit.

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

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

The purpose is front-loaded in one sentence, followed by a compact parameter list with no filler. Each clause adds actionable information, and default values are integrated efficiently.

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 annotations, zero output schema, and 0% schema coverage, the description covers the call contract well: behavior, all params, and output format/verbosity. The main omission is explaining what 'resolved show' means or error behavior on refusal, but an agent can invoke the tool correctly with the information provided.

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 the description compensates by documenting all three parameters with concrete meanings and allowed values: force overrides the running-TD guard, detail controls list truncation/level, and response_format selects yaml or json. This is exactly the semantic weight the schema lacks.

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 clause 'Launch the resolved show .toe in TouchDesigner' uses a specific verb and resource, immediately distinguishing this from state/health bridge tools like bridge_status or bridge_ensure_alive. The refusal condition adds concrete scope.

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 states clear launch context and the force condition: if TD is already running, the tool refuses unless force=true. It does not name sibling alternatives, but no sibling appears to perform the same launch/show action, so the context is sufficient without explicit 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?

With no annotations provided, the description carries the behavioral burden. It clearly discloses the key side effect: a new restored file is created and the live file is never overwritten. It also signals response cost via 'token-cheap' for YAML, though it does not cover failure modes 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?

The first sentence leads with the core behavior and safety guarantee, and the following parameter lines are compact and information-dense. Every sentence contributes either behavioral context or parameter semantics with no filler.

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

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

For a tool with no annotations and no output schema, the description covers the essential call semantics well: output format, detail levels, file placement, and non-destructive behavior. It stops short of describing exact return fields or error conditions, but the missing detail is not critical for selecting and invoking 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%, so the description fully compensates by documenting all three parameters: type, allowed values, defaults, and semantics. This includes explaining what 'summary' and 'minimal' actually return, which is materially more than the raw schema provides.

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

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

The description names a specific verb ('Restore'), a specific resource (a backup .toe), and a precise outcome (a new restored.<N>.toe sibling in the show folder). The 'never overwrites the live file' qualifier distinguishes this from any mutation-style sibling and makes its purpose unmistakable.

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 action is clearly a restore operation, so when to call it is implied by the name and description. However, it does not explicitly contrast itself with related bridge tools such as bridge_snapshot or bridge_save_increment, and it gives no exclusions or preconditions.

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

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

Annotations are not provided, so the description carries the full burden. It mentions that destructive methods are gated by safe mode, which is a key behavioral trait. It does not describe error handling, side effects, or return value structure beyond the detail levels, but the detail parameter partially addresses response shape. It is adequate but not exhaustive.

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

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

The description is concise and front-loaded with the purpose. It uses a compact list format for parameters that is easy to scan. Every sentence adds value, and there is no fluff. It could be slightly more structured, but overall it is efficient.

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 high complexity of a raw router call and the lack of output schema, the description is moderately complete. It covers the parameters and mentions safe mode for destructive methods, but it does not explain the range of possible methods, error scenarios, or how the response varies by detail level in depth. Given the escape-hatch nature, some gaps are acceptable, but it could be more thorough.

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 explain parameters. It does provide examples for method, describes params as a dict, and explains detail and response_format options. However, it does not provide a full list of possible methods or parameter conventions, but it gives enough for a general understanding.

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 it is a raw router call for any method, serving as an escape hatch. It distinguishes itself by noting that typed tools are preferred, which helps set expectations. However, it could be more explicit about what the router itself is, but overall the purpose is clear.

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 says to prefer the typed tools, implying this is for cases not covered by them or for advanced use. It also notes that destructive methods remain gated by safe mode, which is important context. However, it does not enumerate specific alternatives or scenarios when to use this over siblings, but the context is sufficient for an agent to infer.

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 burden. It discloses the soft-warn vs hard-lock behavior, which is useful. However, it doesn't describe what happens on mismatch in detail, error behavior, or whether this is a read-only operation. The description adds some behavioral context but not comprehensive.

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

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

The description is compact and front-loaded with the core purpose. The parameter details are listed efficiently. It could be slightly more structured, but every sentence 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?

For a simple 2-param tool with no output schema, the description covers the main purpose and parameter semantics. However, it lacks information about return value structure, error handling, and when to prefer this over bridge_status or bridge_health. It's adequate but has clear gaps.

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

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

Schema description coverage is 0%, so the description must compensate. It does: it explains the 'detail' parameter's three modes (full, summary, minimal) and the 'response_format' parameter's two options (yaml, json) with their defaults and trade-offs. This adds significant meaning beyond the bare 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 states a specific verb and resource: 'Router surface version + method count' for capability negotiation. It distinguishes itself from siblings like bridge_status and bridge_health by focusing on version and method count, though it doesn't explicitly name those siblings.

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 clear context: it's for capability negotiation, with a soft-warn on mismatch and never hard-lock. It doesn't explicitly say when not to use it or name alternatives, but the negotiation purpose is clear enough for an agent to select it appropriately.

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 must carry the full behavioral burden. It discloses the core safety guarantee ('structurally refuse to overwrite') and the 'SAFE' label, but does not explain behavior on timeout, error handling, or what happens if the bridge is unreachable. It also omits any description of the return value or side effects beyond file 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?

The description is compact and front-loaded with the purpose, then lists parameters with defaults in a clear, scannable format. Every sentence adds value; there is 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?

As a mutation tool with no output schema and no annotations, the description should explain what success looks like (e.g., returns the new file path) and any prerequisites (like bridge_ensure_alive). It also does not cover failure modes or what happens on timeout. These gaps make it incomplete for an agent to fully anticipate the tool's behavior.

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 fully compensates by explaining all three parameters: timeout (float, default 45), detail (full/summary/minimal with behavior), and response_format (yaml/json). It adds defaults and value semantics that the schema does not provide, making each parameter actionable.

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 'SAFE save: write the next numbered Show.<N+1>.toe' which is a specific verb and resource, and adds the structural guarantee of refusing to overwrite. It also positions itself as 'the preferred way to persist bridge edits,' distinguishing it from potential sibling tools like bridge_snapshot or bridge_restore without needing to name 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?

It states it is 'the preferred way to persist bridge edits,' which strongly implies this is the go‑to tool for saving increments and that alternatives exist. However, it does not explicitly name the alternatives or give conditions for when to use them instead, so the guidance is clear but not exhaustive.

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

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

With no annotations provided, the description carries the full burden and covers the key risk profile: it is a raw opcode sender (eval/python imply arbitrary execution), safe mode filters non-catalogued operations, and destructive ops need --allow-destructive. It also reveals that yaml is the "token-cheap" default. It omits error behavior for rejected opcodes, but the core safety and efficiency traits are disclosed.

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 front-loaded with purpose and the safety caveat, followed by a compact per-line parameter block where each entry is dense and useful. Minor redundancy: it repeats Python type annotations (e.g., "(<class 'str'>)") that already exist in the input schema, adding slight noise, but nothing else 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 4-parameter tool with no output schema and no annotations, it covers purpose, the safe-mode/destructive context, and every parameter's semantics including response shaping. The main gap is return/error behavior — e.g., what an agent sees when a disallowed opcode is rejected in safe mode — but the essentials for correct invocation are all 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 is the sole documentation for all four parameters, and it fully compensates: op is explained as an opcode with examples, payload as an arbitrary dict, detail enumerates full/summary/minimal including the list cutoff behavior ("long lists cut to 25 + count"), and response_format gives yaml/json with defaults. This adds meaning far beyond the bare 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 opening line "Raw bridge send: op + payload" states a specific verb, resource, and the escape-hatch nature of the tool. The safe-mode sentence explicitly contrasts it with catalogued non-destructive router methods, which maps directly to the sibling bridge_router_call and lets an agent distinguish the raw opcode path 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?

"In safe mode only catalogued non-destructive router methods pass; the raw python/eval opcodes need --allow-destructive" gives clear context about when this raw tool will actually work and flags that the destructive opcodes require a server-side flag. It stops short of explicitly naming bridge_router_call as the alternative for safe operations, so the when-not guidance is strong but implied rather than 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, the description fully discloses the meaningful behavior: show mode locks the bridge, enforces reads+allowlist for every TD client, and requires the exact human-supplied 'END SHOW' confirmation before leaving. It also includes an explicit agent-safety directive not to supply that confirmation on its own initiative.

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 critical safety warning is front-loaded before parameters, and each parameter gets a compact, scannable one-line explanation. No filler; the length is justified by five undocumented parameters.

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?

Even without annotations or an output schema, the description covers the mode semantics, all parameter formats, the locking side effects, and the human-confirmation requirement. The response_format and detail options give the agent enough control over the returned shape.

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%, but the description compensates completely: it defines the two mode values, the glob format for allow with concrete examples, the exact confirm string, the detail levels, and the response_format choices.

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 the exact operation: switch the bridge between SHOW (locked for live performance) and PREP, and defines what SHOW means. It doesn't explicitly differentiate from sibling tools like bridge_mode or bridge_open_show, so it falls one step 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 clear situational context: use SHOW for a live performance lock, return to PREP to unlock, and never exit show mode without the human-typed confirm phrase. It doesn't explicitly route between siblings, but the conditional guidance is strong.

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

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

With no annotations provided, the description carries the full disclosure burden and does disclose the key safety behavior ('never overwrites anything') as well as how the detail and response_format parameters shape the output. It does not describe return-value content or failure modes, but the core non-destructive trait is well covered.

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 sentences with no filler: purpose plus safety in the first, then one line per parameter. The core purpose is front-loaded and every sentence 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?

For a low-complexity tool (0 required parameters, no output schema, no annotations), the description covers purpose, safety, and parameter semantics well. The main gaps are unspecified return-value semantics and lack of sibling routing, which matter more here because there is no output schema to fill those in.

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 fully compensates by documenting both parameters with their allowed values and concrete effects (e.g., 'summary (long lists cut to 25 + count)'). The only minor wrinkle is 'full (default)' versus the schema's null default, which is reconcilable but slightly ambiguous.

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 states a specific verb ('Copy'), a resource ('current show .toe'), and a destination ('timestamped backup'), plus a concrete safety guarantee ('never overwrites anything'). This is specific enough to distinguish it from siblings like bridge_snapshots (which lists snapshots) and bridge_restore (which restores 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?

No guidance is given on when to use this tool versus alternatives such as project_snapshot, bridge_save_increment, or bridge_snapshots. The safety claim implies it is safe to call, but there is no explicit when-to-use, when-not-to-use, or alternative-routing context.

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

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

With no annotations, the description carries the transparency burden and does well: it discloses ordering (newest-first), truncation behavior for long lists (cut to 25 + count), and format defaults (yaml, token-cheap). It does not explicitly state that listing is read-only, but that is strongly implied by 'List.'

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 three short, front-loaded lines: the purpose comes first, then each parameter in a compact form. Every sentence carries useful information with no filler or repetition.

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 there is no output schema, the description covers the main invocation decisions: what will be listed, ordering, detail levels, and response formats. It does not enumerate the exact output fields for full/summary detail, but the format options and truncation rule give enough context to select and call the tool successfully.

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 is the only source of parameter meaning. It fully compensates by explaining each parameter: detail's allowed values (full, summary, minimal) and response_format's allowed values (yaml, json), plus their defaults. This is excellent beyond-schema guidance.

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

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

The description opens with a specific verb and resource: 'List existing backups, newest-first.' This clearly distinguishes bridge_snapshots from singular create/restore siblings like bridge_snapshot and bridge_restore, so an agent can tell exactly what it 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 gives clear context: use this tool when you need to see available backups, and it explains the available list-detail modes. It does not explicitly name alternatives or state when not to use it, but the verb and resource make the intended usage obvious.

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

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

With no annotations, the description carries the full burden of disclosing behavior. It describes detail levels and response_format options, which is useful, but it does not state whether the tool is read-only, what happens when the bridge is down, or any side effects or error behavior. The word 'probe' implies read-only but is not explicit.

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 three concise sentences, front-loaded with the core purpose, then parameter details. There is no redundant text, and each sentence serves a clear function.

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 probe with two optional parameters and no output schema, the description covers purpose and parameters adequately. However, it lacks usage context (when to choose this over siblings) and any behavioral caveats (safety, side effects, error handling). Given no annotations, these gaps make it incomplete for fully informed usage.

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

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

The schema has zero descriptions (0% coverage), so the description must fully explain parameters. It does: detail with values full/summary/minimal and defaults, and response_format with yaml/json and defaults. This adds meaning beyond the schema and is sufficient for an agent to construct valid calls.

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 returns a three-state probe for the bridge with values ok/starting/down/off, which specifies a verb ('probe') and resource ('bridge state'). It is distinct in that it focuses on state, but it does not differentiate from siblings like bridge_status or bridge_health, which could overlap.

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

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

There is no guidance on when to use this tool versus alternatives. Given many bridge_* siblings, the description does not explain if this is the preferred probe for state, or when bridge_status or bridge_health would be more appropriate. No exclusions or alternatives are mentioned.

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?

Given no annotations, the description carries the full burden. It discloses the return fields (alive, age, project, build) and the effect of the 'detail' parameter on output length. It also mentions that the default response format is YAML for token efficiency, which adds transparency. It doesn't mention any side effects, but as a status read tool, that's fine. More detailed behavior like error handling is not disclosed, but the core is covered.

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 focused and front-loaded with the core purpose, then the parameter details. The parameter documentation adds length but is necessary given no schema coverage. No extraneous information; each sentence 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?

With a simple tool (2 optional params, no output schema), the description covers the key aspects: purpose, parameters, and default formats. It could be more complete if it explicitly stated when to use this over the many bridge-related siblings, but for its simplicity it is quite 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 coverage is 0%, leaving the description to fully explain the parameters. It does this well: it explains 'detail' with the three valid values (full, summary, minimal) and their effects, and 'response_format' with yaml and json options. This is directly useful for an agent deciding values.

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 what the tool does: it reports bridge heartbeat state, including fields like alive, age, project, and build. It distinguishes itself reasonably from siblings like 'system_info' or 'bridge_health' by focusing specifically on heartbeat state, though it doesn't explicitly name a sibling it is not.

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 checking bridge status, which is clear given the name, but it does not explicitly state when to use this tool over alternatives such as 'bridge_health' or 'system_info'. No exclusions or conditions are given, so the guidance is adequate but not explicit.

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

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

With no annotations, the description carries the transparency burden and does disclose the connection direction and response controls (detail and response_format). However, it does not state side effects such as whether an existing connection is replaced, how failures are reported, or what the returned object 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?

The core action is front-loaded in a single short sentence, followed by a compact parameter list. Every line adds a distinct fact about a parameter, with no filler or redundant prose.

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 documents all parameters and response formatting choices, which covers the essential facts an agent needs to call the tool. It still omits the exact return payload shape, error behavior, and any distinction from connection_create, but these are minor gaps for a straightforward creation 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?

All six parameters are individually explained with meaningful roles, defaults, and allowed values despite the input schema having 0% description coverage. The description fully compensates for the bare schema by defining source/destination paths, output/input indices, detail modes, and response_format.

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 line uses a specific verb ('Wire') and resource ('two ops') with a direction ('output -> input'), so an agent can tell this creates a data-flow connection. It is clear even without relying on the tool name, though it does not explicitly distinguish itself from the similar-sounding sibling connection_create.

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 about when to use conn_create versus alternatives such as conn_get, conn_delete, or connection_create. No preconditions, exclusions, or alternative-tool hints are provided; the appropriate use is only implied by the verb 'Wire'.

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

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

There are no annotations, and the description does not disclose side effects, reversibility, failure behavior, or whether existing connections are affected beyond the specified input/output. For a mutation tool, this is a significant transparency 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?

The description is compact and front-loaded with a clear first sentence, followed by a minimal parameter list. It avoids unnecessary prose, though the parameter documentation could be slightly tightened.

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 five-parameter mutation tool with no output schema and no annotations, important context is missing: return behavior, prerequisites, error conditions, and relationship to connection_delete. The parameter list helps, but the overall tool context is incomplete.

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 schema has 0% description coverage, but the description documents every parameter with its purpose and explains the options for detail and response_format. It does not fully specify indexing semantics or whether inputIndex/outputIndex are mutually exclusive, but it provides usable meaning beyond 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 states a specific action, 'Disconnect an input and/or output of a node,' naming both the verb and the resource. It partially distinguishes itself from siblings by focusing on per-port disconnection, but it does not explicitly explain how it differs from the similarly named connection_delete.

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

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

No guidance is given on when to use this tool versus alternatives such as conn_create, conn_get, or connection_delete. The description explains what it does but not in which situations it should be preferred, leaving the agent to guess among close sibling 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?

No annotations are provided, so the description carries the full behavioral burden. It does not disclose side effects, whether the operation is destructive, what response is returned, or any error behavior. The only behavioral hints are the alias statement and the 'token-cheap' note about response_format, which is insufficient for a mutating 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 compact and organized as a clean parameter list, with the alias statement front-loaded. Every line adds value, and there is no redundant repetition of schema information since the schema lacks descriptions.

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?

All six parameters are documented well, but the description omits a plain-language statement of what the tool does, when to use it, and what the response looks like. Given no annotations and no output schema, these gaps matter for correct selection and invocation, though parameter filling is fully supported.

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 fully compensates by explaining every parameter: fromPath/toPath as operator paths, fromOutput/toInput defaults, detail values with exact summary behavior, and response_format with yaml default and token-cheap note. It also clarifies the schema's null defaults into meaningful defaults like 0, full, and yaml.

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

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

The description identifies the tool as 'Alias of conn.create' and lists source/destination operator paths, which implies connection creation, but it never directly states what the tool does (e.g., 'creates a connection between two operators'). It does not distinguish this tool from the sibling conn_create, leaving the purpose largely inferential.

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 only usage hint is the aliasing note 'kept for MCP-side compat,' which suggests a compatibility purpose but does not explain when to choose this tool over conn_create or other siblings. No conditions, exclusions, or alternative selection guidance are provided.

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 burden of behavioral disclosure. It adds some value by showing that inputIndex and outputIndex 'disconnect this input/output,' and 'Alias of conn.delete' signals canonical behavior. However, it does not mention permanence, side effects, permissions, or failure behavior for what is evidently a destructive 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 parameter documentation is terse, well-ordered, and free of filler; each line earns its place. The high-level purpose is compressed into a single alias clause, so the structure is efficient but the opening is under-explanatory.

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 no annotations and no output schema, a destructive delete tool needs clearer purpose, usage, and side-effect context. The description covers parameter meaning well but leaves the agent guessing about when to call it, how it differs from conn_delete/connection_create, and what a successful deletion returns.

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 fully compensates by giving operational meaning to all five parameters: path is the Operator path, inputIndex/outputIndex identify which connection endpoint to disconnect, and detail/response_format enumerate their allowed values and defaults. This is genuinely helpful beyond 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 opens with 'Alias of conn.delete.' but never states in plain terms that this tool deletes a connection. The verb and resource are inferable from the name and the alias, but the object and effect are not explicitly defined, and the description does not clarify how it relates to the sibling conn_delete.

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 such as conn_create, conn_get, or conn_delete. 'Alias of conn.delete' implies equivalence with another operation but does not name the sibling tool or provide any selection criteria, prerequisites, or exclusions.

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

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

No annotations are present, so the description must carry all behavioral disclosure. It only says 'alias of conn.get' and gives parameter options, with no mention of side effects, read-only nature, error behavior, or return structure. The description is silent on what happens on success or failure.

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 text is short but poorly structured. The leading 'Alias of conn.get' is not informative and wastes space. Parameter explanations are crammed into a single line, making them harder to parse. It could be more concise and organized.

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 is severely lacking. It does not explain what a connection is, what the return value looks like, how errors are reported, or any constraints on path. It is insufficient for an agent to confidently invoke this 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?

Despite the schema having no descriptions, the description provides meaningful detail: path is an operator path, detail has three explicit modes with explanations, and response_format offers yaml or json with token-efficiency noted. This adds genuine value beyond the 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 states 'Alias of conn.get' which is not a clear purpose. It implies retrieval but doesn't specify what 'connection' means, what 'path' refers to, or what operation is performed. It doesn't distinguish from sibling conn_get or other connection tools.

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 on when to use this tool vs alternatives. There is a sibling conn_get that appears to be the original, but no relationship or selection criteria is provided. The agent has no basis to choose between them.

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

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

With no annotations provided, the description carries the full burden. It does usefully disclose output behavior via 'detail' modes (e.g., truncation to 25 + count) and response format defaults (yaml as token-cheap), but it does not mention side effects, errors, or authorization requirements. For a read-only tool this is adequate but not exhaustive.

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

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

The description is compact, front-loads the purpose in the first sentence, and then uses tight parameter annotations. Every line provides useful information without 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?

For a simple read operation with three parameters and no output schema, the description gives enough to call the tool correctly, including defaults and valid options. It falls slightly short of a 5 because it omits any hint about how the returned connections are structured or any guidance on choosing among the related connection tools.

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%, but the description fully compensates by documenting all three parameters with types, defaults, allowed values, and meanings. It adds detail not present in the schema, including the distinction between full, summary, and minimal detail and the yaml/json response format choice.

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

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

The description states a clear verb ('Read') and resource ('all input/output connections of a node'), so an agent can understand the core operation. However, among the sibling tools there is also 'connection_get', and the description does not explicitly differentiate conn_get from that alternative.

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 about when to use this tool versus conn_create, conn_delete, or connection_get. It implies use by naming the resource and operation, but it does not state prerequisites, exclusions, or alternative conditions, so the agent must infer the appropriate context.

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

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

With no annotations, the description carries the behavioral disclosure burden and does so well: it discloses uniform downsampling, the default sample cap, summary/minimal output truncation behavior, and token-cheap YAML vs JSON. It stops short of describing exact output shape or error behavior, but the read-only character is clear.

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 definition is tightly structured: one purpose sentence followed by a compact parameter list. Every line adds information, and the default values and output options are front-loaded in a scannable format.

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 lacking an output schema, the description gives enough context to invoke the tool correctly: it names the resource, covers all parameters, and describes response detail levels and formats. It could go further by sketching the full response structure, but for a simple read tool the coverage is strong.

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%, yet the description fully compensates by explaining all four parameters: what path refers to, what max_samples caps, the exact detail modes, and the response_format options. It even clarifies effective defaults (1024, full, yaml) that the schema leaves as null.

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 one-line summary, 'Read CHOP channel values (uniformly downsampled)', names a specific verb and resource and adds a key scoping qualifier. It clearly distinguishes this tool from siblings like data_top, data_sop, and data_dat by targeting CHOP channel data.

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 makes the intended use clear: read CHOP channel values. It does not explicitly name alternatives or when-not-to-use conditions, but the domain-specific phrasing is enough for an agent to know when this tool applies versus related data_* 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 provided, the description carries the full burden. It states 'Read' indicating a read-only operation, and details response_format and detail options. However, it does not disclose error behavior, what happens for invalid paths, or the exact structure of the returned content. This is acceptable for a simple read tool but leaves some 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 compact list of parameters with clear formatting, no redundant words, and the purpose statement is front-loaded. Each parameter is explained in a single line, making it highly scannable and efficient.

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 (read operation, 5 params with 1 required), the description covers parameter semantics and output formats. However, it does not explain the return structure in detail (e.g., what 'full' vs 'summary' actually returns) or error conditions. With no output schema, these gaps are minor but noticeable.

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 provides inline documentation for every parameter, including defaults and allowed values (e.g., detail: full/summary/minimal, response_format: yaml/json). This adds substantial meaning beyond the schema, which has no descriptions. It fully compensates for the 0% schema coverage.

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 'Read text or table DAT content', specifying the verb 'read' and the resource 'DAT content'. It distinguishes from siblings like data_chop, data_top, data_sop, and data_dat_write, which target different operator types or write operations. 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 implies usage for reading DAT operators but does not explicitly contrast with alternatives like data_chop or data_top. No when-to-use or when-not-to-use guidance is provided beyond the resource type implied by the name. The agent must infer from the tool name which sibling to select.

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

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

With no annotations provided, the description carries the full behavioral burden. It explicitly discloses the mutating effects: replacing full text, appending a row, and clearing before writing. It also explains response shaping through detail and response_format, giving an agent a clear picture of side effects and output style.

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 summary line is compact and front-loaded, and each parameter gets a single focused line. There is no filler or repeated schema information; every sentence adds 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?

For a six-parameter tool with no output schema or annotations, the description covers the core operations, parameter semantics, and output format. It lacks only minor context such as error behavior or permissions, but an agent has enough to call the tool and interpret its response.

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?

Although the schema has no descriptions for its properties, the tool description documents every parameter with types and allowed values. It explains path, text replacement, appendRow, clear, detail levels, and response_format defaults, fully compensating for the 0% schema coverage.

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 begins with a clear verb and resource: 'Write text / append a row / clear a DAT.' It names the specific operations and target, making the tool's function obvious. The coarse-grained name is reinforced by concrete actions rather than restating the title.

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 says what the tool does but gives no guidance about when to prefer it over sibling tools such as data_dat, data_chop, data_top, or data_sop. There are no exclusions, prerequisites, or alternative-routing hints.

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

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

With no annotations provided, the description carries the full disclosure burden. It indicates a read operation ('full-frame read via numpyArray()') and describes the statistical computation, but it does not explicitly state side effects (e.g., whether it is read-only), or any potential performance implications. It is adequate for a sampling tool but lacks explicit safety declarations.

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 opens with a clear one-line purpose, then presents a compact parameter list with inline explanations. It is front-loaded and each sentence adds value. Slightly long, but the parameter details are necessary given the lack of schema descriptions.

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, so the description must convey what the tool returns. It names the statistics (mean/min/max/std) and flags, but does not describe the result structure (e.g., a dictionary with specific keys) or potential error cases. It is sufficient for a basic call, but leaves some ambiguity about the exact response shape and handling of edge cases like missing path.

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 provides meaningful context for every parameter, including defaults (16, 0.02, 0.005), interpretation (dark_below, solid_std, detail levels), and output format choices (yaml/json). Since schema description coverage is 0%, this textual parameter documentation is essential and largely compensates for the schema's lack of 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 states a specific verb and resource: it computes luma statistics (mean/min/max/std) of a TOP and produces dark/solid/clipped flags. The phrase 'is the output actually black?' verifier adds a concrete use case. However, it does not explicitly distinguish itself from sibling tools like data_top, so it misses the top tier of 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 'verifier' phrase implies a use case (checking if an output is effectively black or uniform), but there is no explicit guidance on when to prefer this tool over siblings such as data_top or data_sop, nor any exclusions or prerequisites. The usage context is implied but not 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?

With no annotations, the description carries the transparency burden and does a solid job: it discloses truncation behavior (summary cuts long lists to 25 plus a count), minimal-mode behavior (top-level scalars only), and the default response format (YAML, token-cheap). It does not mention side effects or error behavior, but this is not critical for the apparent read-only retrieval role.

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

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

The description is compact and information-dense: a one-line purpose followed by equally concise parameter definitions. Every sentence adds value, and there is no fluff 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 no output schema, no annotations, and only one required parameter, the description is nearly sufficient: it names the returned data (point count/positions/bounds), defines all parameters, and explains output-shaping options. It could add path format details or error behavior, but for a simple 3-parameter query tool it is quite 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 compensates well: it clarifies path as an SOP operator path, enumerates all detail values (full, summary, minimal), and enumerates response_format values (yaml, json) with default behavior. This adds meaning beyond the raw schema, though the path semantics remain somewhat terse.

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 resource ('SOP') and the data returned ('point count/positions and bounds'), which is specific and distinct from sibling data tools. It lacks an explicit verb such as 'get' or 'return', but the tool name and phrasing make the retrieval intent clear.

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 choose data_sop over siblings like data_chop or data_top, nor any exclusions or alternative conditions. It only explains parameter options, not when the tool should be used.

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

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

With no annotations, the description carries the full burden of behavioral disclosure. It does disclose useful behaviors: pixel capture can be downscaled via max_width/max_height, long lists are truncated to 25 items, and YAML is the token-cheap default. But it does not explicitly state that the operation is read-only or describe error handling, leaving some 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 definition is a compact, scannable bullet list with inline defaults and enum values. The opening line is brief and the parameter explanations are efficient. It could benefit from a short prose example, but nothing in the current text 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?

Parameter semantics are strong, but there is no output schema and no explanation of the return payload structure. An agent cannot fully predict what 'full' versus 'minimal' actually returns, nor how the pixel capture is attached to the response. For a simple read tool these are moderate gaps, not fatal ones.

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%, yet the description compensates fully. Every parameter gets a clear semantic: 'path' is the TOP operator path, 'pixels' toggles base64 PNG capture, max_width/max_height explain downscaling, 'detail' defines output levels, and 'response_format' specifies formats and defaults. This exceeds the bare 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 opens with 'TOP resolution, optionally base64 PNG pixel capture,' which names a specific resource (TOP) and the main actions. It distinguishes itself from data_chop, data_sop, and data_dat by being TOP-specific. However, 'resolution' is slightly ambiguous since the detail parameter implies the tool can return broader structured data than just resolution.

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 siblings like data_chop, data_sop, data_dat, or data_pixel_sample. No conditions, prerequisites, or exclusions are provided, so the agent must infer usage entirely from the tool name and sparse description.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It explains the operation and output formatting options (detail, response_format) but does not explicitly state that this mutates node positions, whether the operation is reversible, or if specific permissions are required. This is a notable gap for a layout-modifying 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?

The description is efficient: a one-line purpose followed by a line per parameter. It front-loads the main function and avoids unnecessary prose, making it scannable 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?

For a tool with 7 parameters and no output schema, the description covers the core operation and parameter semantics well. It hints at output via response_format and detail but does not describe the actual response structure or whether the operation is silent or returns a summary. The absence of side-effect disclosure is a minor gap, given the mutation nature.

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 define every parameter. It does so thoroughly: 'paths' clarifies they are ordered operator paths, 'axis' gives allowed values and default, 'spacing' explains the gap and default, and detail/response_format document all options. This fully compensates for the schema's lack of 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 opens with a clear, specific verb and resource: 'Distribute nodes along a horizontal or vertical axis.' This distinguishes it from sibling tools like layout_set_position (which positions a single node) and node_* tools. The axis specification further narrows the scope.

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 does not provide any guidance on when to use this tool versus alternatives. It only describes the operation and parameters, with no mention of use cases, exclusions, or prerequisites such as 'use layout_set_position for single-node positioning.' An agent must infer the appropriate context solely from the name and sibling list.

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

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

With no annotations provided, the description carries the burden of behavioral disclosure. It does add some value by describing response_format ('yaml (default, token-cheap) | json') and the detail levels' effects on output truncation. However, it does not mention side effects like overwriting existing positions, error behavior, or whether the operation is reversible.

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 terse and front-loaded with the purpose, followed by compact parameter definitions with no filler. Every line earns its place and directly helps the agent invoke the tool correctly.

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 covers the full parameter surface and gives enough output-format context via detail and response_format. It does not specify coordinate units, path syntax, or error behavior, but for a simple setter with a clear parameter example, this is a minor gap.

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

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

Schema description coverage is 0%, but the description fully documents all three parameters: nodes as a list of {path, x, y} objects, detail with explicit allowed values and their output effects, and response_format with yaml/json choices and token implications. This fully compensates for 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 opening sentence clearly states a specific verb and resource: 'Set network-editor position of one or more nodes.' It is easy to understand what the tool does, and the operation is distinct from siblings like layout_align. However, it does not explicitly differentiate itself from those siblings, so it stops just short of a perfect score.

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 or when-not-to-use guidance is provided. The description documents parameters and output formats but never explains when to choose this tool over layout_align or other layout-related operations. An agent is left to infer usage context from the tool name and parameter docs.

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 behavioral burden. It does disclose useful behavior: detail levels, long-list truncation to 25 items with a count, and token-cheap YAML default. However, it never explicitly states that this is a read-only inspection operation with no side effects, permissions, or failure modes, which would matter given the total absence of 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 definition is tightly packed: one scoping summary line followed by three parameter lines. Every sentence carries meaning, defaults are front-loaded, and there is no filler or repetition of schema-only information. The inline parameter format is slightly unconventional but efficient.

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 read-style topology query with zero required parameters and no output schema, the description covers the core invocation details: scope, output granularity, and response format. It is slightly incomplete in that key terms like 'Bypass/Src/Srcpath truth' and 'chain orphan detection' are not expanded, and there is no example return shape, but the agent can still call it correctly with the provided information.

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 parameter description coverage is 0%, but the description fully documents all three parameters: path's root-container purpose and default '/', detail's three allowed values with their output implications, and response_format's yaml/json options with the token-cheap rationale. This substantially compensates for the empty schema and gives the agent actionable semantics.

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 summary line names a specific resource and operation: per-device topology analysis with Bypass/Src/Srcpath truth and chain orphan detection for chained COMPs. It is specific enough to distinguish measure_chain from performance-oriented siblings like measure_fps or measure_cooktimes, though it does not explicitly name a sibling or use a clean 'verb + resource' form.

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 states what the tool measures but gives no explicit guidance on when to choose it over alternatives such as measure_verify or node_list. There are no when-to-use, when-not-to-use, or alternative-routing statements, so the agent must infer applicability from the domain jargon in the summary line.

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 useful behavior: results are sorted most-expensive first, 'summary' truncates long lists to 25 + count, and 'response_format' offers yaml (default, token-cheap) or json. It does not state whether the operation is read-only, what happens when both 'path' and 'paths' are provided, or any prerequisites like an active bridge connection, leaving some 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 front-loaded with a concise purpose statement and then lists each parameter with a short, scannable explanation. There is no filler; every sentence adds value, and the structure is easy for an agent to parse quickly.

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

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

All five parameters are documented and core output behavior is described, but there is no output schema and some interactions remain ambiguous, such as whether 'path' and 'paths' are mutually exclusive, what happens if neither is given, and how 'top' interacts with detail modes. This creates moderate risk for an agent using the tool without additional 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 fully compensates by explaining every parameter: paths, path, top, detail, and response_format. It adds semantics beyond types—clarifying parent/child relationships, allowed detail levels, and the token-cheap yaml default—making the invocation intent clear.

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-resource pair: it measures per-operator cook cost in milliseconds, sorted most-expensive first, and frames it as 'which device is eating the frame.' This unambiguously differentiates it from siblings like measure_gpu, measure_chain, or measure_fps by focusing on operator-level cook times.

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 opening line gives a clear usage context (diagnosing which device consumes frame time) and the parameter descriptions add operational guidance. However, it does not explicitly name sibling tools or state when not to use it, so alternative routing 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?

No annotations are present, so the description carries the full burden of disclosing behavior. It does explain output-shaping details such as summary truncation, minimal mode, and YAML/JSON options, but it never states whether the tool is read-only, what the listed fields actually mean, or what side effects or limitations 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 very compact and front-loads the relevant metric names, and the parameter lines are efficient. However, the opening line is an ambiguous fragment rather than a clear sentence, which harms readability even though it is short.

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

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

With no output schema and no annotations, the description should explicitly say what the tool does and what it returns. It lists metric names and formatting options but omits an explicit operation description, usage context, and any relationship to the sibling measure_* tools, leaving the tool under-specified for an agent.

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 does so well: 'detail' is explained with its three modes and their output effects, and 'response_format' is explained with defaults and a token-efficiency note. The only minor gap is that 'full' is not elaborated, but the overall parameter semantics are clear and useful.

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 the subject area (FPS, realtime flag, cook rate, throttle queue) but never states an action verb like 'measure' or 'return'. It is not a full tautology because it lists specific metrics, but it is vague and does not clearly distinguish itself from sibling measurement tools such as measure_gpu, measure_chain, or measure_cooktimes.

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 about when to use this tool versus the many sibling tools. The description only explains output formatting options, not selection criteria, prerequisites, or context. An agent is left to infer when measure_fps is appropriate.

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

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

With no annotations, the description carries the behavioral disclosure burden, and it does so well: it notes host-side measurement (TD never blocks), NVIDIA specificity, and the require_render error behavior when TD is not rendering and no GPU numbers exist. It does not cover every edge case like permission requirements or exact failure modes, but it is strong for a read-only measurement 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?

The main purpose is stated in one dense, high-signal sentence, and the parameter documentation is compact and directly useful. There is no fluff or redundant restatement of the tool 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 tool with no output schema and no annotations, the description covers the core invocation concerns: when to use it, what the parameters do, and even output granularity via detail levels. It could optionally include a sample or explicit return field names, but the existing description is sufficient for correct selection and invocation in most cases.

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%, yet the description fully documents all three parameters with types, defaults, allowed values, and behavioral implications. This adds essential meaning that the bare input schema completely lacks.

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 the resource (GPU util/VRAM on NVIDIA) and the exact diagnostic purpose (checking whether TD is truly rendering), with the memorable framing 'looks healthy but isn't detector.' This clearly distinguishes it from sibling measure_* tools like measure_fps and measure_verify.

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 clear context for when this tool is useful—when GPU utilization and actual rendering status need to be checked without blocking TD. It does not explicitly name alternatives or say when not to use it, so it stops short of a full 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 no annotations provided, the description must disclose behavioral traits. It explains the operation (round-trip measurement) and output elements, but does not state whether it is read-only, has side effects, or requires specific permissions. The description is adequate but leaves the safety profile implicit.

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

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

The description is concise, front-loaded with the main purpose, and each parameter explanation is purposeful. No redundant sentences; it is efficiently structured.

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

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

The description covers the core functionality and parameters, but lacks an explicit output structure beyond mentioning 'rtt_ms + a live TD value'. Given no output schema, a bit more detail on the exact response format would improve completeness, but it is sufficient for a simple measurement 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?

The description provides detailed explanations for all three parameters (expr, detail, response_format), including defaults and allowed values. Since schema description coverage is 0%, this fully compensates and adds significant meaning beyond 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 clearly states a specific purpose: a round-trip canary over the file bridge, returning rtt_ms and a live TD value. It distinguishes itself from sibling measure_* tools (e.g., measure_fps, measure_cooktimes) by specifying the 'file bridge' context and the absTime default.

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

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

The description explains what the tool does and its parameters, but does not explicitly state when to use it versus alternatives. It implies usage as a diagnostic/measurement tool but lacks explicit when-to-use or when-not-to-use guidance.

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

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

No annotations provided, so description carries full burden. It reveals that the tool clears logs, force-cooks, and re-reads, and that recurring errors are meaningful while one-offs are stale. It also explains output detail options (full, summary, minimal), adding behavioral context. However, it doesn't mention side effects like whether clearing is irreversible or affects other logs, missing some depth.

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?

Efficient, front-loaded action sequence with a diagnostic heuristic at the beginning. Parameter docs are compact, each earning its place with default and trade-off notes. No fluff.

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 4 params, no enums, and no output schema, description covers the operation, parameter semantics, and output options. Complete enough for most calls, but could specify expected return format/fields beyond detail levels, and mention error handling (e.g., if node not found).

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 description must compensate. It explains the purpose of each parameter (path for operator path, force_cook for forced cook, detail for output verbosity, response_format for yaml/json), including defaults and trade-offs (yaml is token-cheap). This exceeds schema's bare type info, though it could give more examples or constraints for path.

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 (clear) and resource (node's script-error log) with an explicit action sequence (clear, force cook, re-read). Distinguishes from siblings like node_errors and node_errors_deep, which are for reading errors, not clearing. The description also provides a diagnostic heuristic (recurring error vs stale) that clarifies intent.

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 'force a cook, re-read' sequence and the recurring vs stale heuristic, but does not explicitly contrast with alternatives like node_errors or node_errors_deep. It gives context on when to use (to confirm live problems) but no explicit when-not-to-use or alternative tool 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, the description carries the full behavioral burden, and it adds meaningful details: TD auto-assigns the name if omitted, summary output truncates long lists to 25 with a count, minimal returns only top-level scalars, and YAML is token-cheap. It does not cover conflict/recursion behavior, but the disclosed behavior is substantive.

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

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

The purpose is front-loaded and every subsequent line documents one parameter or a relevant behavior. There is no filler or redundant restating of schema information, since the schema itself has no descriptions.

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?

All parameters are covered, required fields are clear, and response format options are provided. Although there is no output schema and the exact response body is not specified, the detail and response_format parameters give an agent sufficient guidance. Path syntax and error behavior could be more explicit, but they are not critical gaps for this 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%, so the description fully compensates by explaining each of the 5 parameters with types, defaults, allowed values, and behavior. It adds far more meaning than the bare schema property names.

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 ('Copy'), a resource ('a node'), and a destination ('parent'), with source and destination path parameters. This clearly distinguishes it from sibling tools like node_create or node_rename.

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 core usage is clear from the copy semantics and path parameters, but there is no explicit guidance on when to prefer this over alternatives such as node_create or node_rename, nor any exclusions. The context implies the use case without spelling it 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 provided, so the description carries the full burden of behavioral disclosure. It mentions auto-placement to the right of siblings and output format options (yaml/json) but omits critical details such as return value structure, error handling when parentPath is invalid, permissions required, or reversibility of the mutation. This is insufficient 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?

The description is concise, leading with the core action and then listing parameters in a readable format. It avoids unnecessary fluff, though the parameter list includes type annotations that are somewhat verbose. Overall it is well-structured and 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?

Given the tool has 5 parameters, no annotations, and no output schema, the description is incomplete. It does not specify what the tool returns (e.g., created node path or confirmation), error conditions for invalid parent paths, or any constraints on name/type. These gaps make it inadequate for an agent to call confidently.

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 fully compensates by explaining each parameter with types, examples, and defaults (e.g., 'full (default) | summary...' for detail). It clarifies optional behavior (name assignment, response_format) and provides a concrete type example, adding substantial meaning beyond 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 clearly states a specific action ('Create an operator') with a resource type ('parent COMP') and an example type ('noiseCHOP'). The verb 'Create' distinguishes it from read/list/copy siblings like node_get, node_list, and node_copy, so an agent can immediately tell its purpose.

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 creation but provides no explicit guidance on when to use this tool versus alternatives. It does not mention exclusions, prerequisites, or alternative tools for related operations. An agent must infer that creation is the sole use case.

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

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

With no annotations provided, the description carries the full burden, and it does disclose meaningful behavioral details: whether children are included, how detail levels alter output (truncation to 25, top-level scalars only), and that yaml is the token-cheap default. It stops short of describing error responses or what happens for invalid paths, but the core behavior is well communicated.

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

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

The description is compact and front-loaded with the core purpose, followed by a tight parameter list where each line earns its place. There is 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?

Given there is no output schema and no annotations, the description does a strong job of covering parameters and expected output variants. It is missing explicit error behavior or an example return shape, but an agent can correctly construct a call with just this information.

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 fully compensates by explaining all four parameters: path, includeChildren, detail, and response_format, including their types, defaults, and accepted value meanings. This adds substantial value beyond the raw input 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 clearly states the tool returns errors/warnings for a node, optionally including children, which tells an agent what resource is being accessed. However, it lacks a specific verb like 'get' or 'retrieve' and does not explicitly differentiate from sibling tools such as node_errors_deep or node_clear_script_errors.

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 about when to choose this tool over related siblings like node_errors_deep or node_clear_script_errors. It implies use for reading node errors, but there is no explicit context, exclusion, or alternative recommendation.

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

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

With no annotations provided, the description carries the full burden and does a good job: it discloses that only nodes with problems are returned, explains the three detail modes, and mentions that YAML is the token-cheap default. It stops short of stating side-effect safety explicitly, but 'walk and report' strongly implies a read-only 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 opening sentence establishes the core behavior immediately, and the parameter list is compact and scannable. Every line adds necessary information, and there is no filler or repetition.

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 read-oriented traversal tool with no output schema and no annotations, the description covers purpose, traversal bounds, result filtering, and response shaping. It does not specify the exact result object shape, but the detail mode explanations give an agent enough to interpret the response. Minor gaps remain around what happens when max_nodes is exceeded or how warnings/errors are formatted.

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 carry all parameter meaning. It does so comprehensively by explaining each parameter's role, default value, and valid choices, including the behavior of detail modes and the response_format options. This far exceeds the bare schema alone.

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 tool as a recursive walk that reports every node with cook, warning, parameter-expression, or script errors, and states that only problematic nodes are returned. This is a specific verb+resource pairing and the 'whole subtree' wording hints at the difference from the shallow sibling node_errors, though it does not explicitly distinguish itself.

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 useful context like the default root, recursion limits, and result filtering, so an agent can infer when a deep error scan is appropriate. However, it never explicitly says when to prefer this over node_errors or when not to use it, leaving sibling selection 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?

With no annotations, the description carries the full behavioral burden and does a solid job: it discloses recursion, case-insensitive matching, exact-type matching, default depth, and detail/response format behavior. It does not explicitly state that the operation is read-only, but the search framing strongly implies it; a small transparency gap remains.

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 purpose line followed by tight, information-dense parameter definitions. Every line adds value, and the structure front-loads the core purpose before diving into parameter specifics.

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 covers every parameter with defaults and options, which is strong for a 7-parameter tool with no output schema. It does not explicitly describe the return structure or error behavior, but the detail options and response_format field give a meaningful picture of what to expect.

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 fully compensates by documenting all 7 parameters with defaults, types, case-sensitivity, allowed values, and output formatting choices. This is exactly the kind of semantic detail an agent needs to invoke the tool correctly.

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 states a specific action ('Search for nodes') with clear criteria ('matching name/type/family') and recursive behavior. This clearly conveys what the tool does, though it does not explicitly differentiate itself from sibling tools like node_list or node_get.

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 when to use the tool: when you need to find nodes by name, type, family, or path recursively. However, it does not explicitly state when to prefer node_find over alternatives such as node_list or node_get, leaving sibling differentiation 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?

With no annotations, the description carries the burden and it does explain meaningful output behavior: long lists are truncated to 25 + count for summary, minimal returns top-level scalars, and YAML is the token-cheap default. It stops short of error behavior for invalid paths, but the main behavior of a read-only metadata getter is disclosed.

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 core purpose is the first sentence, followed by three compact parameter definitions with no filler. Every line adds information needed to call the 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 there is no output schema or annotations, the description covers the required path, the output detail levels, and the response format, which is enough to invoke it correctly. An explicit example or missing-path error note would make it fully complete, but they are not critical for this simple getter.

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 schema has 0% property descriptions, and the inline parameter notes fully compensate: path is explained, detail lists all three modes with defaults and truncation semantics, and response_format explains the default and cost implications. This goes well beyond the bare anyOf/string 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 names the exact resource ('one operator') and the returned contents (metadata with params, connections, position), making it a specific single-node lookup rather than a list or search. This is enough to pick it apart from node_list and par_get.

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 explicit statement about when to use node_get versus node_list, node_find, or par_get, and no when-not-to-use conditions. The singular wording implies a lookup case, but the selection context is left entirely 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?

With no annotations, the description carries the full burden. It discloses defaults (path '/', response_format yaml), recursion semantics ('1 = direct children'), output truncation behavior ('long lists cut to 25 + count'), and detail variants. It does not explicitly state side-effect safety, but 'List' strongly implies read-only.

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 clear purpose sentence followed by a compact parameter list. Every line adds information; there is no filler, and the most important scoping statement 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?

The description covers all optional parameters and output modes, but there is no output schema and the exact return fields are only hinted at through detail levels ('minimal (top-level scalars only)'). An agent could call it correctly, but the precise shape of a 'full' result is left implicit.

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 is the only source of parameter meaning. It documents all five parameters with defaults, example values (CHOP/TOP), depth semantics, detail enumerations, and response format choices, adding substantial value beyond 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?

Starts with a specific verb and resource: 'List children of a container'. This clearly separates it from siblings like node_get (fetch a single node), node_find, and node_create. The optional family filter adds further precision.

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 parameter documentation implies usage: list with path, filter by family, depth, and detail level. However, it never explicitly states when to choose this over node_find or node_get, and it gives no exclusion conditions or alternative routing.

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

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

With no annotations, the description carries the burden: it does disclose response-format behavior ('yaml (default, token-cheap) | json') and detail truncation ('long lists cut to 25 + count'). However, it does not disclose side effects of renaming, error behavior, or whether references are updated, which is important for a mutating 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?

One line for the operation plus one line per parameter, with no filler or repetition. Each sentence adds information, and the core action 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?

All required inputs and output-format choices are specified, which is enough for an agent to invoke node_rename correctly. It is slightly incomplete only because it omits error conditions and side effects, and there is no output schema to describe the return payload.

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

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

Schema description coverage is 0%, and the description compensates fully: it defines path as 'Full path of the operator,' name as 'New name for the operator,' and details the allowed values/defaults for detail and response_format.

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 'Rename a node,' a specific verb plus resource, and the parameter docs confirm it changes an operator's path/name. This clearly distinguishes it from node_create, node_copy, node_get, and the other node_* siblings.

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?

When to call it is implied by the verb 'rename,' but the description never states when it is or is not appropriate compared with node_copy or node_set_flags, nor does it mention prerequisites such as the node already existing.

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 does add behavioral context via detail (summary truncates long lists to 25 + count; minimal gives top-level scalars only) and response_format (yaml is token-cheap, json available). However, it does not disclose side-effect semantics, such as what null means for a flag, whether unspecified flags are preserved, whether changes persist, or error behavior on an invalid path.

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 compact, structured list with one line per parameter, including type, default, and valid values. The main verb and target are front-loaded, and there is no filler. It is only slightly repetitive in the three flag lines, which is acceptable.

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 needs to explain what the call returns. It partially does through detail and response_format, which describe output verbosity and serialization, but it never states what the payload actually contains (e.g., updated flags, node status, or full node info). It also omits null semantics, prerequisites, and error handling, leaving an agent unable to fully predict the outcome.

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 fully documents all six parameters: path is the full operator path, display/render/bypass are booleans, and detail and response_format list valid values with defaults. The flag descriptions are somewhat tautological, but the detail/response_format explanations add real meaning beyond the bare schema 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?

The description states a clear verb ('Set') with a specific resource ('display / render / bypass flags on a node') and then enumerates exactly which flags can be set. This makes the tool's scope unambiguous even without explicitly naming sibling alternatives like node_get or par_set.

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 on when to use this tool versus alternatives or what conditions select it. There are no exclusions, prerequisites (e.g., node path must exist), or references to sibling tools such as node_get for reading flags. The usage context is only implied by the imperative verb.

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

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

With no annotations provided, the description carries the full behavioral burden and does meaningful work: it discloses that output files are 'never overwrites', that 'yaml' is 'default, token-cheap', and that 'summary' truncates long lists to '25 + count'. The only notable omissions are an explicit statement that the tool is read-only with respect to the node and the exact mechanism of the diff.

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 opening line is front-loaded and information-dense, and the parameter documentation is organized into a compact per-line structure. Every sentence earns its place, though the inline parameter docs add mild density that could be considered schema material.

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 covers purpose, all parameters, output detail levels, and file behavior well. However, the 'diff two snapshots' workflow is underspecified — there is no diff parameter or description of what the diff output looks like — and the return value shape is left to inference despite the absence of an output 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?

Schema description coverage is 0%, so the description must compensate, and it does: each parameter receives meaning beyond the bare type — path is the 'Operator path', out is a 'JSON file under the project folder', detail enumerates full/summary/minimal with truncation behavior, and response_format explains yaml/json with the token-cost tradeoff. This is strong compensation; only path is terse, so it is not 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?

The description states a specific resource ('Complete parameter state (value/mode/expr/evalError) + flags') and an operation (snapshot/diff), with the 'optionally written to a JSON file' behavior. It is clear what this tool does, but it does not explicitly differentiate itself from closely named siblings such as project_snapshot, bridge_snapshot, or par_get_all, 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?

The phrase 'Diff two snapshots around a risky edit' provides a clear workflow context for when to use the tool — capture state before and after a risky modification. It offers clear context but no explicit exclusions or alternative-tool routing, matching the 'clear context, no exclusions' level.

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

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

No annotations are provided, so the description carries the full burden — and it delivers: it discloses the read-only nature, the detail-level behaviors ('summary (long lists cut to 25 + count)', 'minimal (top-level scalars only)') and the token-cost trade-off of yaml vs json. For a non-destructive read tool this is solid behavioral disclosure, though return structure and error handling are not addressed.

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

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

Purpose is front-loaded in the first line, followed by a clean parameter-per-line layout. The parameter documentation is long, but it earns its place — with 0% schema coverage it is the only parameter documentation the agent sees. No filler, no redundancy.

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

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

For a read tool with 4 params, zero schema descriptions, no annotations, and no output schema, the description covers purpose, filtering, all parameter semantics, and response formats. Gaps are the return payload structure and error behavior, which are minor for a pure read operation given everything else is specified.

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 fully compensates by documenting all four parameters inline with types, defaults, and rich semantics: glob pattern syntax with an example ('t[xyz]'), each detail mode's exact behavior, and the yaml/json format trade-off. Nothing about the parameters is 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?

'Read parameter values, optionally filtered by glob' states a specific verb (read) and resource (parameter values) with a distinguishing filter mechanism. However, among siblings (par_get_all, par_info, par_set_expression) the description doesn't explicitly differentiate par_get from par_get_all, leaving an agent to infer the scope boundary from the glob filter rather than being told.

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 glob parameter ('None = all') and the detail modes imply usage context, and mentioning 'yaml (default, token-cheap)' gives a mild selection hint. But the description never states when to prefer par_get over par_get_all or par_info, nor when not to use it. The guidance is implied, not explicit.

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

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

With no annotations, the description carries the behavioral burden and it does disclose useful behaviors: summary mode truncates long lists to 25 plus a count, and yaml is the token-cheap default. It stops short of discussing error handling or side effects, but 'metadata' and 'get' imply a read 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 compact and front-loaded: one purpose sentence followed by three parameter lines with no filler. Every sentence contributes either scope, option values, or defaults.

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 getter with no output schema, the description covers the path, detail modes, response format, and the shape of returned metadata. It could be more explicit about the exact return container (e.g., list vs object), but nothing essential to making the call is missing.

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

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

Schema coverage is 0%, and the description fully compensates: it documents all three parameters, their valid values (full/summary/minimal, yaml/json), and their defaults. This is exactly the information an agent needs and is absent from the 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 states a specific verb and resource: it retrieves full metadata (mode, bounds, menu names) for every par. The scope 'every par' distinguishes it from the single-par sibling par_get/par_info, though it doesn't explicitly name those 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 given about when to choose this tool over par_get, par_info, or par_set. The phrase 'every par' implies bulk retrieval, but there is no explicit context or exclusion to route an agent.

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

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

With no annotations provided, the description carries the behavioral disclosure burden. It reasonably does so by explaining defaults, summary truncation behavior, minimal detail behavior, and the token-cheap YAML option. It does not explicitly state that the operation is read-only, but 'metadata' strongly implies a non-mutating query.

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

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

The description is compact and efficient: one sentence for purpose followed by tight parameter definitions. Every clause adds information, and the most important usage scoping ('or all if names omitted') 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 no-annotation, no-output-schema metadata tool, the description covers invocation parameters, defaults, and response-format choices well. It stops short of describing the exact metadata object fields, but that is not essential for selecting and correctly invoking the 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?

Since the input schema has 0% description coverage, the description must fully explain the parameters. It does: path is the operator path, names is a list with None meaning all, detail enumerates full/summary/minimal with exact behavior, and response_format enumerates yaml/json with defaults. This is a strong compensation for the schema 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 that the tool returns metadata for named parameters, and that omitting names returns all parameters. It does not explicitly contrast with value-focused siblings like par_get or par_get_all, so sibling differentiation relies on naming convention rather than an explicit statement.

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 useful internal usage guidance, such as 'names = all', detail modes, and response formats. However, it does not explain when to choose this tool over par_get, par_set, or par_pulse, and it provides no exclusions or alternative routing.

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

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

There are no annotations, so the description carries the full burden of explaining side effects. 'Pulse a momentary parameter' indicates a transient trigger action but does not disclose whether it mutates state, whether the parameter must already exist, what happens to the current value, or what the response 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?

The definition is compact and front-loaded with the primary action, followed by a clean parameter-by-parameter list. No filler or repeated schema information is included.

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

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

The tool is simple and all parameters are documented, but with no output schema and no annotations, the description does not explain the response shape or error/edge-case behavior. It is adequate for a straightforward call but not fully self-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%, but the description compensates by defining all four parameters, including the accepted values for detail and response_format. The meanings are terse but actionable; the yaml default is noted as token-cheap, which helps an agent choose sensibly.

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 uses a specific verb ('Pulse') and a specific resource ('momentary parameter'), which clearly distinguishes it from sibling parameter tools like par_get, par_set, and par_set_expression. The action described is not present in any sibling tool name.

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 about when to choose this tool over alternatives, or when it should not be used. Although the purpose implies a momentary-trigger use case, there are no exclusions or comparisons to par_set or other parameter 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 behavioral burden. It adds useful output-shaping behavior via 'detail' (full/summary/minimal) and response_format (yaml default, token-cheap), but does not explain side effects beyond 'set,' error behavior on invalid paths, or what the response actually 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?

The opening sentence states the core action, followed by a compact parameter list with no filler. Every sentence earns its place; the description is both short and information-dense.

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 setter with no output schema, the description covers the operation and response options adequately, but it omits usage context, explicit return-value description, and mutation consequences like whether values are persisted or reversible. Solid for basic invocation, incomplete for fully informed agent decision-making.

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?

Despite 0% schema description coverage, the description documents all four parameters with types and semantics: path, values mapping, detail levels, and response_format choices. This fully compensates for the schema's bare property 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 opens with 'Set one or more parameter values on an operator,' which names a specific verb and resource. It distinguishes from sibling read tools like par_get/par_info by focusing on mutation, though it does not explicitly name par_set_expression as the expression-based alternative.

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

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

No guidance is given for when to use this tool versus par_set_expression, par_pulse, or other parameter-related siblings. There are no usage conditions, exclusions, or mention of what belongs in 'values' versus an expression.

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

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

With no annotations, the description must carry behavioral disclosure. It states the operation but not whether it overwrites an existing value, whether it is reversible, whether it triggers evaluation, or what the response contains. The detail/response_format parameters hint at output behavior but are never explained.

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 brief and the parameter list is compact, but the parameter list largely duplicates the schema properties and is presented as raw text rather than structured documentation. It is not bloated, but the brevity reflects under-specification, not efficiency.

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?

This is a mutation tool with five parameters, no annotations, and no output schema. The description fails to convey the effect on the parameter, required expression semantics, or response format semantics, leaving an agent with significant gaps 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?

The description adds minimal semantics for all five parameters: path is 'Operator path', name is 'Parameter name', expression is 'Python expression string', and it defines detail and response_format options. However, it does not explain the expression evaluation context, path syntax, or interaction between path and name, so it only partially compensates for 0% schema coverage.

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 action ('Put a parameter into expression mode') and identifies the resource (parameter) plus the required inputs (path, name, expression). It is not a tautology, but it leaves 'expression mode' undefined for unfamiliar agents and does not explicitly contrast with par_set, so it is clear but not perfectly differentiated.

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 for when to use this tool versus par_set or par_get. The description does not mention alternatives, prerequisites, or conditions, so an agent cannot determine the right choice from the description alone.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure and does so well: it states the never-overwrite default, the .tox-only restriction, and the detail/response-format behavior. It stops short of describing failure modes or prerequisites, which is a minor 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 compact paragraphs front-load the core contract and then enumerate parameters in a scannable list. Every line earns its place; there is no filler or repetition.

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-annotation, no-output-schema tool with five parameters, the description is nearly complete: it defines inputs, output format, and safety constraints. It lacks explicit error/return-value semantics and prerequisites, so it is not fully self-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%, so the description must compensate, and it fully does: path, out, overwrite, detail (with exact truncation rules), and response_format (with default and token-cheap note) are all meaningfully explained beyond their bare types.

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 the specific action (Save), the resource (COMP), and the target format (.tox), and adds an explicit negative scope ('Never a .toe'). This makes it immediately distinct from related export/import/snapshot tools even without comparing schemas.

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

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

The tool's purpose as a .tox exporter is clear, and the overwrite flag gives conditional behavior, but it never names an alternative tool or states when to prefer e.g. render_export or project_import_tox. Usage context is implied rather than explicitly contrasted with siblings.

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

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

With no annotations, the description carries the full burden of behavioral disclosure. It reveals that .toe files are refused, that the path must be under specific roots, and details how the 'detail' and 'response_format' parameters alter output (e.g., summary cuts lists to 25 + count, yaml is token-cheap). This is substantial behavioral context, though it stops short of describing side effects or error behavior.

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

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

The description is compact and efficiently structured: a one-sentence purpose with constraints, then a per-line parameter list. No filler or repetition; every sentence adds value. It is front-loaded with the most critical information first.

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 (4 parameters, no output schema, no annotations), the description covers purpose, constraints, and parameter semantics thoroughly. It does not explicitly describe the return value or error handling, but the response_format parameter implies the output is a yaml or json document, and for an import tool this is likely sufficient. The gap is minor.

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 schema has 0% description coverage, and the description fully compensates by explaining each parameter: path is the .tox file, parentPath defaults to '/project1', detail has three explicit levels with behavior, and response_format has two options with default and token efficiency. This adds significant meaning beyond the bare schema types and 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?

The description opens with a clear, specific verb and resource: 'Load a .tox into a parent COMP.' It immediately adds scoping constraints (path must be under project folder or $TOUCHBRIDGE_TOX_ROOTS; .toe refused), which distinguishes it from export and other node operations. This is unambiguous and easily differentiated from siblings like project_export_tox.

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 path constraints but does not explicitly state when to use this tool versus alternatives or when not to use it. It implies usage context (importing a tox into a COMP) but lacks explicit 'use this instead of X' guidance. The constraints on path are more about validation than usage routing.

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

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

With no annotations, the description carries the full burden. It does disclose observable behaviors like list truncation ('long lists cut to 25 + count') and format trade-offs ('yaml default, token-cheap'), which adds value. However, it does not mention side-effect safety (e.g., read-only nature), failure modes, or prerequisites like an active project, leaving some behavioral aspects undisclosed.

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 sentences with no filler. The purpose is front-loaded, followed by concise parameter documentation. Each clause earns its place, and the format is scannable and directly 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?

For a simple getter with no required parameters and no output schema, the description adequately covers the tool's data scope and output options. It lacks explicit return-structure details for the different detail levels and any error-handling notes, but the simple nature of the tool means these are minor gaps.

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

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

Schema coverage is 0%, so the description must fully compensate. It does: each parameter is explained with its allowed values and their concrete effects (full/summary/minimal for detail; yaml/json and token-cheap for response_format). This goes well beyond the bare schema and gives the agent actionable semantic understanding.

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-like action: retrieving 'Project + app metadata' and enumerates the fields (name, folder, version, cook rate). It is clear what the tool does, but it does not explicitly differentiate itself from siblings like system_info or project_snapshot, so it misses the top score for sibling distinction.

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