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

With no annotations, the description carries the full burden and does real work: it discloses that running cancellation blocks until the worker process tree termination is confirmed, and warns that status 'completed' reflects only Bridge/ZCode execution and normalization, not host acceptance of the work. It still omits idempotency behavior, error cases (unknown/finished task_id), and any permission requirements.

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 the first sentence and the remaining content is substantive rather than filler. The final clause is slightly run-on and begins mid-sentence with a lowercase 'the', which hurts readability but not materially.

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 mutation tool with no annotations, the description supplies the blocking semantics and an important interpretation caveat for results, and an output schema exists so return format need not be restated. The main gap is the total silence on the required task_id parameter and on failure modes.

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 single parameter task_id is never mentioned in the description — no format, no source, no guidance on obtaining a valid id. With one undocumented parameter, the description does not compensate 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?

States a specific verb and resource ('Cancel a queued or running task') and constrains the scope to queued or running tasks, which distinguishes it from read-only siblings like zcode_status and zcode_result. It does not name any sibling explicitly, 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?

Usage is implied: cancel when a task is queued or running. There is no explicit when-not-to-use guidance, no statement about what happens if the task has already finished, and no alternative tool named, so this is minimum-viable rather than instructive.

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 usefully discloses the downstream effect on future tasks, but says nothing about whether the change is reversible, whether it errors when no Bridge default is set, or what permissions it requires 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?

A single sentence that front-loads the action and then the effect, with no filler or redundancy. 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?

An output schema exists, so return values need no explanation, and the zero-param schema is fully described. The only shortfall is the absent behavioral detail around the mutation itself, which leaves a minor gap for an agent about to clear 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 for the description to disambiguate and the baseline for a parameterless tool applies. No parameter-related gap exists.

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 (Remove), the exact resource (Bridge default model), and the concrete consequence of the operation. It is trivially distinguishable from zcode_set_default_model and zcode_default_model, which set or read the model rather than clearing 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?

The description explains the condition under which clearing is useful: future tasks lacking an explicit zcode_task.model will fall back to the ZCode session default. It gives clear usage context but names no alternative (e.g., zcode_set_default_model) nor any when-not-to-use caveat.

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 load and does so richly: it discloses idempotency behavior (same operation_id and input creates no new attempt), that flagged decisions are never auto-approved, that the host must supply the follow-up instruction, and that status 'completed' means Bridge/normalization finished — not host acceptance. These are non-obvious behaviors beyond any structured field.

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?

Front-loaded with the core action and effect, then constraints. It is dense but nearly every clause adds operative meaning; the repeated 'calling host must...' phrasing is slightly redundant but not wasteful.

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 continuation/mutation tool with no annotations and a 4-param schema, it covers preconditions, idempotency, and post-call interpretation. Since an output schema exists, leaving return-field details to that schema is appropriate, and the description still clarifies the misleading 'completed' status.

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 for the two most semantically loaded parameters: it explains task_id reuse/increment semantics and operation_id idempotency. It is silent on what 'feedback' should contain and on additional_requirements, so coverage is partial.

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 (continue) and resource (a finished ZCode task) and enumerates the exact effect: reuses task ID/workspace, increments attempt, preserves evidence. This is clearly distinguishable from siblings like zcode_task (create), zcode_status, and zcode_result.

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?

Gives explicit preconditions — 'Allowed from completed, failed, or waiting_for_master' — and a conditional instruction for operation_id when retrying after a lost response. It does not name an alternative sibling (e.g., when to start a new task versus continue), so it stops just short of full when/when-not 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?

No annotations are provided, so the description carries the disclosure burden, but for a zero-parameter read operation the safety surface is small. It states what is returned but does not say what happens when no default has been set or whether any permission is needed, leaving modest 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?

A single front-loaded sentence that names the returned fields and the condition under which they apply. Every clause earns its place, with zero 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?

