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

Annotations already declare destructiveHint=true, so the destructive nature is covered structurally. The description adds a useful nuance—that calling it on an idle session is safe—which goes beyond the annotation. However, it does not disclose whether aborting is irreversible, whether a running computation is killed, or what happens to partial results.

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, no filler, and the core action is stated first. The safety note is useful and 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 one-parameter destructive action with no output schema, the description is nearly complete: it states purpose and a safe-call condition. It could be slightly richer by explaining the post-abort state of the session, but an agent can invoke this tool correctly with what is 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 description coverage is 100%, and the single parameter session_id is already fully documented as the session id returned by create_session. The tool description adds no further parameter guidance, so the baseline score of 3 applies.

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

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

The description uses a specific verb ('Stop') with a clear resource ('a long-running or unwanted delegated task'), and the title names the action and object. It is immediately distinguishable from siblings like create_session and get_session.

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 signals about when to use it: for long-running or unwanted delegated tasks. It also provides a useful safety condition ('Safe to call when the session is already idle'). It does not explicitly name alternatives or describe when not to use it, but the context is sufficient for most selection decisions.

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?

Beyond the minimal openWorldHint annotation, the description discloses meaningful behavior: the session is persistent, no task runs on creation, and the agent's context is retained between calls when used with send_message. This adds real behavioral context beyond what the structured annotation provides.

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. The core purpose and scope are front-loaded in the first sentence, and the second sentence earns its place by explaining the interaction protocol with send_message.

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 create operation with a fully documented schema, the description is mostly sufficient. However, with no output schema and an openWorldHint, it would help to state what the call returns (e.g., a session identifier to use with send_message) and any workspace requirements, so an agent is left with a small gap about the 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?

Schema description coverage is 100%, so the input schema already documents all four parameters. The description adds no parameter-level meaning, so the baseline of 3 applies; nothing is missing, but nothing extra is contributed either.

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 (create), a specific resource (persistent delegation session in a workspace), and a critical constraint ('without running a task yet'). This last phrase directly distinguishes it from the sibling delegate_task, so an agent can tell the tools apart without opening 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 description gives a clear workflow context: create the session first, then follow up with send_message to keep the agent's context across calls. It does not explicitly name delegate_task as the alternative for one-shot task execution or state when not to use this tool, so it stops short of full when/when-not 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?

Annotations only include openWorldHint, so the description carries the burden. It discloses that read-only agents cannot modify files, coder agents can edit and run tests, and that allow_edits=false disables edit tools. It also states the return object shape. This adds meaningful behavioral context beyond the minimal annotation, though it doesn't mention potential side effects like long execution times or concurrency limits.

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 few dense sentences, front-loaded with the core purpose, then agent capabilities, then return format. There is no fluff; each sentence adds useful information. It could be slightly more structured with separators, but it is concise and effective.

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 7 parameters and no output schema, the description compensates well by listing the return fields (status, session_id, summary, findings, files_changed) and explaining agent behavior. It does not cover error handling or timeout specifics, but the essential information for calling the tool correctly is present. Minor gaps remain but are not critical.

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 100%, so the baseline is 3. The description adds value by clarifying agent capabilities (deepseek-researcher/reviewer vs coder) and the effect of allow_edits, which goes beyond the schema's generic descriptions. It also reiterates the 'hints only' nature of paths, reinforcing schema content. This exceeds the baseline.

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 ('Delegate'), a specific resource (OpenCode agent in the same workspace), and the outcome (returns a summary plus structured findings). It clearly distinguishes this from the sibling session-management tools like create_session or send_message by framing it as a task delegation that includes agent exploration and structured findings.

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 when to use different agents (read-only vs coder) and how to force edit tools off via allow_edits=false, which is useful. However, it does not explicitly contrast this tool with siblings such as create_session or send_message, so an agent might not know when to choose delegation over direct session operations. Usage context is implied but not fully explicit.

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

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

Annotations already provide readOnlyHint=true, and the description adds meaningful behavioral context by explaining the fallback from OpenCode's session diff to a git diff against the baseline. This goes beyond the annotation's safety signal, though it doesn't mention what happens when no diff exists.

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

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

A single, front-loaded sentence that states the primary action first and then details the fallback. No filler or redundant information.

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

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

For a one-parameter, read-only tool with no output schema, the description adequately explains what is returned and how the diff is sourced. Minor omissions, such as behavior when no diff is available, are acceptable given the tool's simplicity.

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 100%, and the schema already explains session_id as 'Session id returned by delegate_task/create_session.' The description does not add any further parameter semantics, so the baseline score of 3 applies.

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

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

