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

With no annotations, the description carries the full burden, and it does disclose one meaningful trait: 'Replace' implies the existing breakpoint set is overwritten rather than appended, which is destructive behavior an agent must know. However, it says nothing about authentication/attach requirements, error behavior, or the timeout, so disclosure is partial.

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

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

A single front-loaded sentence with no filler or redundancy. It is efficient, though its brevity is partly a result of under-specification rather than disciplined editing.

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 mutating tool with nested object parameters, zero schema descriptions, no annotations, and no output schema. The description supplies only a DAP reference and never explains the required 'kind' dispatch, the replacement semantics per kind, or the timeout, leaving significant gaps for an agent to fill.

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

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

Schema description coverage is 0% across four parameters, including two open nested objects with additionalProperties, so the schema alone is nearly uninformative. The phrase 'native DAP argument shapes' is a useful hint about the structure of 'source' and 'breakpoints', but 'timeoutMs' is undocumented and the nested object contents are left entirely to the caller's DAP knowledge.

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 ('Replace') and resource ('breakpoints'), and the three variants it lists (source, instruction, data) exactly mirror the required 'kind' enum. It is clear what the tool does, though it never contrasts itself with nearby siblings such as dolphin_watch or dolphin_execution.

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

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

There is no statement of when to choose this tool over alternatives, nor any preconditions (e.g. must be connected/attached first, must be paused). The one-word 'Replace' hints at how it differs from a hypothetical add-breakpoint tool, but nothing is stated explicitly.

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, and it discloses almost nothing: code injection and detours are inherently destructive and likely require an active process and elevated context, yet nothing about permissions, reversibility, side effects, or failure modes is stated. The timeoutMs parameter and its 0–300000ms bound are never mentioned in the description.

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

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

A single front-loaded sentence listing the main operations with no filler or hedging. It is efficient, though the list is incomplete (missing memoryRegions) and arrives with no structural cues for the multi-action layout.

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 multi-action tool with an untyped nested arguments object, no output schema, and no annotations, the description is too thin: per-action argument shapes, connection prerequisites, return behavior, and the fifth action are all absent. There is no output schema to defer return-value explanation to, so the gaps stand.

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 both the action enum and the untyped 'arguments' object (additionalProperties: {}) are undocumented. The description maps to only four of five action values and says nothing about which keys 'arguments' expects per action or what timeoutMs controls, so it fails to compensate for the coverage 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 names four specific operations (find free memory, inject raw PPC code, create a detour, resolve a pointer chain), which is far more informative than the bare name 'dolphin_code'. However, it omits the fifth enum value 'memoryRegions' and gives no differentiation from siblings like dolphin_memory or dolphin_disassemble, leaving overlap ambiguous.

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

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

There is no statement of when to use this tool versus alternatives, no prerequisites (e.g. a connected/running Dolphin session), and no exclusions. The line reads as a capability list rather than usage guidance, so the agent must guess context from sibling names 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?

No annotations are provided, so the description carries the full burden of behavioral disclosure. It states only that it connects and initializes, but does not describe prerequisites (e.g., server must be running), side effects, timeout behavior, lifecycle semantics, or what happens on failure. This is a significant gap for a connection 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 a single front-loaded sentence with no filler, and every word contributes. It is appropriately concise, though its brevity contributes to under-specification rather than being a structural flaw in itself.

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, no output schema, and 6 parameters at 0% description coverage, the one-sentence description is far from complete. It omits parameter guidance, behavioral details, and return information, leaving significant gaps for an agent to call 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?

The schema has 6 parameters with 0% description coverage, and the description mentions none of them (host, port, lifecycle, timeoutMs, socketPath, stopOnEntry). No parameter meaning is added beyond what the bare schema provides, leaving an agent without guidance on how to configure the connection.

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 ('Connect and initialize') and resource ('Dolphin DAP server'), and the word 'existing' implicitly distinguishes it from the sibling dolphin_start (which presumably creates a new server). It does not explicitly name the alternative, so it falls 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 'existing Dolphin DAP server' implies a usage context (use when the server is already running), but there is no explicit when-to-use, when-not-to-use, or named alternative like dolphin_start. This is implied usage rather than clear 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?

