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

With no annotations provided, the description carries the burden of disclosing side effects, and it does so by explicitly stating 'no model turn is started.' This is the key behavioral trait. It does not mention return format or error behavior, but the safety-relevant part is covered.

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

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

A single sentence front-loads the core read action and immediately follows with the important side-effect guarantee. Every phrase earns its place with no redundancy.

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

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

For a zero-parameter read tool, this is nearly complete. However, the description does not explain what the returned thread data contains or what 'bound' means, and there is no output schema to fill that gap. Still, the core purpose and side-effect profile are clear.

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 zero parameters and an empty input schema, so the baseline is 4. There is no parameter detail needed, and the description correctly mentions nothing about 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?

The description states a specific verb ('Read'), a distinct resource ('current bound Codex thread'), and the access method ('official app-server proxy'). It also clarifies that no model turn is started, distinguishing it from tools that trigger work.

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 this is a passive read for inspecting the current Codex thread, but it gives no explicit 'use this when' or 'instead of X' guidance. It does not differentiate itself from sibling status tools like dsh_status or workflow_status, leaving some routing ambiguity.

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

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

No annotations are provided, so the description carries the behavioral burden. It explicitly discloses that the read is bounded, that hasMore is retained, and that no session is cancelled, which are meaningful operational traits. It does not detail every possible side effect or response format, but the key behavioral guarantees for this kind of read tool are present.

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 primary action is front-loaded, and the negative guarantee about session cancellation earns its place. This is appropriately concise.

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 essential behavior but lacks usage routing, explicit parameter semantics, and return-format detail, and there is no output schema to fill that gap. For a two-parameter tool with a pagination flag, this is adequate but not fully complete.

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

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

Schema description coverage is 0%, so the description needed to compensate by explaining sessionId and maxMessages; it does not mention either parameter by name. Only the word 'bounded' hints at the role of maxMessages, while sessionId is left to be inferred from the schema and tool name.

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 ('Read') and a specific resource ('initial history snapshot'), and it adds useful scope by saying the snapshot is bounded and that hasMore is retained. It is clear about the core action, though it does not explicitly contrast with sibling tools such as dsh_sessions or dsh_prompt.

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

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

There is no guidance about when to use this tool versus alternatives like dsh_sessions or dsh_prompt. The word 'initial' implies a first snapshot, but no explicit when-to-use, when-not-to-use, or alternative routing is 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 behavioral burden, and it does disclose meaningful traits: durable request deduplication and no automatic retry for unknown delivery. It stops short of stating side effects, success/failure return behavior, or duplicate handling details, but the disclosed features go beyond a generic 'queue' statement.

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 front-load the action and scope, then add two essential behavioral qualifiers. No filler words; every phrase contributes, including 'EXISTING' and 'durable'.

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

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

The tool has no output schema, so the description should clarify what happens after queueing, such as return value, async status, or delivery semantics, but it only says unknown delivery is never retried. It provides enough to attempt a call with the required schema fields, but not enough to fully predict the result or next steps.

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 supply parameter meaning. 'EXISTING session' hints at sessionId, 'request deduplication' ties to requestId, and 'task' loosely maps to text, but the description never names or explicitly documents each parameter's exact role.

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 ('Queue') and resource ('an explicitly authorized task in an EXISTING session'), making the tool's core action unmistakable. It also distinguishes dsh_prompt from sibling status/management tools like dsh_status, dsh_sessions, and dsh_wait by focusing on enqueueing into a session rather than inspecting or waiting on 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?

It implies when to use the tool: when there is an existing session and an explicitly authorized task to queue. However, it never names alternatives or states when not to use it, leaving routing decisions to inference.

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

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

With no annotations, the description carries the burden of behavioral disclosure. 'List' implies a read-only operation, and the second sentence clarifies what information the agent should look for. However, it does not describe output format, possible side effects, or any access requirements. This is adequate for a simple listing tool 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 very concise: two short sentences with no wasted words. It front-loads the primary action ('List DSH sessions') and then adds a practical usage note. Every word contributes value.

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

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

