How to run multiple coding agents in parallel

Development teams rarely use a single coding agent anymore. One developer might use Claude Code for refactors, Codex for test generation, and OpenCode with a different model for a specific codebase. Running these agents in parallel, across separate tasks or against each other on the same task, lets you make progress on multiple pieces of work at the same time.

Running several agents on one machine creates conflicts. Agents can edit the same files, start development servers on the same ports, and require credentials from different providers on the same laptop. Cloud environments give each agent room to work independently while making it easier for teams to collaborate and see what others are working on. This guide covers the different ways to run coding agents in parallel, how to set them up locally, and how to run them on Northflank Cloud Harnesses.

Running multiple coding agents gives you more ways to approach development work. Instead of relying on one agent to handle every task, you can split work across agents, use different agents for different parts of a project, or compare their solutions to the same problem.

For example, you could have Claude Code work on a refactor while Codex writes tests for another part of the codebase. You could also give both agents the same task and compare their implementations to see how they approach the problem. This is useful when evaluating different models and coding agents against your actual codebase.

It also gives you more flexibility when working with different model providers. If one provider reaches its usage limit or becomes unavailable, you can continue working with an agent connected to another provider.

There are three common patterns for running coding agents in parallel.

For a detailed walkthrough of running multiple sessions of the same agent, see How to run multiple Claude Code sessions in parallel.

You can run different coding agents on your local machine using Git worktrees and separate terminal sessions. Each worktree gives an agent its own working directory and branch, so multiple agents can work on the same repository without editing the same files.

For example, you can create one worktree for Claude Code and another for Codex:

# From your main repository
git worktree add ../myapp-claude -b claude-refactor
git worktree add ../myapp-codex -b codex-tests

# Start Claude Code in its worktree
cd ../myapp-claude
claude

Open another terminal tab and start Codex in its worktree:

cd ../myapp-codex
codex

You can repeat this for other coding agents, such as OpenCode or Pi, as long as their CLIs are installed and authenticated on your machine.

Each worktree has its own working directory, so you'll need to install project dependencies separately. For example, node_modules and Python virtual environments aren't shared between worktrees. Each agent also needs its own provider authentication and configuration.

Terminal tabs are a simple way to keep each agent in a separate session. You can also use tmux to create and manage named sessions:

# Start a session for each agent
tmux new -s claude -c ../myapp-claude
tmux new -s codex -c ../myapp-codex

# List active sessions
tmux ls

You can detach from a tmux session and return to it later, even after closing your terminal window. However, tmux doesn't keep processes running if your laptop sleeps, restarts, or loses power.

Git worktrees keep the agents' working files separate, but they don't isolate the underlying machine. All agents still share your CPU, memory, network, and other local resources.

Git worktrees keep agents out of each other's working directories, but everything else on the machine is still shared. Running different agents also introduces problems that you might not encounter when running several sessions of the same agent.

Two agents handling light tasks can usually run on a capable machine. The limitations become more noticeable with long-running tasks, heavy builds, multiple providers' credentials, or agents that need to keep running after you leave your desk.

Northflank Cloud Harnesses also make parallel work easier to coordinate across a team. Multiple team members can collaborate in Harnesses and see what others are working on in real time, without sharing a single developer's local machine.

Northflank Cloud Harnesses are cloud workspaces built for coding agents. When you create a Harness, you choose the agent it runs: Claude Code, Codex, Cursor, OpenCode, Pi, or Bring Your Own Agent. The agent comes pre-installed, its credentials are configured for the environment, and the Harness can clone a connected Git repository and branch on start. You can access a Harness through the web terminal in the Northflank dashboard or over SSH from your local machine.

For parallel agents, each Harness provides a configured workspace for an agent to work independently. A Claude Code Harness, a Codex Harness, and an OpenCode Harness can all work on the same repository at the same time, each with its own branch, compute resources, filesystem, and credentials. None of them depend on your laptop staying on.

Harnesses also support team collaboration. Multiple team members can access workspaces, follow what others are working on in real time, review agent output, and continue tasks without having to share a local development environment.