With no annotations provided, the description carries the full burden of behavioral disclosure but states only what the tool does, not how it behaves. It doesn't mention whether this is a read-only operation, what permissions or session state are required, what the return format looks like, or how timeoutMs affects behavior. For a tool that likely queries live emulator state, this is a significant gap.

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

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

The description is a single, efficient sentence with no wasted words. It is appropriately sized but does not compensate for the lack of detail elsewhere, though conciseness itself is good.

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 five parameters and zero schema descriptions, no annotations, and no output schema, the description is inadequate. It should explain the address format, offset semantics, and what disassembly output to expect. The complete absence of behavioral and parameter context leaves the agent unable to invoke this tool correctly without trial and error.

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 for five parameters, but it adds no parameter information beyond the required 'address'. Parameters like byteOffset, instructionOffset, instructionCount, and timeoutMs have no explanation of their meaning or expected format. The description fails to convey whether address is hexadecimal, symbolic, or what units the offsets use.

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 (Disassemble) and resource (PPC instructions), which is clearer than the bare tool name. However, it doesn't distinguish itself from the sibling dolphin_code or clarify what 'emulated address' means in the context of Dolphin emulation. The purpose is understandable but lacking in precision regarding scope and 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?

No guidance is provided on when to use this tool versus alternatives like dolphin_code or dolphin_memory. The description offers no context about whether this requires an active debug session, whether the address must be in a specific memory space, or any prerequisites.

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

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

No annotations are provided, so the description bears full responsibility for behavioral disclosure. It does not explain what 'disconnect DAP' entails, potential side effects, or whether 'terminateDolphin' kills a process forcefully. The lack of detail is significant for an operation that may terminate a process.

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

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

The description is a single, front-loaded sentence that efficiently conveys the core functionality and the optional behavior. No unnecessary words are present.

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 that may terminate a process, and with no annotations or output schema, the description is incomplete. It omits critical details such as side effects, whether the process is terminated gracefully, and any required permissions or states.

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%, meaning the single parameter 'terminateDolphin' is not documented in the schema. The description does clarify that it 'optionally terminate[s] a Dolphin process started by this server', which adds meaning. However, it does not specify the default (false) or the implications of setting it to true.

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

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

The description clearly states the action: disconnect DAP and optionally terminate a Dolphin process. It distinguishes itself from sibling tools like dolphin_start and dolphin_connect by focusing on disconnection. However, no explicit sibling differentiation is provided in the text.

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

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

The description gives no guidance on when to use this tool versus alternatives, nor any preconditions or warnings. It merely states what the tool does, leaving the agent to infer usage 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?

No annotations, so the description bears full behavioral burden. It says 'drain queued' and 'wait for one named event' but doesn't explain blocking behavior, timeout handling, what happens when no event arrives, whether draining removes events from the queue, or concurrency semantics – all critical for an async event-consuming 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?

Single sentence, front-loaded with the main verb, no filler. Appropriate length for a two-parameter tool, though the ambiguity of the two modes could have been clarified with one more sentence.

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 an async event tool with zero annotation coverage, 0% schema descriptions, and no output schema, the description is insufficient. It doesn't clarify return shape, timeout behavior, queue semantics, or how this interacts with other dolphin_* calls.

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

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

Schema coverage is 0%, so the description must compensate. It mentions waiting for a named event (corresponding to waitFor) but gives no format, case-sensitivity, or valid names; timeoutMs is never mentioned, leaving its default and max completely undocumented in prose.

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: drain DAP events and wait for named event. Clearly distinguishable from siblings like dolphin_request or dolphin_disconnect, though 'DAP events' assumes domain knowledge and doesn't mention the debugging context explicitly.

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

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

Implied that you use this when you need to consume queued events or synchronize on a specific event. No explicit when-not-to-use or alternatives offered (e.g., when to use waitFor vs. polling).

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 full behavioral disclosure. It simply lists actions and does not warn about destructive operations (terminate, restart), side effects, permissions, reversibility, or how timeoutMs and awaitState affect 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 a single, front-loaded sentence that lists the tool's actions without waste. It is appropriately sized for the high-level purpose, though the brevity contributes to gaps elsewhere.

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

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

