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 adds useful transparency by stating that checkpoints capture tracked and untracked files "without touching the user's index" and that restoration happens via codex_restore. It does not detail edge cases like empty git repos or corrupted checkpoints, but for a listing tool this is adequate.

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 three sentences with no wasted words. It front-loads the core action, then adds important behavioral details and the prerequisite. Every sentence contributes necessary 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 simple one-parameter listing tool, the description is complete enough: it states what is listed, what checkpoints capture, that the operation does not touch the index, how to restore, and the git requirement. The absence of an output schema is acceptable because the listing semantics are clear from the description and tool name.

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 required parameter taskId is already documented in the schema as "Task whose checkpoints should be listed." The description adds contextual framing around "a task's turns" but no additional parameter-level semantics, so baseline 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 opens with a specific verb and resource: "List the working-tree snapshots taken around a task's turns." It clearly distinguishes itself from the sibling codex_restore by noting that checkpoints "can be restored with codex_restore," making the tool's listing-only role unambiguous.

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

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

The description provides clear context for when to use the tool: to list checkpoints for a task, and it points to codex_restore as the restoration alternative. It also gives a prerequisite (must be inside a git repository). It stops short of explicitly stating when not to use it versus alternatives, so it is not a perfect 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?

No annotations are present, so the description carries the full burden. It does disclose that this is a mutating follow-up that preserves prior thread context, but it doesn't disclose the asynchronous execution model, that a pollable taskId is returned, or how invalid/expired threads are handled. Useful but incomplete behavioral coverage.

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 waste: purpose and identifying trait are front-loaded, and the usage guidance follows immediately. Every sentence 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?

