How to run multiple Claude Code agents on one project

Why one session is not enough

One Claude Code session is one agent with one context window. On a real project that single agent ends up holding the frontend, the backend, the tests and every decision at once. Its context fills up, it loses track of earlier choices, and it can only do one thing at a time. Splitting the work across several sessions gives each agent a smaller job and a cleaner context, and lets independent parts run at the same time.

The hard part is not starting more sessions. It is keeping them from overwriting each other and from forgetting what was decided.

Option 1: by hand, with terminals and git worktrees

Claude Code runs in a terminal, so the simplest way to get several agents is several terminals.

1. One working copy per agent. If two sessions edit the same checkout, they edit the same files. A git worktree gives each agent its own folder and branch from the same repository:

   git worktree add ../myapp-frontend -b frontend
   git worktree add ../myapp-backend -b backend

2. Start one session in each folder. Open a terminal in each worktree and run claude. Each session now has its own context and its own branch.
3. Write the shared rules down once. Claude Code reads a CLAUDE.md file in the project at the start of each session. Put the stack, the conventions and the decisions every agent must follow there, so you do not repeat them in every chat.
4. Merge by hand. When a branch is done, you review the diff, run the tests and merge it. You are the one who keeps the parts consistent.

Claude Code also has subagents: helpers that one session starts for a focused job, each with its own context, which report a result back to the main conversation. They are good for research or a self-contained change. They are not a standing team: they do not keep a role across sessions, and the main session still holds the plan.

This setup works and costs nothing extra. Its limits show up as the project grows: you carry every decision between terminals yourself, nothing is remembered between sessions except what you write into files, and you have to check each terminal to know what is happening.

Five rules that make parallel agents work

Whichever way you run them, these are the rules we follow when agents build Korvenium's own products, this site included.

1. One owner per file. Never let two agents write the same file at the same time. Every task says which files belong to that agent, in a line like YOUR FILES: builder.html, builder.css.
2. Self-contained briefs. An agent does not see another agent's chat. The brief has to carry what it needs: the files already read, the cause already found and what "done" means. Otherwise each agent re-reads the whole project.
3. Contract first. When the frontend and the backend change together, write the contract (endpoint, input, output, errors) before either starts, and put the same text in both briefs.
4. Two or three parts, not ten. Each extra part adds a merge and a chance of overlap. Split by area of ownership, not by size.
5. Proof, then a human. "Done" means the build and the tests ran and the result is written down. A person reviews and approves before anything is pushed.

Option 2: with OBA

OBA (One Base for Agents) is a Windows desktop app from Korvenium where a team of AI coding agents on Claude Code, Codex or Antigravity CLI splits a task, writes the code, reviews and tests it in your own project folder, and a human approves the result. It runs the setup above for you:

• A house per project. Each project is a house with its own folder and its own team, for example a leader, a frontend developer, a backend developer and a tester. Each agent is its own Claude Code (or Codex, or Antigravity CLI) session working in that folder.
• The leader splits the work. You give the task to the house leader. The leader decides which part belongs to whom, writes a brief for each one with its own file list, and hands the parts out; parts that do not wait on each other run at the same time. When an agent finishes, its report comes back to the leader, who puts the parts together and checks the result.
• Shared memory that lasts. Decisions, rules and project notes live in one shared memory. Notes link to each other and stay between sessions, so agents do not start from zero and you do not paste the same context into every chat.
• A board instead of a pile of terminals. Every task, its status and its proof show on the board, and you watch the agents work in the village square. When an agent needs a decision, the question waits on the board for you.
• You approve the push. Agents commit; sending changes to GitHub asks you first, unless you turn that off in the settings.
• A roadmap that runs on its own. Write the steps into the project's roadmap file and the village works through them one item at a time per house, each with a written "done" check.

Agents in one house share the same project folder, so the file-ownership rule above is what keeps them apart, not separate copies. Your code, chats and memory notes stay on your computer; the agents reach the AI service behind the CLI you choose, the same way that CLI does on its own, and that subscription or API key is yours.

A real example: this post

This post was made in OBA, in the house that runs korvenium.com. The task was one sentence: add visible prices, the current version and update dates to the OBA pages, add a blog, and write this guide. The house leader, Alex, kept the blog and the site files that link to it, and handed the price and version lines on the product pages to the frontend developer, Max, with a brief that listed exactly which four pages were his. The two parts ran at the same time and never touched the same file. Alex then ran the site's SEO check and the work went to a human for approval before it was pushed.

What you need to start

• Windows 10 or 11, 64-bit, and at least one coding CLI: Claude Code, Codex or Antigravity CLI, with its own account or an API key. Git for Windows for the git features.
• OBA 1.5.8 is the current version. The free plan has 1 house and 2 agents, enough for a leader and one developer. Pro removes the house and agent limits and adds GitHub: $12 / month or $120 / year at the launch price until 31 December 2026. Korvenium Lifetime is $400 one-time for the first 100 buyers. See plans and download.