Invite a friend, get 1 month of Pro freeHow it works

Parallel coding agents: Claude Code and Codex together (2026)

How to run Claude Code and Codex as parallel coding agents in 2026: split the work, give each agent a git worktree, pass output between agents and watch limits.

Solviera Teknoloji Updated: 10 min read

Short answer (November 2026): to run parallel coding agents such as Claude Code and Codex on one project, give each agent its own git worktree (or a strict folder boundary), one measurable goal and a defined place for its output. Both CLIs now help with the first step: claude --worktree <name> starts Claude Code in its own worktree, and OpenAI’s ChatGPT desktop app runs Codex chats in parallel, optionally in git worktrees. To see agents from more than one vendor in one window, use a multi-agent app such as AgentVera, Orca, Emdash or the VS Code Agents window. Start with two agents, and remember that every agent draws on the same plan limits.

We make AgentVera, one of the apps mentioned here, so keep that in mind as you read. The method below works in plain terminals too.

What changed since this guide first came out

This guide first came out in September 2026. Since then:

  • Claude Code creates worktrees itself. claude --worktree feature-auth (or -w) creates a worktree under .claude/worktrees/feature-auth/ on a new branch named worktree-feature-auth and starts the session there. Subagents can get their own worktree too, with isolation: worktree in their frontmatter.
  • Codex runs in parallel in OpenAI’s app. The ChatGPT desktop app runs several Codex chats at once, each optionally in its own worktree, on macOS and Windows, with Linux in preview.
  • More apps manage several agents. Orca, the VS Code Agents window and others joined Conductor, Paradev (formerly Superset) and AgentVera. We compare them in the best apps to run Claude Code and Codex in parallel.
  • Limits got new names. Anthropic’s Max plans are now Max and Ultra. Pro and Max still cap usage in a 5-hour window plus a weekly limit, which matters when several agents share one account.

Why parallel coding agents?

The bottleneck with a single agent is waiting. While it thinks, reads files and runs tests, you either wait or switch to something else. Parallel agents put that waiting time to use.

They pay off most when you have:

  • Independent work: a backend endpoint and a frontend form that don’t touch each other.
  • Writing and checking: one agent writes the code, another writes tests for the same change.
  • Research and implementation: one agent compares library options while another edits existing code.
  • Different strengths: Claude Code and Codex ship with different models and tool sets; trying both on the same problem can get you there faster. For how the two differ, see Claude Code vs Codex.

Three rules for splitting the work

Whether parallel work succeeds depends on how you split it.

1. Draw file boundaries up front

Two agents editing the same file is the most common failure. Write in each agent’s role which folders it may touch. For example, one agent works only under src/api/, the other only under tests/.

2. Give each agent one goal

Instead of “improve the auth module”, give a measurable goal such as “move session handling to refresh tokens”. A clear goal lets the agent stop early and makes its output easy to check.

3. Decide where the output goes

If one agent’s result feeds another, design that up front. Will it write a plan file, commit, or send its reply straight to the next agent?

Prevent file conflicts with git worktrees

When folder boundaries aren’t enough, the most robust option is a separate working tree per agent. A git worktree opens another branch of the same repository in its own folder, with shared history. You can create them by hand:

git worktree add ../acme-web-auth -b auth-refactor
git worktree add ../acme-web-tests -b auth-tests

Or let Claude Code do it:

claude --worktree auth-refactor

Claude Code puts that worktree under .claude/worktrees/, so add that folder to .gitignore. A .worktreeinclude file in the project root (gitignore syntax) copies untracked files such as .env into every worktree Claude Code creates. When you exit, Claude removes a clean worktree of an unnamed session and asks before removing one that has changes.

Each agent works in its own folder and never touches the other’s files. When they’re done, you merge the branches through a normal pull request. The details, including ports, env files and cleanup, are in git worktrees for parallel agents.

In AgentVera, worktrees live in the right panel: create one from a new or existing branch, see its change count and how far it is ahead of or behind the main branch, and start an agent directly in it.

Example setup: Claude Code writes, Codex tests

A simple, effective starting layout:

AgentToolRoleWorks in
ArchitectClaude CodePlans and implements the featureauth-refactor worktree
TesterCodexWrites integration tests for the changeSame worktree, tests/ only
Dev serverTerminalRuns pnpm devMain folder

Setup steps in AgentVera:

  1. Add the project folder.
  2. In the New agent dialog, pick Claude Code, name it “Architect” and write the file boundaries in its role.
  3. Do the same for Codex as “Tester”.
  4. Start the dev server in a Terminal agent.
  5. Give Architect its task; when it finishes its turn, hand its output to Tester.

You can do the last step by hand, or with a flow: flows (Pro and Team) send one agent’s last reply to another through an {{output}} template, and wait for the target agent to finish its turn if it’s busy. Without an app, a plain summary file that the next agent reads does the same job.

Keeping an eye on parallel agents

As the number of agents grows, the real work becomes following them. Watch for:

  • Status: which agent is working, which is waiting for you, which hit an error?
  • Context size: long conversations cost more tokens on every turn.
  • Approval requests: an agent waiting for permission stops while the others keep going.

AgentVera’s workspace shows agents side by side in a grid. Each pane has its status, live context size and a message box. Agents waiting for approval are listed in the status bar, and ⇧⌘A jumps to the one that has waited longest.

