Skip to main content
Glama

Codex code review

codex_review

Run a read-only review of a git repository's changes, a branch against its base, or a specific commit. Add focus or adversarial mode to target concurrency, edge cases, and design assumptions.

Instructions

Run Codex's native code review (read-only) in a git repo. The review text comes back in the "review" field. Pass focus and/or adversarial: true for a steerable review that challenges assumptions and edge cases.

Tool call template

Replace each placeholder with a value matching the input schema. Only required parameters are included; add optional parameters as needed.

{
  "id": 1,
  "jsonrpc": "2.0",
  "method": "tools/call",
  "params": {
    "arguments": {
      "cwd": "<cwd>"
    },
    "name": "codex_review"
  }
}

Input Schema

NameRequiredDescriptionDefault
cwdYesAbsolute path inside the git repository.
focusNoWhat to concentrate on, e.g. "concurrency and error handling".
modelNo
effortNo
targetNouncommitted changes, the branch vs base_branch, or one commit_sha.uncommitted
commit_shaNo
adversarialNoChallenge the approach and assumptions, not just find bugs.
base_branchNo
wait_secondsNoSeconds to block before returning a progress snapshot (default 120). Returns early when the turn finishes or Codex needs an answer. The turn keeps running after this returns.

Schema Changelog

Changes observed during successful MCP inspections.

  1. First observedv0.2.0

TDQS

A3.6/5.0
Behavior4/5

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

With no annotations supplied, the description carries the full burden and does real work: it declares the operation read-only, names the output field ('review'), and explains the blocking semantics of wait_seconds — early return on turn completion or when Codex needs an answer, with the turn continuing to run afterward. That is unusually useful async context. It omits error/failure behavior and any permission or cost expectations, which keeps it from a 5.

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

Conciseness4/5

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

Three sentences, front-loaded with purpose, then output location, then the steering parameters. Almost no waste. The phrase 'Pass focus and/or adversarial: true' is slightly awkward to parse but does not obscure meaning.

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

Completeness3/5

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 annotations and no output schema, the description covers the essentials: what it does, where the review lands, and how the blocking wait behaves. It leaves the target/commit_sha/base_branch relationship and the model/effort parameters entirely to the schema, and never says how to resume or answer a pending turn, so an agent must infer the follow-up path.

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

Parameters3/5

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

At 56% schema coverage, the description adds some meaning by framing focus and adversarial as producing a 'steerable review that challenges assumptions and edge cases,' though the adversarial schema field already says nearly the same thing. The description says nothing about model, effort, target, commit_sha, or base_branch, four of which have no schema descriptions at all, so it does not compensate for the coverage gap.

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

Purpose4/5

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: 'Run Codex's native code review (read-only) in a git repo.' That is materially different from the generic siblings codex_run or codex_steer, and the read-only framing sets it apart from mutating operations. It stops short of naming a sibling as the alternative path, so it does not fully earn a 5.

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

Usage Guidelines3/5

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

There is implied guidance: use focus and/or adversarial for a 'steerable review,' which tells an agent when those knobs matter. But there is no explicit when-to-use versus codex_run, no statement of when not to use it, and no instruction on what to do after the early-return snapshot (presumably codex_respond or codex_wait, but that 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.