Given the tool's simplicity—no parameters, no output schema, no nested objects—the description is mostly complete. It names the resource and explains why an agent would call it. The main gap is lack of differentiation from closely named siblings, but the core invocation context is adequately covered.

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 zero parameters, and the input schema is empty. Per the baseline, 0 params warrants a 4. The description adds no parameter-specific meaning, but none is needed.

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 clear verb and resource: 'List DSH sessions.' It also states the intended use ('Inspect project and running state before submitting work'), which clarifies why the tool exists. However, it does not explicitly differentiate from sibling tools like dsh_status or dsh_history, 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 description gives a clear usage context: 'before submitting work.' This tells an agent when to use the tool. It does not mention when not to use it or explicitly name alternative tools, but the stated timing provides useful, non-ambiguous 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?

There are no annotations, so the description carries full responsibility for behavioral disclosure. It notably discloses that the operation is a read-only verification and does not submit work, which is the most important side-effect information. It does not describe output format or failure modes, but for a zero-parameter status check the core behavior is adequately conveyed.

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 short sentences with no filler. The primary purpose is front-loaded, and the second sentence adds a valuable behavioral clarification. 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-only status tool with no output schema, the description is mostly complete: it states what is verified and what is not done. It is slightly incomplete in not distinguishing from sibling status tools, but the low complexity makes this a minor gap.

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

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

The tool has zero parameters and the schema already reflects that with an empty properties object. Because there are no parameters to document, the baseline of 4 applies and the description does not need to add parameter-level semantics.

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

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

The description uses a specific verb, 'Verify', and names the target resource: the configured DSH Web process and authenticated session/list. It also adds a distinguishing negative scope, 'Does not submit work', which separates it from submission-oriented siblings. However, it does not clearly differentiate itself from other status/session tools like codex_status or dsh_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 that the tool is for verification of DSH Web process and session state, and it explicitly states this tool does not submit work. That provides a clear when-to-use and when-not-to-use signal. It stops short of naming alternative tools or giving explicit routing conditions relative to status/session siblings.

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

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

With no annotations, the description carries the behavioral burden and does meaningful work: it discloses a bounded wait (at most 30 seconds), frames the operation as observation, and warns that idle is not proof of success. It does not detail timeout behavior or return semantics, but the key behavioral risk is surfaced.

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, front-loaded with the primary action and time bound. Every clause earns its place: the wait behavior, the 30-second cap, and the necessary success-verification caveat.

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 is enough to select the tool and understand the basic invocation, but without annotations or an output schema it leaves ambiguity around return values, timeout behavior, and how sessionId should be obtained or used. The review-history/files guidance helps, but a complete definition would clarify what happens when the 30 seconds elapse.

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 partially compensates by explaining the functional role of seconds as the idle-observation duration. However, it does not explain sessionId semantics or how it relates to the queue/job, and it omits optional/default behavior for seconds, leaving a clear 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 states a clear, specific action: observe a queue/job for idle with a 30-second cap. It distinguishes itself from status/history siblings by emphasizing waiting rather than reporting, and it adds the important caveat that idle does not imply success. It does not explicitly name sibling tools, so it stops short of full differentiation.

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

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

The description gives practical context: wait for idle, then verify by reviewing history and files rather than trusting idle. It implies the alternative path to dsh_history/files, but it does not explicitly state when not to use this tool or name the sibling 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?

With no annotations, the description must disclose behavior on its own. It usefully states the tool will not dispatch work or enforce scope, and that it binds to existing entities. However, it does not say whether the binding mutates state, is idempotent, requires permissions, or returns any confirmation.

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

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

Two compact sentences with no filler. The main purpose is front-loaded, and the second sentence adds meaningful boundary information about what the tool does not do.

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

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

For a tool with 4 required parameters, no annotations, no output schema, and no parameter descriptions, the description is too sparse. It lacks details on prerequisites, expected parameter semantics, failure behavior, and when to choose this over sibling tools.

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

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

