Maxxwell by Rindler
Writing

Running Claude Code and Codex in parallel

2026-08-30

Most people who run Claude Code or Codex seriously hit the same wall: the agents scale, your attention doesn’t.

Most people who run Claude Code or Codex seriously hit the same wall: the agents scale, your attention doesn’t.

You go from “this is fast” to “I am tab-switching babysitter for eight terminals” in about a week.

This piece compares two ways to run Claude Code and Codex in parallel using git worktree: manual prompt juggling vs structured orchestration with an agent manager like Maxxwell.

It assumes you’re already comfortable with git and running agents locally.

Git worktrees are the isolation primitive

Parallel agent work without isolation is how you get silent conflicts and mystery test failures.

Git worktrees are the shared abstraction everyone has settled on:

Basic pattern:

# In your main repo
$ git worktree add ../feature-auth feature/auth
$ git worktree add ../feature-search feature/search

# Now you have:
#   repo/              -> main branch
#   feature-auth/      -> feature/auth branch
#   feature-search/    -> feature/search branch

From here you can:

Worktrees are inherently parallel-friendly: git supports zero or more linked worktrees per repo, and each is just another directory with a branch checked out.

Manual prompt juggling: simple, but attention-bound

The default for most devs is manual orchestration:

For example, using Claude Code’s CLI plus Codex in another shell:

# Session 1: Claude Code on auth worktree
$ cd ../feature-auth
$ claude-code

# Session 2: Codex on search worktree
$ cd ../feature-search
$ codex

You then:

Where manual control is actually fine

Manual control still makes sense for smaller, supervised work:

Anthropic’s docs call this synchronous terminal/editor work: you get fine-grained control, but burn attention the whole time. OpenAI’s guidance is similar: for most work, start with “Ask for approval”.

Manual is good when:

The manual ceiling

Manual breaks down once you try to run agents truly in parallel:

In practice, that looks like:

Worktrees solved concurrency for git. They did nothing for your ability to see and route what the agents are doing.

Structured orchestration: one brain above many agents

The industry is converging on an orchestration layer that sits above individual agents:

The pattern is:

Our pillar guide, “AI coding agent orchestration: the complete guide for multi-agent development”, goes deep on this. Here we stay concrete on Claude Code, Codex, git worktrees, and an agent manager like Maxxwell.

A concrete git worktree workflow for parallel Claude + Codex

Say you want to build three features:

Set up worktrees:

$ cd repo
$ git worktree add ../auth         feature/auth
$ git worktree add ../search       feature/search
$ git worktree add ../analytics    feature/analytics

Launch agents:

# Auth with Claude Code
$ cd ../auth
$ claude-code

# Search with Codex
$ cd ../search
$ codex

# Analytics, your choice
$ cd ../analytics
$ claude-code   # or codex

Now the question is how you orchestrate these three sessions.

DIY orchestration with scripts and discipline

One route is to build your own thin orchestration on top of this:

Example: crude status check via git and a convention:

$ git worktree list
repo          0123abc [main]
auth          4567def [feature/auth]
search        89ab012 [feature/search]
analytics     3456ghi [feature/analytics]

You then rely on:

This works, but every coordination decision still goes through you.

Orchestration with Maxxwell: agent-of-agents

Maxxwell is an agent that manages your coding agents. It does not replace Claude Code or Codex; it sits above them.

With Maxxwell in the same setup:

You:

Important constraints:

Maxxwell gives you orchestration without a hidden autopilot:

You still decide; the system just makes that decision cheap.

When automation improves throughput and reliability

You don’t need structured orchestration for every task. You probably do need it once you cross three or four concurrent agents.

Patterns where automation helps:

  1. Parallelizable feature work
    • Multiple independent branches: auth, search, analytics, emails.
    • Each mapped to a worktree and agent.
    • Claude’s Agent View and Codex’s subagents are explicitly built for this.
  1. Team environments
    • Several developers running agents at once.
    • Coordination cost is suddenly visible.

In these cases, an orchestrator that:

…gives you higher throughput than manual prompt juggling, while keeping human review in the loop.

Human review remains non-negotiable:

An orchestrator should make review easier, not optional.

How Maxxwell differs from other orchestration tools

Brief landscape:

Maxxwell’s distinctives:

If your DIY tmux scripts are mostly about keeping sessions visible and states straight, Maxxwell is essentially a turn-key version of that with an agent sitting on top.

Comparison: manual vs orchestrated Claude + Codex with worktrees

Here’s a condensed comparison for the same scenario: Claude Code on auth, Codex on search, analytics as a third lane.

Manual control is strongest for small, high-risk tasks, while structured orchestration wins once you run several agents in parallel across git worktrees.

Key differences:

Recommendation by use case

For most teams running Claude Code and Codex in parallel with git worktrees:

If your pain sounds like “I have eight sessions open and I am the slowest part of this”, you’re past the manual ceiling. At that point, tying Claude Code and Codex to worktrees and letting an orchestrator manage them is the more stable path.

FAQ

How do I run Claude Code and Codex in parallel safely?

Use git worktree to create one worktree per independent feature or task. Attach Claude Code to one worktree and Codex to another. Avoid sharing a single working tree between agents to prevent file collisions.

When is manual control over agents enough?

Manual control is enough when you run one or two agents at a time on short, high-risk tasks. You’re watching outputs closely, and coordination overhead is low. For bigger parallel feature work, the attention cost grows faster than the benefit.

What does an orchestration layer actually do?

It:

Maxxwell does this while keeping agents in real terminals you can take over.

Does Maxxwell replace Claude Code or Codex?

No. Maxxwell is an agent that manages your coding agents. Claude Code, Codex, Cursor, and similar tools remain your workers. Maxxwell owns the layer above them: goals, visibility, and the handful of decisions that need a person.

How do I integrate orchestration with CI and main?

Keep each agent on its own worktree and branch. Land changes via normal git hygiene:

Tools like ctx add an agent merge queue; Maxxwell focuses on making the state of each session visible while leaving CI and merges in your existing pipeline.