An output schema exists, so return-value explanation is unnecessary, and with no parameters the call surface is trivial. The only minor omission is the edge case of no default model being configured (null vs. error), which an agent might want to know.

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 no parameter semantics to document; the baseline for a no-param tool is 4. The description correctly frames the call as requiring no input.

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?

Specific verb+resource: 'Read the provider, model, and optional reasoning level' for the bridge default model. It even scopes the resource semantically ('used when zcode_task has no model override'), which distinguishes it from siblings like zcode_set_default_model, zcode_clear_default_model, and zcode_model_catalog.

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 'used when zcode_task has no model override' implies the context of use (inspecting the fallback model), but the description never states explicitly when an agent should call this versus sibling read tools such as zcode_model_catalog or zcode_status, nor any 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?

With no annotations, the description carries the burden and does well: it declares the read-only nature, explicitly states it does not start a ZCode session, and discloses that app-server model availability and real permission approval remain unverified until a task runs. It omits any note on permissions or runtime cost, but the core behavioral profile 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?

Three tight sentences, front-loaded with the check scope, followed by the scope exclusion and the verification caveat. Each sentence adds distinct information with no waste.

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?

An output schema exists, so return values need not be explained. For a no-param read-only diagnostic, the description covers what is checked, what is deliberately not done, and the limits of the results. Only the tie-break against similar diagnostic siblings like zcode_status 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?

Zero parameters, so the baseline applies; there is nothing parameter-level for the description to add. The 100% schema coverage is trivially satisfied by an empty object.

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

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

States a specific verb (run read-only checks) plus a concrete resource scope: Bridge prerequisites, ZCode runtime/provider config, execution mode, task storage, and Desktop task-index availability. It explicitly negates the adjacent session-starting behavior, distinguishing it from siblings like zcode_task.

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 pre-flight/diagnostic usage by enumerating prerequisite checks and excluding session start, but never names an alternative (e.g., when to prefer zcode_status) or states the conditions under which this tool should be chosen. Usage is inferable 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?

With no annotations, the description carries the full burden and does well: it discloses that raw is the default view, that summary merges adjacent model-text chunks, that next_seq advances across all scanned events, that hidden reasoning is excluded, and that interaction_requested events include bounded detail. It does not state read-only nature, error behavior, or what limit does under the hood.

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, but the middle is dense and mixes tool semantics with agent workflow instructions ('report the project path... report the ZCode session...'). It is information-rich but longer than needed and not tightly scoped to describing the tool 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?

An output schema exists, so return-value explanation is not required, and the description focuses on how to page and poll. Given the 5-param, no-annotation surface, it gives the agent enough to call and drive the tool correctly, aside from the undocumented limit parameter.

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 largely does: view (summary merges chunks; raw default), after_seq (last next_seq), and wait_ms (up to 25000) are all explained. limit is never mentioned, and task_id is left to the pattern in 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 first sentence gives a specific verb+resource: 'Read persisted progress events for a task.' That is unambiguous. However, it does not distinguish itself from close siblings like zcode_progress_probe, zcode_status, or zcode_result, leaving the agent to infer which read path to use.

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?

Strong operational guidance: set after_seq to the last next_seq, keep polling until turn_started or startup failure, wait_ms up to 25000. This tells the agent how to drive the polling loop. It does not, however, name an alternative sibling or state when NOT to use this tool in favor of zcode_progress_probe/zcode_status.

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 key policy behavior (what authorizes an allow, what must not be treated as authorization, and that this does not approve the task result). It stops short of describing the effect of replying (does the task resume, is the decision final/irreversible) or any auth requirements.

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?

Front-loaded with the core action and the trail back to zcode_events, then layered policy constraints in short declarative sentences. No filler and no repetition of the title or 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?