Complete enough to invoke correctly: required params, purpose, and the continue-vs-delegate choice are clear, and the waitSeconds schema hint covers the pollable-taskId return flow. However, with no output schema and no annotations, the description could do more to state how results are obtained (e.g., polling via codex_task_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 100%, so the schema already documents all five parameters (taskId, instruction, model, waitSeconds, reasoningEffort) with meaning. The description only reinforces that instruction is a follow-up and taskId refers to an existing thread — baseline 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?

States a specific action ('Send a follow-up instruction into an existing Codex thread') and the defining trait (keeping all prior context). It differentiates from the sibling codex_delegate by explicitly rejecting re-delegating from scratch, so an agent can tell them apart without opening the 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 an explicit when-to-use ('Use it to iterate on review feedback') and names the alternative behavior to avoid ('instead of re-delegating from scratch'), which maps to codex_delegate. The selection condition is concrete and actionable.

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

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

With no annotations provided, the description carries the full burden, and it delivers: it discloses that the tool checks quota before running, starts a fresh thread, returns changed files, and returns status 'quota_exhausted' with a handoff on failure. These are behavioral traits an agent cannot infer from the schema alone. It stops short of describing error behavior beyond quota or cost/long-running implications, but the disclosed traits are substantive.

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 sentences with zero fluff: the core purpose is front-loaded first, followed by execution behavior, then the key edge case. Every sentence earns its place — the quota-exhausted sentence describes a real decision-relevant scenario for the agent rather than filler. Appropriately sized for an 8-parameter 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 tool with no annotations and no output schema, the description explains the essential return behavior (result plus changed files) and the most likely failure mode (quota exhaustion with handoff). The pollable taskId return is only hinted at through the waitSeconds parameter description, and the full return shape beyond 'result plus files' is underspecified. Given the moderate complexity — spawning a subagent that edits files — this is slightly better than 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 100%, so the schema already documents all 8 parameters, establishing the baseline of 3. The description adds no parameter-level meaning beyond what the schema provides — it mentions output (files changed) and quota, but neither maps to a specific parameter. This is adequate 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 verb-resource pair ('Hand a self-contained coding task to Codex as a subagent') and describes a concrete outcome: runs the task and returns the result plus changed files. 'Starts a fresh Codex thread' distinguishes this from codex_continue, and the quota-first behavior distinguishes it from codex_get_limits. An agent can tell what this tool does and roughly how it differs from nearby siblings.

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

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

The qualifier 'self-contained coding task' implies when this tool is appropriate, and the quota_exhausted handoff describes a fallback action. However, the description never explicitly names alternatives or exclusion conditions (e.g., 'use codex_continue for ongoing conversations, codex_review for reviewing changes'), which is a real gap given nine closely related siblings. Usage context is present but only implied, not stated.

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. It discloses normalization behavior with concrete examples (300 min -> '5h', 10080 min -> 'weekly'), lists the returned fields, and mentions a delegation verdict. While it doesn't detail error behavior or auth requirements, it is transparent enough for a read-only limits check.

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 dense sentences with no filler. The first sentence front-loads the operation and return details; the second gives actionable guidance. 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 parameterless read tool with no output schema, the description is complete: it explains normalization, names the returned fields, signals read-only intent, and provides usage context. An agent has enough information to invoke and interpret the result correctly.

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

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

The tool has zero parameters and schema coverage is 100%, so there is no parameter information the description needs to add. The baseline for 0-parameter tools is 4, and the description appropriately focuses on output and usage rather than 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 uses a specific verb ('Read') and resource ('Codex usage limits'), and details what the tool returns: normalized windows, percentages, reset times, and a delegation verdict. It also distinguishes itself from siblings like codex_delegate by framing this as a pre-flight check.

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 explicitly states when to use the tool: 'Check this before delegating anything large.' This gives clear usage context relative to the delegation workflow, though it does not explicitly name alternatives or provide when-not-to-use cases.

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. It adds useful context by saying it reads live from the Codex model catalogue and is never hardcoded, but it does not mention the 60-second cache behavior, and 'read live' slightly overstates freshness for a tool whose refresh parameter implies cached results by default.

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 short sentences, each earning its place: the main action, the data-source caveat, and the usage routing. It is front-loaded with the core purpose and contains no fluff.

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

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

For a read-only list utility with one optional parameter already fully documented in the schema, the description covers purpose, account scope, output content (models plus reasoning-effort levels), and when to use it. The output expectation is clear even without an output 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%; the refresh parameter is already documented as bypassing the 60s catalogue cache and re-reading from Codex. The description adds no parameter-level meaning, so the baseline 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 states a specific verb ('List'), a clear resource ('Codex models available to this account'), and a key included detail ('reasoning-effort levels each one supports'). This clearly distinguishes it from sibling tools like codex_get_limits or codex_delegate without needing to inspect 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 explicitly tells the agent when to call it: before codex_delegate, when matching model strength to task difficulty. This gives concrete, decision-relevant routing to a sibling tool.

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 adds important non-obvious context: the thread survives interruption and can be resumed via codex_continue. It does not cover edge cases like interrupting when no turn is running, but the core behavior is 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 short sentences with no filler. The primary action is front-loaded, and the key consequence (thread survives, resumable) is delivered in the second sentence efficiently.

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

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

For a single-parameter tool with no output schema, the description covers the essential facts: what is interrupted and what happens afterward. It does not explain behavior when there is no in-flight turn, but given the tool's simplicity and the sibling context, it is sufficiently 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 100%, and the parameter taskId is already clearly described as 'Task whose in-flight turn should be stopped.' The tool description adds no new parameter detail, which is acceptable since the schema fully documents the only parameter.

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 ('Stop') and resource ('the turn Codex is currently running for a task'), which clearly identifies the tool's action. It also distinguishes itself from related siblings like codex_continue by noting the thread survives, making the purpose unambiguous.

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 implicitly provides usage context by stating that codex_continue can pick the thread back up, which signals this tool is for pausing rather than terminating a task. It does not explicitly list exclusions or compare with siblings like codex_task_status, but the context is clear enough for most agents.

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 states that files on disk are overwritten (destructive), requires user confirmation, and reveals that the pre-restore state is captured as a new checkpoint, making the operation undoable. This is thorough and directly useful for safe invocation.

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 sentences with zero waste: purpose/trigger first, then the destructive warning and consent requirement, then the undo guarantee. Every sentence earns its place and the most critical 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?

For a destructive mutation tool with no annotations and no output schema, the description covers the essential context: what it does, when to use it, side effects, user-consent requirements, and undoability. Schema handles parameter details. Nothing critical is missing for 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 100%, and the schema already explains taskId, checkpointId, and removeUntracked. The description reinforces the checkpoint concept but adds no parameter-specific syntax or format detail beyond the schema. Baseline 3 is appropriate when the schema does the heavy lifting.

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 ('roll the working tree back to a checkpoint') and a clear trigger ('use it when Codex made things worse'). This distinguishes it from siblings like codex_checkpoints, which lists checkpoints, and codex_review, which reviews work. The verb and resource are unambiguous.

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 when-to-use signal ('when Codex made things worse') and a pre-call requirement: confirm with the user unless they already asked for the rollback. It doesn't explicitly name alternatives or state when not to use it, but the context is clear enough for an agent to route correctly.

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 disclosing side effects, and it does so clearly: 'Codex reviews read-only and changes nothing.' It also discloses the return behavior—a review task that can be polled or extended—which is important since there is no output schema.

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 three tight sentences with no filler. The core action is front-loaded, the primary use cases follow immediately, and the safety guarantee and return contract are packed into short, scannable statements.

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

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

Given no annotations and no output schema, the description covers the essential operational context: read-only behavior, return format as a pollable task, and how to chain with codex_continue. It could slightly expand on what 'report findings' means or how results are retrieved, but the schema and sibling names make the overall workflow reasonably 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 100%, and all nine parameters have meaningful descriptions in the schema itself. The tool description adds context around parameters like taskId and model ('on a Codex task's output with a different model'), but the schema already does the heavy lifting for individual parameter meaning.

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

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

The description opens with a specific verb and resource: 'Ask Codex to review changes and report findings.' It clearly positions the tool as a review action, distinct from the sibling tools that manage checkpoints, worktrees, or delegate tasks, and it explicitly notes the returned artifact is a pollable review 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?

The description gives concrete when-to-use guidance: use on your own work before shipping, or on a Codex task's output with a different model for a cross-model second opinion. It also tells the agent how to continue after the call by polling or extending with codex_continue, though it does not explicitly say when not to use this tool or name alternative review workflows.

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 burden of behavioral disclosure. It clearly states this is a read operation, lists the fields the caller will see, and clarifies the list-all behavior when taskId is omitted. For a read-only status tool, this is sufficient even without detailed side-effect or rate-limit notes.

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 front-loads the operation and the full set of returned state fields; the second provides the polling trigger and the list-all variant. Every sentence 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 tool with one optional parameter, no output schema, and no annotations, the description provides all essential context: what is inspected, what fields will be returned, when to poll, and how to list all tasks. Nothing an agent needs to correctly call this tool 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 100%, and the schema already explains that taskId is the task to inspect and that omitting it lists all known tasks. The description repeats this omission behavior without adding new syntactic or format details, 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 the specific verb 'Read' and clearly identifies the resource: the current state of a delegated Codex task. It enumerates exactly what state is returned (status, model, reasoning effort, changed files, commands run, plan, diff, worktree, checkpoints, timestamps), which distinguishes it from sibling tools like codex_delegate or codex_interrupt.

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 trigger condition: 'Poll this when codex_delegate returned status running.' It also explains the omit-taskId behavior for listing all tasks. It does not explicitly enumerate alternatives or state when not to use this tool, but the usage context is clear and actionable.

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 disclosure burden and does well: it explains that 'commit' records work and reports a merge command without merging into the user branch, and that 'remove' tears down the worktree and refuses to discard uncommitted work unless forced. It leaves out post-commit worktree state and error conditions, but the critical side effects and safety behavior are 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?

Three sentences with no filler: the first states the overall purpose, the second explains commit semantics, the third explains remove semantics including the forced flag. Each sentence earns its place and the key scoping constraint 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 provides the essential operational context for a two-action tool: target resource, per-action behavior, and safety defaults. It does not describe the full return value shape or error handling, and there is no output schema to supplement, but the available information is sufficient for selection and basic 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 coverage is 100%, so the baseline is 3. The description adds meaning beyond the schema by explaining what 'commit' produces (a merge command) and that 'force' overrides a refusal to discard uncommitted work. This helps the agent reason about when to use the optional force and message params, though the message param is only documented 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 description names two specific actions (commit, remove) applied to a specific resource (the task's isolated git worktree), and scopes it to tasks delegated with isolation "worktree". This clearly distinguishes it from sibling tools like codex_restore or codex_checkpoints, which handle different task lifecycle concerns.

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 states the tool applies only to tasks delegated with isolation "worktree", giving a concrete condition for use. It does not explicitly name alternatives or list when-not-to-use scenarios, but the isolation qualifier provides enough guidance for an agent to select it correctly.

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