Schema description coverage is 0%, and the description only indirectly maps taskId, originCodexTaskId, and dshSessionId to the local task, Codex task, and DSH session. The required 'scope' parameter is entirely unexplained, leaving a significant gap for correct invocation.

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

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

The description states a specific verb and resource: 'Bind a local task to an existing Codex task and DSH session.' It also differentiates from siblings by noting what it does not do ('Does not dispatch work'), making the tool's role distinct from workflow_dispatch and similar dispatch-oriented 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?

The description implies when this tool is appropriate by clarifying it does not dispatch work or enforce scope, but it never explicitly states when to use it or names an alternative tool for those cases. The usage context is only inferable from the negative statements.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It clearly states that the tool records, requests review, never approves, and never wakes Codex. This gives an agent meaningful expectations about side effects and boundaries, though it does not mention permissions, idempotency, or error behavior.

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

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

The description is only two sentences and front-loads the most important qualifier 'UNVERIFIED' and the resource 'completion report.' Every phrase earns its place, and the behavioral exclusion is stated in a compact, scannable way.

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 four-parameter, no-output-schema tool, the description covers the core action and key behavioral constraints. However, because parameter semantics are not explained and there are no annotations, an agent may not know the exact roles of dshSessionId and requestId. The description is adequate but not fully self-sufficient.

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

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

Schema description coverage is 0%, and the description does not map any parameter names to their meanings. Terms like 'bound task' and 'completion report' indirectly hint at taskId and summary, but dshSessionId and requestId are left entirely unexplained. The description fails to compensate 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 states a specific verb ('Record'), a specific resource ('unverified completion report for a bound task'), and the key distinction 'never approves or wakes Codex.' This clearly separates it from sibling tools like workflow_review or review_pending. It avoids ambiguity about what 'complete' means in the tool name.

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

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

The description gives clear usage context: this is for recording an unverified completion and requesting review, not for approving or waking Codex. It does not explicitly name sibling alternatives or say 'use this instead of X,' but the 'never approves' statement provides a strong exclusion that guides an agent away from misuse.

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

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

With no annotations, the description carries the transparency burden. It explicitly indicates a read-only operation, caps results at 100, and warns that records are untrusted claims, which is valuable safety context. It does not cover pagination or failure behavior, but these are secondary for a simple read 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?

Two short sentences convey purpose, a limit, and a critical data-quality caveat with no filler. The key information is front-loaded.

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

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

For a zero-parameter tool with no output schema, the description gives enough context to invoke it correctly: what is read, how many records, and how to treat the data. The only minor omission is behavior when more than 100 records exist, but that does not prevent correct invocation.

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

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

The input schema has zero parameters, so there are no parameter semantics to document; the baseline is 4. The record limit and trust warning are behavioral notes rather than parameter 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 a specific verb ('Read') and a specific resource ('local pending-review inbox'), with a clear limit of up to 100 records. This distinguishes it from mutating sibling tools like review_complete and review_bind.

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 retrieving pending review records, but it does not name alternative tools or state when a different sibling should be chosen. No explicit exclusions or conditional guidance are provided.

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

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

There are no annotations, so the description carries the full burden of behavioral disclosure. It reveals critical traits: the tool is a durable ledger, it does not drive a browser itself, it must not auto-resend unknown submissions, and media availability must be observed rather than assumed. This is strong behavioral context. It does not explain each action's side effects, but the disclosed constraints are unusually valuable.

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

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

