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

With no annotations present, the description carries the transparency burden and does well by disclosing that repeated calls are safe, that timeout returns current state rather than error, and that archived results from reaped agents remain readable. These are non-obvious runtime behaviors that help the agent decide when and how to call the 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 tightly structured: one purpose sentence, then behavioral notes, then parameter explanations. Every sentence adds meaningful information without repetition or fluff. The format uses clear separation and remains easy to scan.

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 most important contextual aspects: repeatability, timeout behavior, run provenance, and archived result accessibility. Since an output schema is present, the description does not need to explain return values in depth. Minor gaps like error cases for unknown run_id are not critical 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 is the only source of parameter meaning. It adds useful semantics: run_id is tied to dsh_delegate/dsh_continue, and wait_seconds is 'Maximum time to block' with tuning guidance for large tasks. This largely compensates for the missing 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 opens with a clear, specific action: 'Wait for a run to finish and return its result.' It identifies the tool's resource (a delegated/continued run) and distinguishes it from siblings like dsh_list, dsh_cancel, and dsh_transcript by directly stating what this wait operation does.

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

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

The description provides clear context for when to use this tool, such as waiting on a run identified from dsh_delegate or dsh_continue, and gives practical guidance to use a longer wait_seconds for big tasks. It does not explicitly mention exclusions or alternatives, but the usage context is unambiguous.

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 excels. It discloses the side effects: 'kills the child process,' 'in-flight run is reported as cancelled,' 'file edits it already made stay on disk,' and the session becomes non-resumable. This level of detail about runtime and session consequences is exemplary.

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 well-organized, leading with the core action, followed by necessary behavioral caveats. Every sentence contributes meaningful information without redundancy. The Args section is minimal and to the point.

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 a single parameter, no nested objects, and an existing output schema, the description covers all essential aspects: what it does, side effects, and parameter purpose. It could optionally mention expected return behavior or error handling, but those are likely captured by the output schema and are not critical for this simple cancellation operation.

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

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

The schema provides zero description for 'agent_id' (coverage 0%), so the description must compensate. It does offer 'agent_id: Agent to stop,' which accurately identifies the parameter's purpose. However, it adds minimal detail beyond the parameter name and does not mention expected format, validation rules, or how to obtain a valid agent_id. It is functional but not enriching.

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

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

The description uses a specific verb and resource: 'Stop a subagent and release its runtime process.' It clearly differentiates from sibling tools like dsh_list, dsh_await, or dsh_continue by focusing on termination and process cleanup. The scope is 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 description explains the critical usage constraint: 'The harness protocol has no mid-turn cancel, so this kills the child process' and warns that 'Cancelling ends the session: its context cannot be resumed.' This provides clear context for when to use the tool, though it does not explicitly name alternative tools or state when not to use it beyond the session-ending implication.

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 carry the burden of behavioral disclosure. It explains queuing behavior, the preservation of context, the optional verification parameter with its consequence (completed_unverified), and the wait_seconds blocking behavior. This adequately covers the tool's operational nuances, though it does not mention potential error conditions or authorization requirements, which are not critical for a follow-up 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 and well-structured. It opens with a one-sentence purpose, follows with a brief contextual note about queuing and context preservation, and then presents a clean, labeled Args list. Every sentence adds value; there is no fluff or repetition. The front-loaded purpose ensures agents quickly identify applicability.

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 moderate complexity (4 parameters, optional verification, wait semantics), the description is complete. It covers the intended use case, operational behavior, and parameter meanings. Since an output schema exists, the description does not need to explain return values. It also implicitly addresses prerequisites by referencing dsh_delegate/dsh_list for obtaining agent IDs.

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

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

Despite a schema description coverage of 0% (i.e., the schema provides no textual descriptions), the description includes an 'Args' section that explains each of the four parameters: agent_id (identifies the target agent), message (the follow-up instruction), verification (optional command to prove completion), and wait_seconds (blocking duration). This adds rich meaning beyond the schema's bare types and defaults, fully compensating for the schema's lack of 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 begins with a clear, specific verb-resource combination: 'Send follow-up work to an existing subagent, in its original session.' This explicitly distinguishes it from sibling tools like dsh_delegate (which presumably creates a new agent) and dsh_await (which waits on runs). The phrasing is precise and immediately conveys the tool's core function.

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

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