No output schema, so the description needn't explain returns, but for a 5-parameter tool with 0% schema coverage it leaves request_id/task_id sourcing and the reason/answers fields entirely unexplained. The decision-policy side is well covered; the mechanical side is not.

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 implicitly maps the decision enum to request types (allow/deny for permission requests, answer for input requests), which is genuinely useful, but it never addresses task_id, request_id, reason, or how the nested answers object is keyed.

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 (reply) and resource (a pending ZCode permission or user-input request) and ties the request back to the sibling tool that surfaces it, zcode_events. It also draws a boundary against another sibling by noting it 'does not approve the task result.' An agent can distinguish this from zcode_result or zcode_continue without opening a 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?

Gives explicit when/when-not rules: use allow only when the user explicitly authorized the action, otherwise deny or ask; do not infer permission from task instructions, worktree use, or ZCode mode; for input requests, answer only from known facts or explicit user direction. These are directly actionable decision constraints.

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 well: it discloses the 24-hour cache lifetime, refresh triggers (provider settings change or cache expiry), the retry behavior (re-reads provider config), and a specific response-shape quirk (current_model=null on cache responses). These are non-obvious operational details that meaningfully help correct invocation. It stops short of stating rate limits or full error semantics.

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 the core action and then layers in cache/refresh behavior and a response hint. Three sentences, each carrying distinct operational information 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?

Given a single-parameter read tool with an output schema, the description covers cache semantics, refresh triggers, retry behavior, and a response-shape edge case (current_model=null). This is substantial for a tool of this complexity; only explicit when-to-use guidance 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 description coverage is 0% for the single `workspace` parameter, but the description implies the catalog is workspace-scoped ("for this workspace"). The description provides contextual meaning for the parameter even though it does not document its format or constraints; baseline 3 is appropriate given the minimal parameter surface.

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 ("Read") and resource ("models and reasoning levels") for the workspace, which clearly distinguishes it from state-mutating siblings like zcode_set_default_model or zcode_clear_default_model. It could better differentiate from zcode_default_model, which likely returns the current default, but the catalog scope is reasonably 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?

No explicit when-to-use or when-not-to-use guidance is provided, nor are any sibling tools named as alternatives. The agent must infer that this is called to discover available models before, e.g., selecting one via zcode_set_default_model.

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 substantial work: it discloses the TASK_NOT_FINISHED sentinel, explains that 'completed' reflects invocation/normalization rather than host acceptance, and flags files_changed/tests/decisions as unverified claims. It does not address permissions, idempotency, or any other error modes.

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, but the core warning that 'completed' is not a host PASS is restated three separate ways across consecutive sentences. That redundancy inflates length without adding new information, and the grammar in one clause is garbled.

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?

An output schema exists, so return shape need not be described, and the description instead covers the semantic traps an agent must know about terminal states and claim verification. It leaves the discovery path for task_id and any access prerequisites unstated.

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% for the single task_id parameter, and the description adds no syntax, format, or sourcing guidance for it. The parameter name is nearly self-explanatory, which keeps this above a 2, but nothing compensates for the documentation 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 a specific verb and resource ('Read the persisted TaskResult for a finished task') and states the pre-condition that yields TASK_NOT_FINISHED, which implicitly separates it from status-polling siblings like zcode_status. It stops short of naming any sibling explicitly, so an agent must infer the routing.

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 establishes that this tool applies to a 'finished task' and warns about interpreting 'completed', but never says when to prefer it over zcode_status or zcode_events, nor how to obtain the required task_id. Usage is implied rather than directed.

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 does disclose real behavior: the selection is persisted, validated by the app-server only when a task starts, reasoning_level attaches to the configured default, and per-task overrides win. It omits any note on permissions, reversibility, or failure behavior, keeping it below 5.

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 tight sentences, front-loaded with the core action, and each sentence adds distinct information (scope, ID source/validation, reasoning_level and override). No filler or repetition 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?