Harnesses on Northflank Cloud run in isolated microVMs. Harnesses are persisted between restarts, so you can pause a Harness and resume it later with the same files, branches, and installed packages. Billing runs per second of active compute, and pausing a Harness stops compute billing while preserving its workspace.

For teams with compliance or data residency requirements, bring your own cloud (BYOC) lets you run Harnesses inside your own AWS, GCP, Azure, Oracle, or CoreWeave account.

Create your first Harness on Northflank, or follow the quick start guide for the full setup.

Each coding agent runs in its own Harness. Create one Harness per agent, connect them to the same repository, and give each one its own branch.

1. Create a Harness and select Claude Code. Connect your repository and select a branch (see quick start guide).
2. Repeat to create additional Harnesses for Codex, Cursor, OpenCode, Pi, or Bring Your Own Agent.
3. Select compute size for each Harness based on its task. A large refactor may need more CPU and memory than a documentation update.
4. Open each Harness from the sidebar and start its agent using the relevant CLI, such as claude, codex, or opencode.
5. Give each agent its task. They can now work in parallel, each in its own microVM.
6. Pause each Harness when its task is complete. You can resume it later to continue working or review its output.

Each Harness has its own repository clone and filesystem, so you don't need Git worktrees to keep agents' files separate. You can also configure compute resources and credentials independently for each Harness.

Running two or more agents on the same task lets you compare how they handle your codebase, conventions, and tests.

1. Pick a base commit or branch and create one Harness per agent, all connected to the same starting point.
2. Have each agent create its own branch from the base, such as claude-auth-fix and codex-auth-fix.
3. Give every agent the same prompt and acceptance criteria.
4. Let each agent finish, then run the same test suite in each Harness.
5. Open a pull request for each branch and compare the diffs, test results, and how much rework each implementation needs.
6. Merge the implementation you want to keep and pause the other Harnesses.

Keep the prompt, base commit, acceptance criteria, and test conditions consistent across Harnesses so the comparison reflects the agents rather than differences in the setup.

1. Use a separate branch for each task: Give each agent its own branch so its changes can be reviewed and merged independently.
2. Scope each prompt: Tell each agent which directories, files, or modules it should work on. Assigning separate areas of the codebase reduces the chance of agents editing the same files and creating merge conflicts.
3. Share instructions across agents: Keep your project conventions, coding standards, and test commands in a shared instruction file. For example, Codex and some other agents support AGENTS.md, while Claude Code supports CLAUDE.md. You can reference shared instructions from agent-specific files so each agent follows the same standards.
4. Review changes through pull requests: Open a pull request for each agent's branch and review the changes independently. After merging a branch, update any remaining branches against the latest base branch before merging them.
5. Bring in teammates: With Northflank Cloud Harnesses, teammates can open an agent's Harness to review its output or continue its task without setting up the environment again. Team members can also see what others are working on in real time.
6. Pause finished Harnesses: Once an agent has pushed its changes and no longer needs to run, pause its Harness to stop compute usage while preserving its workspace.

Yes. Give each agent its own branch, using Git worktrees if they share one machine or separate Harnesses if you are running them in the cloud. Connect each Harness to the same repository and assign a different branch to each agent. Scope their tasks to different parts of the codebase to reduce merge conflicts.

No. Usage limits depend on the model provider and account each agent uses, not simply on the coding agent. For example, Claude Code and OpenCode using the same Anthropic account may draw from the same usage limits. Running agents in separate Harnesses does not give you additional provider quota.

It depends on your codebase, language stack, and the models available to each agent. Rather than relying only on public benchmarks, you can give two or more agents the same task and starting commit, then compare their implementations and test results on your own repository.

No. Each Harness has its own repository clone and filesystem, so agents working in separate Harnesses cannot overwrite each other's local files. Git worktrees are useful when multiple agent sessions share one Harness or local machine.

Yes. Bring Your Own Agent lets you configure a Harness for a CLI-based coding agent that is not on the default list. You install and configure the agent in the Harness, which provides the same microVM isolation, workspace persistence, and access options available to other Harnesses.

• How to run multiple Claude Code sessions in parallel
• How to run a coding agent in the cloud
• What is a coding harness?