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

With no annotations, the description carries full burden. It does disclose that the operation 'Runs in the background' (async execution), which is genuine behavioral value beyond structured fields. However, it omits whether the original history is preserved or replaced, whether compaction is reversible, and any auth/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?

Two tight sentences with the core action and outcome front-loaded and zero filler. 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 single-param, no-output-schema tool, the description covers the action and async nature adequately. But it leaves the parameter undocumented and omits the data-modifying implications of compaction, so it is only minimally 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% and the single parameter (thread_id) is never mentioned in the description. The name implies it operates on 'a thread,' but the description adds no meaning about what thread_id should be, its format, or how it is obtained.

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 (summarize/compact) and resource (a Codex thread's history), plus the outcome (free up its context window). It distinguishes itself from siblings by being the only compaction tool, though it never names an alternative explicitly.

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 when to use it via 'a long Codex thread's history' and 'free up its context window,' which hints at context-exhaustion scenarios. But there is no explicit when/when-not guidance, no prerequisites, and no routing to or from siblings like codex_threads or codex_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?

No annotations are provided, so the description carries the full behavioral burden. It states that the turn is stopped, but does not disclose what happens to the thread afterward, whether the interruption is reversible, whether permissions are required, or what side effects occur.

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 or repetition. Every word contributes to stating the action and target.

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, no output schema, and 0% parameter description coverage, the description is too thin. It omits parameter semantics and behavioral details that an agent would need to invoke the tool confidently 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 should compensate for the undocumented thread_id parameter. It only mentions "a Codex thread," which weakly implies the parameter identifies a thread, but gives no format, requiredness, or other meaning beyond the bare 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 uses a specific verb ("Stop") and resource ("the running turn on a Codex thread"), making the core action immediately clear. It does not, however, differentiate this tool from siblings like codex_steer or codex_run, which could also affect a running turn.

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 such as codex_steer or codex_wait. The closest thing is the implied condition that a turn is running, but no prerequisites, exclusions, or alternative-routing advice are given.

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. It does disclose one behavioral fact — the listing is scoped to the current Codex login rather than global — but says nothing about whether the call is read-only, whether it hits a network/auth boundary, caching, or what shape the list takes. It leans on the obvious read-only nature of a 'list' without confirming it.

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 with no waste; the resource and scope come first. It is efficient, though arguably too terse to be fully self-sufficient, which keeps it just under the top mark.

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

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

For a simple read-only list tool with one optional param and no output schema, the description covers what is returned at a high level but omits the meaning of include_hidden and any note on output format. Adequate but with a clear, easily closed 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?

Schema description coverage is 0% and the single parameter (include_hidden) is never explained in the description. The agent cannot tell from either source whether hidden models should be included by default or why to enable it, so the description fails to 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 (List) and resource (Codex models) and adds scope detail — models available to 'this Codex login' with supported reasoning efforts. No sibling (codex_run, codex_status, codex_threads, etc.) overlaps with model enumeration, so the agent can immediately place 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?

There is no explicit when-to-use guidance, no mention that this is the discovery step preceding codex_run, and no stated alternatives or conditions. Usage is only loosely inferable from the name and resource, which matches the calibration's 'no when-to-use, no prerequisites' = 2.

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. It usefully discloses the two modes (approvals consume a decision; questions consume an answers map), which is real behavioral context, but it omits side effects, permission needs, or what happens after a decision is submitted.

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 purpose followed by the mode-specific input formats. Little waste, though the final sentence reads as an instruction rather than tool-contract 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?

No output schema and no annotations, so the description must stand alone. It covers the two request shapes and their inputs, but leaves return/blocking behavior largely to the wait_seconds schema and does not describe outcomes of the response.

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

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

Schema coverage is only 25%, so the description is expected to compensate. It clarifies the answers map semantics ({question id: "answer"}) and restates the decision enum values, but leaves request_id and the mode-dependent usage of decision vs answers partially implicit.

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+resource: answer a request Codex is blocked on, and ties it to the pending_requests list. It distinguishes the two request types (approvals vs questions), making the tool's role clear, though it doesn't explicitly name how it differs from siblings like codex_steer or codex_wait.

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 one usage instruction ('Ask the user first when the request is something they should decide') and implies usage when a request is pending, but never states when to prefer this over codex_wait or codex_status, and offers no alternatives or exclusions.

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 it does disclose two useful traits: the operation is read-only, and the output lands in the 'review' field. It does not cover whether a thread/run is spawned, how it interacts with codex_wait/status/interrupt siblings, or authentication needs. Partial disclosure for a no-annotation 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?

Three compact sentences with the core action and the return-field location front-loaded, then the steering hint. No filler. Could be slightly tighter but earns nearly every clause.

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 9-parameter tool with no output schema, explaining that results arrive in the 'review' field is valuable, and the schema documents target/wait_seconds. But the description omits how this relates to the thread-lifecycle siblings (wait/status/interrupt/respond), leaving the agent to infer the async workflow.

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 56%, so several parameters (model, effort, commit_sha, base_branch) rely on the schema alone. The description does add real meaning for 'focus' and especially 'adversarial' ('challenges the design, not just bugs'), which enriches beyond the schema text. This compensates for some but not all of 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: 'Run Codex's native code review (read-only) in a git repo.' The 'native code review' phrasing distinguishes it from the generic codex_run sibling. It stops short of explicitly contrasting with codex_run's capabilities, so the boundary is implied rather than stated.

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 conditional guidance for one mode ('Pass focus and/or adversarial: true for a steerable review'), which implies when the deeper mode is appropriate. However, it never says when to choose codex_review over codex_run, nor any prerequisites such as needing a thread or authenticated Codex. Usage is implied, not fully framed.

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 the blocking model (blocks up to wait_seconds, returns early on completion or input request), that the turn keeps running after return, and exactly what is returned (status, latest message, files changed, commands run). It does not surface sandbox/approval safety implications or that sandbox is fixed per thread, but those live in the schema descriptions.

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?

Dense but front-loaded: the core action comes first, followed by mode selection, return contract, status routing, and the parallel recipe. Every sentence is actionable and none is 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?

For a complex 11-parameter orchestration tool with no output schema, the description fully covers the call/return/continue loop an agent needs, including the return payload and the follow-up tool for each status. Nothing required to drive the multi-step workflow correctly 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%, so all 11 parameters are already documented. The description adds a little meaning to thread_id (keeps context) and wait_seconds (returns early, turn keeps running), but largely restates what the schema provides; 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?

States a specific verb and resource ("Give Codex a task") and immediately distinguishes the two modes (new thread vs. continuing via thread_id). It routes to named siblings codex_wait and codex_respond, so an agent can tell it apart from the other codex_* tools 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?

Explicit when-to-use routing: status "inProgress" → codex_wait, "waitingForInput" → codex_respond, plus a concrete parallelization recipe (call with wait_seconds: 0, then codex_wait with all thread_ids). It also names when to use thread_id (continuing an existing thread) and adds a self-review 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 burden. It usefully discloses that the call is non-blocking and returns current activity plus pending requests, which is real behavioral context. But it says nothing about whether it mutates state, whether calling it has side effects, or any auth/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?

One compact sentence front-loads the key trait ('Non-blocking snapshot') and then enumerates the payload. No filler or redundant restatement 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?

For a simple, zero-required-parameter read tool with full schema coverage and no output schema, the description covers what the agent needs: it is non-blocking and what information it surfaces. Sibling differentiation is implicit rather than explicit, which is the main 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?

Schema coverage is 100% and the single optional parameter is fully documented in the schema ('Defaults to every thread used in this session'). The description adds no parameter-level detail beyond that, 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?

States a specific verb+resource: a non-blocking snapshot of Codex threads, returning status, activity, and pending requests. The scope ('in this session') and the read-only framing distinguish it from siblings like codex_run, codex_wait, and 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 'non-blocking' framing implies this is the polling/inspection tool to use instead of blocking calls like codex_wait, and 'peek' signals an observation-only call. However, it never explicitly says when to use this versus codex_wait, codex_threads, or codex_status alternatives, so routing is left 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 full behavioral burden, yet it only discloses that the turn keeps running. It does not say what happens if no turn is active, whether instructions are queued or injected immediately, whether steering can fail, or what the call returns — all material for a mutation-style tool. The useful blocking behavior is documented only in the schema's wait_seconds field, not the description.

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 tight sentence with no filler and the key constraint ('without stopping it') placed up front. It is arguably under-specified rather than over-long, but on conciseness and structure alone it is efficient.

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 3-parameter, no-annotation, no-output-schema tool, one sentence leaves significant gaps: failure modes, whether an active turn is required, and the return/progress behavior are all unaddressed. The description does not do enough to let an agent invoke this correctly in edge cases.

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 only 33%: only wait_seconds is documented, while prompt and thread_id (both required) have no description anywhere. The description adds no parameter meaning at all — it never mentions what the prompt should contain, whether it is additive to the original task, or how thread_id is obtained.

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 (add instructions / steer) and a specific target (the turn Codex is currently working on), which is clear enough to separate it from codex_run or codex_status. It stops short of naming the sibling it is most easily confused with (codex_respond, which presumably supplies the answer Codex is waiting for), so it is clear but not fully differentiated.

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?

'Without stopping it' implies the precondition that a turn is already running and that this is the non-disruptive alternative to codex_interrupt, but the agent must infer that. No explicit when-to-use, when-not-to-use, or named alternative (e.g., use codex_respond when Codex is blocked on a question) is given.

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 full behavioral burden. It does disclose source coverage (app/CLI threads) and sort order (newest first), which is useful, but says nothing about read-only nature, pagination beyond the limit param, or what fields each thread entry contains.

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 tight sentences, zero filler, with the core purpose and ordering front-loaded before the follow-up hint.

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?

There is no output schema, so the description should ideally sketch the return shape; it only implies a thread_id exists. For a simple two-optional-param list tool with no annotations, this is adequate but leaves the agent guessing about returned fields and pagination 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 coverage is 50%: 'cwd' is documented in the schema but 'limit' only carries default/min/max with no explanation. The description adds no parameter meaning at all, so it fails to compensate for the undocumented half.

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 ('List recent Codex threads'), adds scope ('including ones from the Codex app/CLI') and ordering ('newest first'). An agent can distinguish it from the codex_run/codex_status siblings 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?

Explicitly routes the agent to the next step: 'Continue one with codex_run + thread_id.' That is actionable context, but there is no statement of when NOT to use this tool or how it relates to other listing/status siblings such as codex_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 disclosure burden. It does well on the core trait: it blocks, returns early when a turn finishes or Codex needs an answer, and the turn keeps running afterward (reinforced in wait_seconds). However, it says nothing about permissions, concurrency, or what a 'blocked on a request' state means operationally for the caller.

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 tight sentences, front-loaded with the action and return, then the mode behavior. No filler; every clause carries 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 4-parameter blocking tool with no annotations and no output schema, the description covers return timing and the mode switch reasonably well. It omits authentication needs, whether the call is safe/idempotent, and what the returned 'reports' contain, leaving gaps for a tool whose whole purpose is a side-effect-free wait.

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 50%: mode and thread_id have no schema descriptions, while thread_ids and wait_seconds do. The description compensates for mode by defining 'all' vs 'any' semantics, but adds nothing for thread_id or the relationship between thread_id and thread_ids, leaving half the surface unexplained.

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 (wait) and resource (turns on Codex threads) plus the return payload (reports), so an agent knows this blocks until turns resolve. It does not explicitly contrast itself with siblings like codex_status, but the blocking-wait semantics are distinctive enough to infer.

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 mode-based return conditions (all vs any), which implicitly tells the agent when the call completes, but never says when to prefer this over codex_status or how it relates to codex_run. Usage is implied rather than stated with alternatives.

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