An output schema exists so return values needn't be described, and the description covers persistence, validation timing, and override precedence for a mutation tool lacking annotations. The main remaining gap is the absence of valid reasoning_level values.

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 points provider_id/model_id at zcode_model_catalog or configured rules and explains that reasoning_level applies to the configured default, but it gives no accepted values or format hints for reasoning_level, leaving a gap for one of three parameters.

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 ('Persist a default provider/model selection') and scopes it to 'future tasks that omit zcode_task.model'. It is readily distinguishable from siblings zcode_default_model (read) and zcode_clear_default_model (clear), and it names zcode_model_catalog as the ID source.

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?

Explains when the setting takes effect (tasks that omit zcode_task.model) and that a per-task selection can still override it, which implicitly frames when this tool is and isn't needed. It never explicitly contrasts itself with the sibling read/clear tools, so it stays at 4 rather than 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, the description carries the full burden and does substantial work: it warns that 'completed' means invocation and report normalization finished, not host acceptance, and that the caller must independently review the diff and checks. It omits error/not-found behavior and whether status records expire or are overwritten, but the key interpretive trap 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 warning is front-loaded, but the PASS/FAIL point is restated twice ('never contains a PASS/FAIL code-review judgment' and 'NOT that the calling host accepted the work'), and the sentence beginning 'the calling host must...' is lowercase and reads as a fragment. Some redundancy could be trimmed.

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?

An output schema exists, so return values need not be documented, and the description covers the one thing an agent could get wrong: misreading 'completed' as approval. The remaining gap is how to obtain a valid task_id and what happens on an unknown id.

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?

One parameter with 0% schema description coverage, so the description must compensate and does not — task_id's format, source, or lifetime are never mentioned. The name is fairly self-evident, which keeps this at a minimum-viable 3 rather than lower.

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 ('Read the execution status record for one task') and immediately scopes it away from a review verdict. It does not name which sibling to use instead (zcode_result, zcode_task), so the differentiation from the other zcode_* tools is left implicit.

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 establishes what the status does and does not mean, which implies the usage context (polling a task's execution state), but it never states when to call this versus zcode_result or zcode_task, nor any prerequisite such as having a task_id from a prior invocation.

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 so well: it discloses the Bridge never creates/selects/removes worktrees, that the task runs asynchronously in a detached worker, that model override is session-scoped and not a project default change, and — critically — that status 'completed' means the invocation and report normalization finished, NOT that the host accepted the work. That last point is non-obvious semantics an agent could easily misread without the text.

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 and the worktree/workspace decision are front-loaded, and the review caveat is a useful closing sentence. It is somewhat verbose for its content — the worktree policy is restated ('The Bridge never creates, selects, or removes a worktree' appears twice in spirit) and there are minor typos ('the the calling host') mid-sentence that slightly hurt scanning.

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?

An output schema exists, so return values need not be described, and the description correctly spends its words on non-derivable behavior (async execution, status semantics, worktree ownership). However, for a 12-parameter, 8-required tool with zero schema property descriptions, leaving most task-package fields (objective, requirements, allowed/forbidden paths, acceptance_criteria, test_commands, timeout_ms) unexplained is a real gap in how to construct a valid call.

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 12 parameters, and the description only explains three of them (workspace, worktree_path, model). task_id, objective, requirements, allowed_paths, forbidden_paths, acceptance_criteria, test_commands, context, and timeout_ms get no semantic guidance in either place, so the description does not 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?

States a specific verb and resource — 'Create a bounded coding task for the local ZCode subordinate agent' — and immediately pins down the two key inputs (workspace, worktree_path). An agent can distinguish this from sibling lifecycle tools (zcode_status, zcode_result, zcode_cancel) without opening any 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?

Gives explicit conditions for the tricky case: the calling host decides whether to create a worktree, and only then passes an existing absolute directory as worktree_path; otherwise ZCode runs directly in workspace. It does not route the agent to sibling tools (e.g., polling via zcode_status/zcode_result after submission), so it stops short of explicit alternative selection.

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