Running several Codex sessions at once

The setup

git worktree add -b feature/auth   ../app-auth
git worktree add -b feature/search ../app-search

# -C sets the agent working directory; no cd, no subshell
codex -C ../app-auth   -s workspace-write -a on-request
codex -C ../app-search -s workspace-write -a on-request

The sandbox root is the working directory Codex starts in, which is why -C is the flag that matters here. Point two sessions at two worktrees and each one's writable region is a different directory. Point them at the same directory and you are back to two agents editing one tree with no coordination.

Why Codex parallelises unusually well

Most agents ask you to trust that they will stay in their directory. Codex runs model-generated commands inside a platform sandbox, so staying in the directory is not a decision the model gets to make.

Approvals do not scale, so set them deliberately

Four sessions each asking permission produces a stream of interruptions you will start approving without reading, at which point the prompts have stopped providing safety and are only costing you attention. Decide the policy up front instead.

The desktop app manages worktrees for you

If you use Codex in the ChatGPT desktop app rather than the CLI, the worktree management already exists and is worth knowing about before you build your own.

A launcher worth writing once

Three commands per session is enough friction that you will stop after a week. Collapse it.

#!/usr/bin/env bash
# cx <branch> [prompt...] - start a Codex session in its own worktree
set -euo pipefail

name="$1"; shift
repo="$(basename "$PWD")"
dir="../${repo}-${name//\//-}"

[ -d "$dir" ] || git worktree add -b "$name" "$dir"

for f in .env .env.local; do [ -f "$f" ] && cp "$f" "$dir/"; done

( cd "$dir"
  if   [ -f pnpm-lock.yaml ];    then pnpm install --prefer-offline
  elif [ -f package-lock.json ]; then npm ci
  fi )

exec codex -C "$dir" -s workspace-write -a on-request "$@"

cx feature/auth "add JWT middleware to the admin routes"

The three ceilings

1. Attention. Around four sessions, terminal tabs stop being a usable index of what is running and which one is blocked waiting on you. You start tabbing through them to find out, which is the moment parallelism starts costing more than it returns.
2. Quota. Consumption scales linearly with sessions. Four parallel sessions drain a ChatGPT allowance roughly four times as fast, and the failure mode is not a warning, it is four agents stopping at once in the middle of four different tasks.
3. Review. The one that actually binds. Four agents generate more diff than one person can read carefully, and unreviewed agent output is a liability rather than an asset.

Mixing Codex and Claude Code

Running both is the cheapest way to raise the quota ceiling, because the two bill against different subscriptions. It is also the fastest way to get a second opinion on the same task: two agents on two worktrees, one branch each, and you pick the diff you prefer.

Questions people ask

Keep reading