The description provides clear usage context by explaining that work is queued if the agent is mid-run and that the agent retains full context, enabling direct references to prior work. It also directs users to obtain agent IDs from dsh_delegate or dsh_list, indicating alternatives. However, it does not explicitly state when not to use this tool, such as when a fresh context is needed, so it stops short of full exclusion 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 are provided, so the description fully discloses behavior: creates a fresh agent per call, returns immediately unless wait_seconds, child cannot ask clarifying questions (must include acceptance criteria), verification exit code decides unverified vs completed, workspace resolution, and defaults. This is thorough behavioral disclosure.

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

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

The description is well-structured: a lead paragraph stating purpose and key behavior (fresh process, immediate return), then a clean Args section with one line per parameter. Each sentence adds value; no fluff. Front-loads the most important behavioral facts.

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 meaning, explains control flow (wait_seconds), explains the verification command's role in determining completion status, and mentions the sibling tool dsh_continue. It is complete enough for an agent to correctly invoke this tool without further 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 has no descriptions (0% coverage). The description compensates fully: it explains task (with acceptance criteria and inability to clarify), verification (shell command, exit code semantics), workspace (relative paths, default), instructions (prepended standing guidance), model (default), name (human label), and wait_seconds (blocking behavior). Every parameter is given meaningful semantics beyond the schema's type-only definition.

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

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

The description clearly states the verb (start) and resource (a new DeepSeek Harness subagent), explains the immediate-return behavior, and explicitly distinguishes this from 'dsh_continue' for giving more work to existing agents. This effectively differentiates it from 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 provides explicit guidance: states when to use dsh_continue for existing agents, explains the wait_seconds behavior, and describes the verification command's role in determining run status. This clearly orients the agent on when to invoke this vs. alternatives.

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, and the description does not explicitly state whether the operation is read-only, what side effects it might have, or any access requirements. It only lists what it returns.

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

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

The description is a single, clear sentence that efficiently conveys the tool's purpose and output without any 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?

The description mentions the output attributes (state, cost, run history) and scope ('this server owns'), but does not discuss pagination, ordering, or other response details. Given an output schema is present, this is adequate.

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

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

The tool has no parameters, and the description correctly omits any parameter details. With zero parameters, this is a baseline score of 4.

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 (List) and the resource (subagents) with specific attributes (state, cost, run history), making it distinct from sibling 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?

It is implied that this tool is for listing subagents, but there is no explicit guidance on when to use it versus alternatives like dsh_transcript or others.

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?

Without annotations, the description carries the transparency burden. It explains that it returns the tail of the activity log, live data, and the effect of the 'raw' parameter. It implies read-only behavior by saying 'Show' and 'Returns', but doesn't explicitly state it has no side effects. This is adequate given the tool's nature.

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 well-structured with a clear overview and parameter explanations. It is slightly verbose but each sentence adds value. It is not overly long relative to the complexity of 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?

The description covers the tool's purpose, typical use cases, return behavior, and parameter semantics. It doesn't explain output schema (not required), but it provides enough context for an agent to decide when and how to use it. The mention of dsh_delegate relationship adds completeness.

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

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

The description explains each parameter beyond the schema: run_id (which run), limit (how many recent lines), and raw (full uncapped response). It also connects raw to dsh_delegate, adding context. Since schema coverage is 100%, the baseline is 3, but the extra semantic detail raises it to 4.

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

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

The description clearly states the tool's function: 'Show what a subagent did during a run.' It specifies the content returned (tool calls, assistant messages, turn endings) and distinguishes it as a transcript tool for inspecting activity.

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

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

The description provides clear usage scenarios: 'Use this to check progress on a long run, or to understand a failure.' It also mentions live data during a run, but does not explicitly contrast with sibling tools like dsh_list or dsh_delegate, which would make the guidance stronger.

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