For an execution-control tool with destructive actions, no annotations, no output schema, and 0% schema description coverage, the description is far too thin. It does not explain parameter behavior, return values, side effects, or safe usage conditions, leaving the agent without enough context to invoke it correctly.

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

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

Schema description coverage is 0%, so the description must explain the four parameters. It partially maps the required action parameter by naming several commands, but ignores timeoutMs, awaitState, and granularity entirely, leaving most parameter semantics undocumented.

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

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

The description states specific verbs (pause, continue, step, restart, terminate, inspect) and a clear resource (Dolphin's PPC execution state). It distinguishes from most siblings by focusing on execution control, though it does not explicitly name an alternative tool or clarify overlap with status or breakpoints.

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 controlling execution but gives no when-to-use guidance, prerequisites, or alternatives. An agent must infer that this is the right tool for execution state changes versus other Dolphin siblings like status or start.

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. It mentions that reads return base64 and hex data, but doesn't describe write behavior, permissions, error conditions, timeouts, or partial read handling. With 8 parameters and no annotations, this is a significant gap.

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

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

Two short sentences with no waste. The core action is front-loaded, and the return format detail follows 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?

With 8 parameters, no annotations, no output schema, and 0% schema description coverage, the description is far too sparse. It should explain parameter usage, memory model, write semantics, and error behavior. The single sentence about return format is insufficient for a tool of this complexity.

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

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

Schema description coverage is 0%, and the description only mentions that reads return base64 and hex, which is not parameter-specific. Critical parameters like action, address, count, offset, encoding, timeoutMs, and allowPartial are entirely undocumented in the description. The description fails to compensate for the schema's lack of parameter 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?

States a clear verb and resource: read or write emulated memory. This is specific but does not differentiate from siblings like dolphin_scan or dolphin_variables, which could also involve memory access. The purpose is clear but sibling differentiation is absent.

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 such as dolphin_scan, dolphin_variables, or dolphin_watch. The agent must infer from the name alone. No exclusions or contexts 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 full behavioral burden and does not meet it. It says nothing about whether requests mutate debuggee state, how timeoutMs affects blocking, what awaitEvent does, or how errors/unsupported commands are surfaced, for a tool whose side effects are entirely command-dependent.

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

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

Two sentences with zero filler and the core purpose front-loaded, so structure is clean. But for a complex escape-hatch tool with four undocumented parameters, this brevity tips into under-specification rather than disciplined concision.

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 high-complexity, command-agnostic protocol tool with no annotations, no output schema, and 0% schema coverage, yet the description explains neither request/response shape nor parameter behavior. An agent cannot confidently construct a DAP request from this description alone.

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

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

Schema description coverage is 0% across 4 parameters, and the description adds no meaning for command, arguments, timeoutMs, or awaitEvent. The nested arguments object and the awaitEvent string are especially opaque; the agent gets no help on accepted command values or the semantic difference between awaiting an event and a bare response.

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 (send) and resource (standard or Dolphin-specific DAP request), and the phrase 'complete protocol escape hatch' signals this is the generic fallback relative to the specialized siblings like dolphin_execution and dolphin_stack. It doesn't name a specific sibling, but the scope ('any standard or Dolphin-specific DAP request') is clear enough to distinguish it from the targeted 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?

'This is the complete protocol escape hatch' implies the tool is for cases the specialized request tools do not cover, which is useful implied guidance. However, it never states explicitly when to prefer this over dolphin_execution, dolphin_variables, etc., nor any prerequisite or exclusion, leaving the agent to infer the fallback role.

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 implies several operations, but does not disclose side effects, which actions mutate or destroy scan data, permission requirements, whether refine depends on a prior scan, or how timeoutMs and awaitCompletion affect execution.

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?

It is a single, front-loaded sentence with no wasted words. However, for a complex action-multiplexing memory-scan tool, this level of brevity leaves the agent without enough structure to safely choose and invoke an action.

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

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

Given four parameters, a nested object, zero schema description coverage, no annotations, and no output schema, the description is far too thin. It does not explain action arguments, return values, action ordering, or how the scan lifecycle is intended to be managed.

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

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

Schema description coverage is 0% for four parameters, including a nested free-form arguments object and timeoutMs/awaitCompletion fields. The description's action list does not map cleanly to the action enum and supplies no semantics for arguments, timeoutMs, or awaitCompletion.

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?

It states a resource, 'Dolphin memory scan,' and lists multiple verbs, so the general domain is clear. However, the listed actions do not fully match the action enum ('inspect'/'filter' vs. 'status'/'results'/'removeResults'), and it does not distinguish this multiplexer from siblings such as dolphin_memory, dolphin_start, or dolphin_status.

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

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

The description provides no guidance on when to use this tool versus its many dolphin_* siblings, nor any prerequisites, ordering of actions, or conditions for choosing start/refine/status/results/cancel/etc. It only lists possible operations.

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 state whether the operations are read-only, what permissions are required, how large source text can be, or how timeoutMs behaves, leaving significant behavioral gaps.

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

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

The description is a single front-loaded sentence with no wasted words. Its brevity is appropriate structurally, though it omits necessary detail at the expense of completeness elsewhere.

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

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

For a tool with three parameters, a nested arguments object, no output schema, and no annotations, the description is too thin. It explains the action options but says nothing about argument payloads, timeout behavior, or return format, so an agent cannot confidently invoke the read or breakpointLocations actions.

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

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

Schema description coverage is 0%, so the description must compensate. It only names the three action values and gives no meaning for the arguments object or timeoutMs, leaving two of three parameters effectively undocumented.

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

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

The description names three concrete operations—listing loaded sources, fetching source text, and querying valid breakpoint lines—which clearly states the tool's purpose. It does not distinguish itself from siblings like dolphin_breakpoints, so it falls 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 three operations loosely imply when to use the tool, and the action enum values (list, read, breakpointLocations) map directly onto them. However, there is no explicit guidance on when to choose this tool over dolphin_breakpoints or other siblings, nor any exclusions.

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

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

No annotations are provided, so the description carries the full disclosure burden. It does hint at conditional data ('when available'), but says nothing about whether the debug target must be halted, whether the call is cheap or blocking, or how levels/startFrame affect the returned 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?

A single front-loaded sentence with no filler; the core operation leads and the supplementary detail follows. It is arguably too terse rather than too long.

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 annotations, no output schema, and three undocumented parameters, the definition leaves an agent guessing about preconditions, defaults, and return shape. For a debugging tool that likely depends on run-state, this is materially 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?

All three parameters (levels, timeoutMs, startFrame) have 0% schema description coverage and the description does not compensate for any of them. It never explains that levels caps stack depth, that startFrame skips frames, or that timeoutMs bounds the wait — the most useful semantic, startFrame-based paging, is left entirely undocumented.

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

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

States a specific verb and resource — 'Get the PPC call stack' — and adds what the result contains (DWARF source paths and lines). That is enough to separate it from sibling tools like dolphin_variables, dolphin_memory, or dolphin_disassemble, though it never explicitly names a sibling to contrast against.

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

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

The description offers no when-to-use guidance, no prerequisites (e.g. target must be paused), and no mention of alternatives such as dolphin_execution or dolphin_status. An agent must infer that this tool is for inspecting the current call stack.

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 discloses that a process is launched and a DAP server connected, but says nothing about blocking behavior, whether an existing session is replaced, the meaning of headless/timeoutMs, or failure modes for an 8-parameter process-launching 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?

A single sentence, front-loaded with the verb and primary resource, with no filler. It is efficient, though its terseness is part of why so much parameter and behavioral context is missing.

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 launch tool requiring two mandatory paths plus six optional settings, with no annotations, no output schema, and no parameter descriptions, the definition is too thin. An agent cannot reliably determine required vs optional inputs, defaults, or what a successful launch 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% across 8 parameters, so the description must compensate. It only accounts for three (elf, disc, sourcePaths) and leaves executable, port, headless, timeoutMs, and stopOnEntry entirely undocumented, forcing the agent to guess their semantics and defaults.

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

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

The description names a concrete verb and resource ('Start Dolphin'), lists the key inputs (ELF, optional disc, source roots), and states the side effect of connecting the DAP server. This distinguishes it from the sibling dolphin_connect, though it doesn't explicitly say when to prefer one over the other.

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

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

Usage is only implied: launching Dolphin includes connecting its DAP server, so the agent can infer this is a setup/launch step. However, there is no explicit guidance on when to use this versus dolphin_connect, nor any prerequisite or exclusion (e.g., what to do if a session is already running).

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, but 'Show' clearly signals a non-mutating read and the enumerated outputs (state, capabilities, queued events, PID) tell the agent what information it yields. It does not clarify whether calling it has side effects on queued events, or whether it requires an active connection.

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

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

A single front-loaded sentence with no filler; the verb comes first and the reported fields follow immediately. Every clause 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 zero-parameter read tool with no output schema, the description usefully enumerates the return content, which is the main thing an agent needs. It is only slightly short of complete because it omits any precondition about connection state.

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

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

The tool takes zero parameters, so there is nothing to document and the baseline of 4 applies. The description does not need to compensate for any parameter semantics 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?

States a specific verb ('Show') and enumerates the exact resource it reports: DAP connection state, capabilities, queued events, and managed Dolphin PID. This lets an agent distinguish it from dolphin_connect/disconnect/events without opening a schema, though it never explicitly names a sibling.

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

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

There is no when-to-use guidance, no statement of prerequisites or ordering relative to dolphin_start/dolphin_connect, and no mention of alternatives. The agent must infer from the name that this is a diagnostic read to call after connecting.

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. 'Set a register' signals a mutation, but the description doesn't say whether it requires an active/paused debug session, whether it is reversible, or what happens on failure, and it never distinguishes read-only actions (scopes/variables/evaluate) from the write action (set).

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 front-loaded sentence with no filler or repetition, though its compactness comes partly from omitting information the tool needs rather than from disciplined editing.

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-action, 7-parameter debugger tool with no annotations, no output schema, and 0% parameter documentation, the description is far too thin. It leaves the action-to-parameter mapping, the mutation semantics of 'set', and the distinction between scopes and variables entirely unresolved.

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 seven parameters exist. The description mentions only 'register' and 'expression' at a conceptual level and adds nothing about name, value, frameId, timeoutMs, or variablesReference, nor which parameters pair with which action. It fails to compensate for the total absence of schema documentation.

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

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

The description names three capabilities (inspect scopes/variables, set a register, evaluate a PPC expression) and the enum confirms four action values, so the general domain is clear and distinguishable from siblings like dolphin_memory or dolphin_stack. However, it never ties the verbs to the action enum values ('set' maps only loosely to 'set a register', and 'scopes' vs 'variables' are merged into one phrase), so an agent must guess which mode it is selecting.

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 choose this tool over dolphin_memory, dolphin_stack, or dolphin_watch, and no indication of which action requires which parameters. The only implicit hint is that evaluation/setting concerns registers and expressions.

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

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

With no annotations, the description carries the full behavioral burden. It discloses that the tool mutates state (creating/cancelling watches, freezing/unfreezing memory) but says nothing about what a freeze does to a running emulator, whether actions are reversible, or how the timeoutMs default interacts with long-running watches. That is a real gap 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 definition is a single front-loaded sentence with no filler, which is structurally efficient. It is arguably too terse for a tool with four actions and an untyped nested arguments object, but there is no wasted text.

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

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

Given four enum actions, a required nested arguments object with additionalProperties, no annotations, and no output schema, the description is not complete enough to invoke the tool confidently. An agent would not know what to put in 'arguments' for a watch versus a freeze, or what a successful call 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%, and the nested 'arguments' object accepts arbitrary properties, so the description needed to explain what each action expects. It only restates the four action names that the enum already provides and says nothing about the required arguments shape or timeout behavior. The opaque nested object is left entirely unexplained.

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

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

The description names four concrete operations with verbs and resources: create/cancel watches and freeze/unfreeze emulated memory. That distinguishes it from sibling tools like dolphin_memory and dolphin_variables, though it never names an alternative explicitly. The purpose is clear enough for an agent to know what this tool does.

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

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

There is no guidance on when to choose this tool over dolphin_memory, dolphin_variables, or any other sibling, nor any prerequisite or context for using watches versus freezes. The action names imply the four modes of use, but that is the schema's enum, not usage guidance. An agent gets no routing help.

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