The description is compact and front-loaded with the core identity, then the workflow pipeline, then critical safety constraints. Every sentence contributes information, and there is no filler. The phrasing is dense and somewhat cryptic, but structurally it is efficient and well-ordered.

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 9 undocumented parameters, 8 actions, no output schema, and no annotations, this description is too sparse to fully support correct invocation. It gives excellent safety constraints but does not specify what each action requires, what parameters are valid for each action, or what response an agent should expect. The workflow hints are useful but incomplete 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 adds almost no meaning for the nine parameters. It references workflow steps like prepare, bind, claim, collect, and accept, but does not explain parameters such as url, text, taskId, tabId, browserId, evidence, or revision. The phrase 'claim BEFORE Send' is cryptic and 'Send' is not even an action in the enum. The description does not compensate for the schema's total lack of parameter 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 identifies web_task as a 'durable ledger for agent-operated ChatGPT browser tasks,' giving a specific resource and role. It also clearly states what the tool does NOT do: it does not control a browser or send prompts itself, which helps an agent distinguish it from action-taking tools. However, it does not explicitly name or differentiate against sibling tools, so the distinction is implicit rather than direct.

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 an explicit workflow order: 'prepare -> bind -> claim BEFORE Send -> collect visible result -> independently accept.' This tells an agent how the actions are meant to be sequenced. It also adds important conditions: 'Unknown submission must never be automatically resent' and 'Image/video availability must be observed, not assumed.' It lacks a direct statement of when to choose this tool over a sibling, but the protocol guidance is far above minimal.

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

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

With no annotations provided, the description carries the behavioral disclosure burden. It explicitly states 'Does not delete project files', directly addressing a likely safety concern, and implies a state change from active to archived. It does not mention reversibility or permissions, but the key non-destructive behavior 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 description is two short sentences with no filler. The main action and purpose are front-loaded, and the clarifying negative statement is separated cleanly.

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 tool with no output schema, this is nearly complete: an agent knows what to act on, why, and a critical non-effect. The main gap is that the description does not explicitly tie taskId to the terminal record, nor does it state whether archiving is reversible.

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, taskId, is not mentioned in the description. Schema description coverage is 0%, so the description should compensate by explaining where the ID comes from or what it identifies, but it only refers to 'an accepted terminal record' without linking that concept to taskId. The parameter name and regex carry nearly all the semantic weight.

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

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

The description states a specific verb and object: 'Archive an accepted terminal record', and gives the intended outcome: 'to release active inbox capacity'. The qualifier 'accepted' clarifies the target state, and no sibling tool covers archiving, so it is readily distinguishable.

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: this tool is for accepted terminal records and is appropriate when active inbox capacity needs to be freed. It does not explicitly name alternatives or exclusion cases, but for an archive operation the context is sufficient for an agent to select it.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. It mentions 'completion ticket' and 'original Codex reviewer' and a prerequisite, but does not disclose side effects, whether work is synchronous or asynchronous, what happens to the DSH session, or what the return value/outcome looks like.

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

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

The description is concise, consisting of two short sentences with no redundant filler. The main action is front-loaded, and the prerequisite is stated separately. Slight jargon ('bounded work', 'completion ticket') reduces clarity but not structural efficiency.

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

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

This is a complex tool with 7 parameters, no output schema, and no annotations, so the description must carry a heavy load. It provides only a high-level purpose and prerequisites, leaving parameter semantics, invocation outcomes, and behavioral consequences undocumented. Not adequate for safe and correct invocation.

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

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

Schema description coverage is 0%, and the description does not explain any of the seven parameters. Terms like 'bounded work' and 'completion ticket' are not explicitly mapped to maxRounds, acceptance, taskId, or any other property, so an agent has no meaningful semantic guidance for invoking the tool correctly.

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

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

The description states a specific action: 'Bind and dispatch bounded work to an existing DSH session,' which clearly identifies the resource (DSH session) and the operation (dispatch work with completion ticket and Codex reviewer). It partially distinguishes itself from sibling status and review tools by focusing on dispatching work, though it does not explicitly contrast with similar tools like dsh_prompt.

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 prerequisite ('Requires configured project allowlist and Codex connection') but no guidance on when to use this tool versus alternatives. It does not mention sibling tools, when not to use it, or conditions that would make another tool more appropriate.

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

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