The description uses a specific verb ('Return'), names the resource ('file changes associated with a delegated session'), and specifies the diff-source fallback logic. This clearly distinguishes it from siblings like get_session, which deals with session metadata rather than file changes.

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

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

The description clearly implies when to use the tool: to inspect file changes for a delegated session. The sibling list makes alternative purposes evident, but the description does not explicitly state exclusions or alternative tool names, so it falls short of a 5.

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

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

The readOnlyHint annotation already covers the safety profile, and the description adds useful behavioral nuance: the stored session state is always returned, while live OpenCode status is only included when a server is running. This conditional behavior is valuable context beyond the annotation.

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 filler. The main purpose is front-loaded, and the sibling reference to get_diff earns its place by clarifying tool boundaries.

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-only tool with one well-documented parameter, the description provides sufficient invocation context. It could name the fields contained in 'stored state' or describe the no-server behavior more explicitly, but those are minor gaps given the schema and readOnlyHint.

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 100% and the session_id parameter is already well-described as the ID returned by delegate_task/create_session. The description itself adds no further parameter meaning, so the baseline of 3 is appropriate.

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 ('Return') and names the exact resource: the stored state of a delegated session plus live OpenCode status. It also distinguishes itself from get_diff by telling the agent to use get_diff for file changes, which prevents confusion among 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?

It gives clear context for what get_session returns and points to get_diff as the alternative when inspecting file changes. It does not explicitly enumerate when not to use get_session, but the comparison to get_diff provides enough routing 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?

The readOnlyHint annotation already covers the key safety behavior Photon, so the description does not need to restate that. It adds useful context by mentioning project-local agent discovery from .claude-opencode/agents and the role of cwd. It does not describe output format or failure behavior, but no contradiction exists and the annotation lowers the burden.

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

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

The description is a single sentence that leads with the core action and resource, then adds the most important scoping detail about project-local agents. Every part earns its place; there is no filler or redundancy.

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

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

This is a simple, read-only listing tool with no required parameters and no complex schema. The description plus the cwd parameter documentation is sufficient for an agent to know what the tool does and when to call it. The absence of an output schema is acceptable given the straightforward 'list' semantics.

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

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

The only parameter, cwd, is already fully described in the schema with 'Workspace used to discover project-local agents (optional).' The description adds a small amount of context by linking cwd to the .claude-opencode/agents discovery mechanism, but schema coverage is 100%, so the baseline applies.

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

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

The description names a specific verb ('List') and resource ('agents that delegate_task and create_session can use'), making the tool's purpose immediately clear. It also distinguishes this listing tool from the action-oriented siblings like delegate_task and create_session. The inclusion of project-local agents adds useful 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 implies when this tool is useful: before delegating or creating a session, to discover available agent names. It names the consumer tools explicitly and clarifies the optional cwd behavior for project-local discovery, but it does not state formal exclusions or contrast directly with sibling listing 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?

The openWorldHint annotation already signals that the tool may interact with external systems. The description adds useful context by stating that the agent retains previous context and can build on earlier exploration and edits, but it does not describe side effects on the session, response format, or failure behavior. This is adequate but not richly transparent.

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 two sentences with no filler. The first sentence states the core purpose, and the second sentence adds valuable context about state retention. Every word contributes to an agent's ability to decide whether and how to use 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?

For a simple two-parameter tool with openWorldHint and no output schema, the description provides sufficient context: it explains the stateful nature, when to use it, and what the message is for. It does not explain return values or error handling, but these are less critical given the tool's simplicity and the explicit session_id and message 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 100%, so both session_id and message are already documented. The description's mention of 'follow-up' reinforces that message is an instruction building on prior context, but it adds no new meaning beyond the schema. Baseline 3 is appropriate because the schema carries the parameter documentation burden.

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 ('Continue an existing delegated session with another message') that clearly distinguishes it from sibling tools like create_session, delegate_task, get_session, and abort_session. The emphasis on 'existing' and 'follow-up' makes it unambiguous that this is not for initiating or inspecting sessions.

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 indicates when to use this tool: when a delegated session already exists and the agent wants to continue it. It does not explicitly name alternatives or state when not to use it, but the context provided (existing session, previous context) is enough to infer that this is the follow-up tool rather than a session creation or retrieval tool.

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