Skip to main content
Glama

Review git changes (paid)

codex_review_changes

Get an independent code review of your git changes from Codex, covering working tree, branch, or commit diffs.

Instructions

Ask Codex (a different model) to review your git changes for an independent second opinion.

PAID — this spends Codex quota on every new call; use codex_dry_run or codex_status (both free) first if you only need to check scope or readiness.

scope: working_tree (tracked changes vs HEAD — untracked files follow the untracked policy and are NOT reviewed by default), branch (needs base, reviews base...HEAD), or commit (needs a commit SHA). The diff is gathered, secret- redacted, and bounded by this server; Codex reviews it read-only and returns structured findings. Pass workspace_root (absolute) for the right repo. Optional extra_context (author intent, bounded like the diff) cuts false positives.

The result's top-level review_status and coverage disclose whether the model actually ran and what it was shown: a pass over partial coverage is surfaced as unknown, and a tree with nothing reviewable returns not_run, never a pass.

STATIC review, not a verify mode: the read-only sandbox blocks the writes a test/build/lint run needs, so Codex can't run the project's checks to confirm its findings — treat them as unvalidated claims you verify yourself before acting.

Data egress: this sends the gathered diff to OpenAI via the codex CLI. The diff is secret-redacted (best-effort), but your extra_context is sent raw (unredacted), and Codex may read and send other repo files. Codex auto-loads the resolved workspace's AGENTS.md and discovers skills in its .agents/skills/ and user-global $CODEX_HOME/skills/ (default ~/.codex/skills/), reachable from outside the workspace. The plugin's isolation flags don't suppress any of it. A selected skill's body can reach the model even if your prompt never mentions it. Redaction is not a guarantee. Do not rely on it to protect live credentials; keep them out of the reviewed tree and your supplied inputs, or do not request a review of that tree.

Progress & recovery: blocks up to the resolved deadline (timeout_seconds, clamped 10-600s; when omitted, the server-configured value, built-in default 300s). If that deadline expires the run is terminated and its partial output is not recoverable or resumable, so for a multi-file or whole-branch review that may exceed it, prefer codex_review_changes_async (a background job, built-in default 1800s deadline; poll codex_job_status). Coarse notifications/progress streams while it blocks when your client requests it; some MCP clients background a long call before the deadline, so timeout_seconds bounds the run, not necessarily the inline wait — either way the detached run (meta.job_id) is recoverable via codex_job_listcodex_job_statuscodex_job_result.

Input Schema

TableJSON Schema
NameRequiredDescriptionDefault
baseNoBase git ref for scope='branch'; the review covers base...HEAD.
modelNoOverride the Codex model slug for this call; defaults to the server/Codex default when unset.
pathsNoRepo-relative paths to narrow the review ('/' separators, no '..'); omit to review all changes in scope.
scopeNoWhich changes to review: 'working_tree' (tracked changes vs HEAD; untracked files follow the `untracked` policy, off by default), 'branch' (needs base), or 'commit' (needs commit).working_tree
commitNoCommit SHA or ref to review for scope='commit'.
detailNoResponse verbosity: 'summary' (default) omits the raw model text; 'full' includes it.summary
isolationNoCodex config isolation: 'inherit' | 'ignore-config' | 'ignore-rules'. Defaults to the server's configured value (built-in 'inherit'; `codex_status` reports the resolved one).
untrackedNoHow working_tree scope treats untracked files: 'explicit_only' (default) includes only those named in `paths`; 'include' reviews all non-ignored untracked files (SENDS their contents to OpenAI — opt-in egress); 'exclude' includes none. Omitted ones are disclosed in `coverage`. Inert for branch/commit scopes.explicit_only
extra_contextNoOptional author intent/background context, added as clearly-labeled UNTRUSTED prompt data. Redaction does NOT cover it — no live secrets. Full caveats and bounds: codex://params.
workspace_rootNoAbsolute path to the target repo root — pass it (or an MCP root) to target the intended repo; otherwise the call falls back to the server's own cwd and sets meta.workspace_warning.
idempotency_keyNoOptional dedup key scoped to THIS tool + workspace. Same key + same args replays the prior result with no new spend; different args are refused (idempotency_conflict). Sync and _async are separate tools and never share a key. Omit for none; retention is bounded. Lifecycle: codex://params.
timeout_secondsNoPer-call wall-clock timeout in seconds, clamped to 10..600 (out-of-range values are coerced, not rejected). Defaults to the server's configured timeout.
reasoning_effortNoOverride the Codex reasoning effort for this call (a model_reasoning_effort override); omit or pass null for the server default (CODEX_IN_CLAUDE_REASONING_EFFORT) or Codex's own resolution. An open, per-model string the backend validates at run time — commonly minimal|low|medium|high|xhigh; codex_models lists each model's advertised set (advisory). Rejection and bounds detail: codex://params.

Output Schema

TableJSON Schema
NameRequiredDescriptionDefault
okYes
Behavior5/5

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

Beyond the annotations, the description discloses extensive behavioral context: it spends Codex quota, sends the diff and possibly other repo files to OpenAI, has best-effort redaction with raw extra_context, auto-loads AGENTS.md and skills, ignores isolation flags, blocks up to a deadline, loses partial output on timeout, and supports recovery via job_id. It also explains review_status/coverage semantics. No contradiction with annotations.

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

Conciseness5/5

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

Although long, every paragraph earns its place: cost/alternatives, scope, result semantics, static-review limitation, data egress, and progress/recovery. It is front-loaded with the core purpose and paid warning, and uses clear section labels and bolded terms for scannability. The length is justified by the tool's complexity and security implications.

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

Completeness5/5

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

Given the tool's complexity, the output schema covers return values, so the description correctly focuses on usage context, cost, egress, limitations, and recovery. It leaves no practical gap: the agent knows when to use it, what it costs, what data leaves the environment, what the limitations are, and how to handle long-running or timed-out calls via the async/job family.

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

Parameters4/5

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 meaningful cross-parameter context beyond the schema, such as 'extra_context ... cuts false positives', 'untracked files ... NOT reviewed by default', 'pass workspace_root (absolute) for the right repo', and the distinction that timeout_seconds bounds the run, not necessarily the inline wait. It does not walk through every parameter, but the schema already does that.

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

Purpose5/5

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

The description opens with a specific verb+resource: 'Ask Codex (a different model) to review your git changes for an independent second opinion.' It distinguishes itself from siblings by explicitly naming codex_dry_run/codex_status as free alternatives and codex_review_changes_async for long-running reviews. The paid nature is boldly stated in the first line.

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

Usage Guidelines5/5

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

It provides explicit when-to-use guidance: use codex_dry_run or codex_status first if only checking scope/readiness, prefer codex_review_changes_async for multi-file/whole-branch reviews that may exceed the timeout, and treat results as unvalidated claims because this is STATIC review, not a verify mode. It also tells the agent to pass workspace_root for the correct repo and use extra_context to cut false positives.

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

Install Server

Other Tools

Latest Blog Posts

MCP directory API

We provide all the information about MCP servers via our MCP API.

curl -X GET 'https://glama.ai/api/mcp/v1/servers/briandconnelly/codex-in-claude'

If you have feedback or need assistance with the MCP directory API, please join our Discord server