With no annotations, the description carries full behavioral burden. It discloses a critical side-effect: retrying after an incorrect inspection can duplicate delivery. This is a meaningful and non-obvious behavioral warning, though it does not detail acknowledged semantics or other state changes.

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 tightly written sentences, with the core purpose in the first sentence and a critical warning in the second. There is no filler, and the most important safety information is front-loaded.

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

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

The description covers key preconditions and the main risk, but leaves the 'acknowledged' action semantics, expected 'notes' content, and return behavior unstated. Given four required parameters and no annotations or output schema, an agent would still need to infer some behavior.

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

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

Schema description coverage is 0%, so the description must compensate for parameter meaning. It partially clarifies the 'retry' action by warning about duplicate delivery, but gives no semantic guidance for 'acknowledged', 'taskId', 'round', or 'notes'. This is insufficient for an agent to confidently construct a valid call.

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 ('resolves'), a specific resource ('UNKNOWN/BLOCKED notification'), and a specific actor ('Original reviewer'). This clearly distinguishes it from siblings like workflow_review or workflow_dispatch without needing to open their 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 explicit usage context: only for UNKNOWN/BLOCKED notifications, only by the original reviewer, and only after inspecting Codex history. It does not explicitly name alternative tools, but the preconditions and restrictions are clear enough to guide selection.

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

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

With no annotations, the description carries the full behavioral disclosure burden. It does disclose the decision semantics ('acceptance or bounded rework') and an authorization restriction, but it does not describe side effects, finality, what happens after a 'changes' decision, or whether the recorded review creates notifications or state transitions.

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 only two sentences long, contains no filler, and front-loads the most decision-relevant information. Every clause adds value: what the reviewer does, the independent nature of the review, and the worker-role restriction.

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 four required parameters, no annotations, and no output schema, the description is too sparse to be fully actionable. It omits return behavior, round semantics, workflow effects after review, and does not distinguish the tool from the many review/workflow siblings in context.

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

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

Schema description coverage is 0%, so the description must compensate for missing parameter documentation. It adds meaning to the decision enum by mapping 'accepted' to acceptance and 'changes' to bounded rework, but it leaves taskId, round, and notes to be inferred solely from their names and schema constraints.

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

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

The description names a specific action ('records independent acceptance or bounded rework'), a specific actor ('Original Codex reviewer'), and an explicit restriction ('Worker role cannot approve'). It does not explicitly distinguish itself from siblings like review_complete or review_pending, but the role and decision scope make the core purpose 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?

The description provides a clear usage boundary by stating that the worker role cannot approve, implying this tool is for the original Codex reviewer. However, it does not explain when to choose this tool over related siblings such as review_complete, review_pending, or workflow_dispatch, nor does it mention prerequisites for review.

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 bears the full burden. It does disclose a read-only behavior ('Read tasks') and calls out that notification failures and delivery uncertainty are included in the result set, which adds useful behavioral context. However, it does not describe authentication, scoping edge cases, or what happens when the optional taskId is omitted.

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. It opens with the key action and resource, then adds distinguishing detail about notification failures and delivery uncertainty. Every word 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?

The tool has one optional parameter, no annotations, and no output schema, so the description must carry significant explanatory weight. It clarifies the tool's basic purpose, but it omits the meaning of taskId, any usage guidance, and any detail about the returned task structure beyond the included failure/uncertainty aspects. This leaves noticeable gaps for an agent deciding how to call it.

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 does not mention the taskId parameter at all. Since the sole parameter is optional and undocumented in both schema and prose, the agent cannot know its filtering or scoping effect from the description.

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

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

The description clearly states a specific verb ('Read') and resource ('tasks owned by the current Codex reviewer'), and highlights the distinctive inclusion of notification failures and delivery uncertainty. This makes the tool's purpose identifiable and separates it from sibling tools like workflow_resolve_notification or codex_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 implies it should be used to read the current reviewer's tasks, but it gives no explicit guidance on when to prefer this tool over alternatives, nor does it state exclusions or conditions like 'use workflow_resolve_notification for resolving failures.' An agent is left to infer usage context from the name and sibling list.

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