Context, cost and limits

Working in parallel multiplies token usage. Each agent’s first request carries tool definitions, the system prompt and plugins, and in long conversations that baseline is re-read on every turn. All agents on one account also share its limits: on Claude Pro and Max, a 5-hour session window plus a weekly limit.

To keep cost in check:

  • Start agents for simple jobs with a narrower tool set, and add MCP servers only where they’re needed. MCP server managers help keep one list for every agent.
  • Compact long conversations with /compact.
  • When passing output between agents, send only the part that’s needed.
  • If you run out of limits regularly, see Claude Code account switchers, and use several accounts only where the provider’s terms allow it.

For measured numbers, see cutting Claude Code token usage.

Common mistakes

Two agents on one file. The fastest fix is a worktree or a strict folder boundary.

Vague tasks. Open-ended tasks like “fix the code” make the agent read endless files and bloat the context.

Merging without checking. Run the tests and review the diffs before merging what parallel agents produced. Automatic code review saves time here.

Starting everything at once. Begin with two agents and add a third once the split works.

An end-to-end example: moving to refresh tokens

Splitting work looks easy on paper; here’s how it plays out on a real task. The goal: move a web app’s session handling to short-lived access tokens with rotating refresh tokens.

Splitting the task

First, break the work into independent pieces. This task has three:

  • Server side: token issuing, validation and rotation (src/auth/).
  • Tests: integration tests for the new flow (tests/api/).
  • Docs: reflecting the API changes in the README.

Server side and tests look at the same behavior but live in different folders. Docs only make sense once the server side is settled. So run the first two in parallel and the third afterwards.

Role instructions

Keep each agent’s role short and strict. For Architect:

Work only under src/auth/. Don't change tests.
Run pnpm test auth after every change.
When you're done, summarize your changes as a bullet list.

For Tester:

Work only under tests/. Don't touch application code.
Write integration tests for the behaviors in the summary you receive.

The last line of Architect’s role matters: its summary becomes Tester’s input. The tidier the summary, the fewer files Tester has to read.

Handoff and follow-up

When Architect finishes its turn, its last reply goes to Tester, by hand or through a flow. If Tester is busy, a flow waits for its turn to end, and the connection’s turn limit stops the two agents from looping forever. Meanwhile you can watch the dev server logs in the terminal agent or have a third agent prepare the docs.

When not to go parallel

Not every job parallelizes. Stick to one agent working step by step when:

  • The change is concentrated in one file or a few tightly coupled files.
  • The task isn’t clear yet; research and a plan come first.
  • One agent’s output is a precondition for the other, and the second job is short.

In those cases a staged pipeline works better than parallelism. I cover that in AI agent workflow.

Where to run parallel agents

You can run all of this in plain terminal tabs. Once you have more than two agents, an app that shows them together helps. What to look for is covered under agentic development environment; in short:

  • One vendor only: the Claude desktop app (Code tab) runs parallel Claude sessions in worktrees; the ChatGPT desktop app does the same for Codex.
  • Inside your editor: the VS Code Agents window runs Copilot, with Claude and Codex as experimental options.
  • Free and open source, any OS: Orca (MIT) or Emdash (Apache-2.0).
  • Mac only: Conductor runs Claude Code, Codex and Cursor agents.
  • Many CLI agents with your own logins on Windows, Linux or macOS: AgentVera runs 18 of them in one grid. It is closed source; the grid, worktrees and all agents are on the free plan, and flows and account switching on Pro and Team.

For per-OS help, see coding agents on Windows, and if the agents run unattended, running Claude Code overnight.

Checklist

Before a parallel session:

  • Is each agent’s goal written in one sentence?
  • Are file boundaries in the role?
  • If conflicts are likely, does each agent have its own worktree?
  • If one agent’s output feeds another, is the handoff (summary file or flow) ready?
  • Is there an agent or terminal to run the tests?
  • Do you know how much of your plan’s limit is left?

Wrapping up

Parallel coding agents save real time on work that splits cleanly. The key is to separate agents and define the handoff between them: worktrees separate files, a summary file or a flow carries output, and well-written roles separate responsibilities.

AgentVera is built to set this up in one window: Claude Code, Codex and other CLIs run side by side with their own logins. You can start on the free plan and check the plans when you need more.

Questions

Can Claude Code and Codex work on the same project at the same time?

Yes. Each runs in its own terminal session with its own login. The safest setup gives each agent its own git worktree, so they never edit the same files. Claude Code can create one itself with claude --worktree <name>.

Do parallel agents need separate accounts?

No. You can run several agents on one account, but they all draw on the same usage limits, which fill up faster. If you use several accounts, check that the provider’s terms allow it.

How many agents should I run at once?

As many as you can review. Two to four agents is manageable for most projects; beyond that you need a clear view of which agent is waiting for you.

Can agents use each other’s output?

Yes. You can have one agent write a plan or summary file that the next one reads. In AgentVera, flows (Pro and Team) send one agent’s last reply to another through a template.

Which app runs Claude Code and Codex side by side?

Multi-agent apps such as AgentVera, Conductor (macOS only), Orca, Emdash, Paradev and the VS Code Agents window run both. The Claude desktop app and the ChatGPT desktop app each run only their own agent.

Bring your agents to one desk.

Download AgentVera for free; your installed CLIs are ready to go.

More posts