codex-collab

English | 中文

Collaborate with Codex from Claude Code. Run tasks, get code reviews, do parallel research, all without leaving your Claude session.

codex-collab is a Claude Code skill that drives Codex through its app server JSON-RPC protocol. It manages threads, streams structured events, handles tool-call approvals, and lets you resume conversations — all without leaving your Claude session.

Why

• Structured communication — Talks to Codex via JSON-RPC over stdio. Every event is typed and parseable.
• Event-driven progress — Streams progress lines as Codex works, so Claude sees what's happening in real time.
• Review automation — One command to run code reviews for PRs, uncommitted changes, or specific commits in a read-only sandbox.
• Thread reuse — Resume existing threads to send follow-up prompts, build on previous responses, or steer the work in a new direction.
• Approval control — Configurable approval policies for tool calls: auto-approve, interactive, deny, or Codex's Guardian auto-reviewer (--approval auto).
• Two-way ask channel — Codex can ask a question mid-turn (ask) and keep working once the answer arrives (answer); next blocks until something needs attention. Fail-open: an unanswered question never stalls a run.
• Live observability — run --detach hands a long task to a detached runner; follow --watch is a purpose-built live view that tracks every run in a terminal pane.
• Memory isolation — Threads created by codex-collab are excluded from Codex's memory feature by default, so agent-driven sessions don't shape Codex's learned picture of how you work. Opt back in with --memory (see Options for details).

Installation

Requires Bun >= 1.0 and Codex CLI (npm install -g @openai/codex) on your PATH. Tested on Linux (Ubuntu 22.04), macOS, and Windows 10.

git clone https://github.com/Kevin7Qi/codex-collab.git
cd codex-collab

Linux / macOS

./install.sh

Windows

powershell -ExecutionPolicy Bypass -File install.ps1

After installation, reopen your terminal so the updated PATH takes effect, then run codex-collab health to verify.

The installer builds a self-contained bundle, deploys it to your home directory (~/.claude/skills/codex-collab/ on Linux/macOS, %USERPROFILE%\.claude\skills\codex-collab\ on Windows), and installs a binary shim (install.ps1 adds it to your PATH; install.sh places it in ~/.local/bin and prints instructions if that directory is not already on your PATH). Once installed, Claude discovers the skill automatically.

Upgrading

An installed codex-collab can update itself — no manual git pull needed:

codex-collab update            # show the latest release and changelog, confirm, then install
codex-collab update --check    # report only, install nothing

update downloads the pinned release tag from GitHub, rebuilds locally, reinstalls the skill bundle and binary shim, and prints the SKILL.md diff it applied. Nothing is installed without consent: an interactive y/N prompt, or an explicit --yes in non-interactive sessions. run, review, and health print a one-line notice when a newer release exists (checked at most once a day, never installing anything on their own); update --skip mutes notices for a given release, and CODEX_COLLAB_NO_UPDATE_CHECK=1 disables the release check entirely (the local skill-drift notice is offline and stays on).

Relatedly, if the installed SKILL.md drifts from the binary or your template set (e.g., after adding a custom template), codex-collab skill sync shows the pending diff and applies it on confirmation.

Upgrading manually still works: pull the latest version in your clone and rerun the installer (dev installs — install.sh --dev — always update this way):

git pull
./install.sh    # Windows: powershell -ExecutionPolicy Bypass -File install.ps1
codex-collab health

Either path replaces the installed skill bundle and binary shim. Existing configuration, templates, thread history, and run logs under ~/.codex-collab/ are preserved. Treat ~/.claude/skills/codex-collab/ as installer-managed: manual edits there may be overwritten on upgrade (skill sync surfaces them as a diff before overwriting).

When upgrading from older versions, codex-collab automatically migrates thread state to the per-workspace layout on first use. No manual state migration is required. The old jobs command remains available as a deprecated alias for threads.

Development mode

Use --dev to symlink source files for live-reloading instead of building a bundle:

# Linux / macOS
./install.sh --dev

# Windows (may require Developer Mode or an elevated terminal for symlinks)
powershell -ExecutionPolicy Bypass -File install.ps1 -Dev

Quick Start

# Run a prompted task
codex-collab run "what does this project do?" -s read-only --content-only

# Code review
codex-collab review --content-only

# Resume a thread
codex-collab run --resume <id> "now check error handling" --content-only

# Long task: detach it, watch it live in another pane
codex-collab run "large refactor" --detach --approval auto
codex-collab follow --watch

CLI Commands

Command	Description
run "prompt" [opts]	Start thread, send prompt, wait, print output (run - reads the prompt from stdin — no shell-quoting hazards)
review [opts]	Code review (PR, uncommitted, commit)
threads [--json] [--all]	List threads (--limit <n> to cap, --discover to scan server, --session for only threads the current session has run)
kill <id> [--clear]	Interrupt running thread. An active goal is paused first — interrupt alone would just respawn a continuation turn; --clear abandons the goal instead
follow [id]	Live view of a running thread; exits with its status (replays the last run when already finished). Without an ID, attaches to the workspace's active run — or replays the most recent one. With --watch, stays open and follows each new run (every run shown once, in start order)
output <id> [--last]	Full log for thread (--last: only the latest turn's output)
progress <id>	Recent activity (tail of log)
peek <id>	Show recent conversation slice from server
ask "question"	(for Codex, mid-turn) Post a question to the collaborator and wait for the answer; --timeout <sec> sets the deadline (default 600). Fails open: on expiry it prints proceed-on-your-judgment guidance and exits 0
answer <id> "text"	Answer a pending question (answer <id> - reads the answer from stdin)
questions [id]	List pending questions in this workspace; with an ID, show that question's full text
next	Block until something needs attention (question or approval), print it in full with how to respond, exit
config [key] [value]	Show or set persistent defaults
models	List available models
templates	List available prompt templates
skill sync [--yes]	Regenerate the installed SKILL.md when it drifts from the binary or template set — prints the diff, applies only on confirmation
update	Check GitHub for a newer release, show its changelog, and (with confirmation) download, build, and reinstall — see Upgrading
health	Check dependencies
version	Print version (also -v/--version before a command)

Thread management

Command	Description
delete <id> [--purge]	Archive thread (recoverable via codex unarchive) and delete local files; --purge permanently deletes it server-side instead
clean	Delete old logs and stale mappings
approve <id>	Approve a pending request
decline <id>	Decline a pending request

Options

General

Flag	Description
-d, --dir <path>	Working directory
-m, --model <model>	Model name (default: auto — latest available)
-r, --reasoning <level>	none, minimal, low, medium, high, xhigh, max, ultra (default: auto — highest the model supports, up to xhigh)
-s, --sandbox <mode>	read-only, workspace-write, danger-full-access (default: workspace-write). review rejects this flag: reviews always run read-only
--resume <id>	Resume existing thread
--approval <policy>	Approval policy: never, on-request, on-failure, untrusted, auto (default: never). auto: Codex's Guardian reviewer approves or denies each request autonomously — never blocks on a human; decisions stream as Guardian lines. review rejects this flag: Codex locks review sub-agents to never, so it could never take effect
--memory	Let Codex's memory feature learn from threads this run creates. Default: created threads get thread/memoryMode/set mode=disabled; resumed threads are never touched (the flag is persistent per-thread, and a thread you created yourself should keep feeding your memory). Governs Codex's local memory consolidation (~/.codex/memories) only — the personality feature is explicit user config (not learned) and unaffected. Persistent form: config memory true
--timeout <sec>	Turn timeout (default: 1200, max 2147483). When a goal is active it scopes the whole goal, and expiry pauses the goal before exiting. For ask: answer deadline (default: 600); for next: wait deadline (default: wait indefinitely)
--	End of options; remaining arguments are treated as prompt text

run

Flag	Description
--detach	Return once the turn is running; watch with follow <id>. Turn lifetime is decoupled from the invoking shell
--template <name>	Prompt template (user ~/.codex-collab/templates/ or built-in)
--goal <objective>	Create the thread's goal before the first turn (replaces the objective on --resume); requires goals = true in ~/.codex/config.toml. With --template collab the objective also gets a one-line ask-channel note — re-injected into every continuation turn, so channel awareness survives long goals
--budget <tokens>	Token budget for --goal. Size generously — usage counts each turn's full context, so a single small turn can consume ~60k
-	Read the prompt from stdin

review

Flag	Description
--mode <mode>	Review mode: pr, uncommitted, commit, custom
--ref <hash>	Commit ref for --mode commit
--base <branch>	Base branch for PR review (default: auto-detected default branch)

follow

Flag	Description
-w, --watch	Don't exit when the run finishes — keep following each new run (Ctrl-C to stop)

skill & update

Flag	Description
--yes	Apply without prompting — the explicit consent flag for non-interactive sessions
--check	(update) Show the latest release and changelog without installing
--skip	(update) Mute update notices for the latest release; a later release notifies again

Listing & output

Flag	Description
--json	JSON output for supported commands (threads, peek)
--all	List all threads with no display limit
--discover	Query Codex server for threads not in the local index
--limit <n>	Limit items shown by threads or peek
--full	Include all item types in peek output (default shows messages only)
--content-only	Suppress progress lines; with output, return only extracted content
--last	(output) Only the latest turn's output instead of the whole thread history (implies --content-only)
--session	(threads) Only threads the current session has run

Exit codes

run and review:

Code	Meaning
0	Completed
1	Failed
3	Timed out — an active goal is paused first (resumable)
4	Interrupted (kill)
5	Died blocked on an approval — the request is void; resume with a longer --timeout, or use --approval auto
6	Broker busy and fallback unavailable — transient, retry
7	Goal ended blocked or usage/budget-limited — steer with run --resume, or abandon with kill --clear

next: 0 event delivered (printed in full on stdout) · 3 --timeout elapsed with no event · 10 workspace idle (nothing running, nothing pending).

Goal mode

With goals = true in ~/.codex/config.toml, a goal — created by Codex mid-turn, or explicitly with run --goal "objective" [--budget <tokens>] — makes the server keep starting continuation turns until the objective is done, and a run follows the whole goal in one run record and log; its exit code reflects the goal's end. The objective is re-injected into every continuation turn; one too big to state in a sentence can point at a spec or plan file in the repo. threads shows each thread's latest goal state ([goal active: 45k/100k tokens]).

Defaults & Configuration

By default, codex-collab auto-selects the latest model (the server's default, followed up its upgrade chain, preferring a -codex variant where one exists) and the highest reasoning effort that model supports, up to xhigh. No configuration needed — it stays current as new models are released.

The max and ultra tiers are opt-in rather than auto-selected: reach for them with -r max / -r ultra on a single run, or make one the standing default with codex-collab config reasoning.

To override defaults persistently, use codex-collab config:

# Show current config
codex-collab config

# Set a preferred model
codex-collab config model gpt-5.6-sol

# Set default reasoning effort
codex-collab config reasoning high

# Unset a key (return to auto-detection)
codex-collab config model --unset

# Unset all keys
codex-collab config --unset

Available keys: model, reasoning, sandbox, approval, timeout, memory

CLI flags always take precedence over config, and config takes precedence over auto-detection:

CLI flag  >  config file  >  auto-detected

Config is stored in ~/.codex-collab/config.json.

Contributing

See CONTRIBUTING.md for development setup and guidelines. This project follows the Contributor Covenant code of conduct.

See also

For simpler interactions, you can also check out the official Codex MCP server. codex-collab is designed as a Claude Code skill, with built-in support for code review, thread management, and real-time progress streaming.