--- title: "Parallel AI coding agents on a team: how to split who works on what · Cork" description: "How a team splits work across parallel AI coding agents: slice by code ownership, name shared files, one branch per agent, small tasks, and live coordination." canonical: "https://corkcli.com/blog/split-work-parallel-ai-coding-agents-team" last_updated: "2026-11-14" published: "2026-10-03" author: "Kevin Vera" --- # Parallel AI coding agents on a team: how to split who works on what How a team splits work across parallel AI coding agents: slice by code ownership, name shared files, one branch per agent, small tasks, and live coordination. By Kevin Vera · October 3, 2026 · [Guides](https://corkcli.com/blog/c/guides) · 6 min read When a team runs [parallel AI coding agents](https://corkcli.com/blog/parallel-ai-coding-agents), split the work by code area rather than by feature title: give each agent a directory or module it owns, name the shared files (types, schema, config, routes) that only one agent may change at a time, put each agent on its own branch, and keep tasks small enough to merge within a day. Then make the split visible to the agents themselves, in an instruction file they read and, ideally, in a live view of who is editing what. ## Why splitting work is harder with agents than with people Two engineers on one team usually know roughly what the other is doing: they talk at standup, they see each other's pull requests, they ask before touching a shared module. Agents do none of this. Each Claude Code, Codex or Cursor session starts with a fresh context window and knows only what is in the repo, its instruction files and its prompt. Multiply that by four people each running two or three agents and you get a dozen independent writers who have never heard of each other. Two kinds of collision follow: - **Overwrites**: two agents edit the same file in the same checkout and one loses its work. - **Semantic conflicts**: agents on separate branches change things the other depends on (a renamed function, a new required argument, a changed return type). Each branch passes its own tests; the merge does not. A good split reduces both. It cannot remove the second kind on its own, because dependencies cross directory lines. ## Rule 1: slice by ownership, not by ticket A ticket like "add discount codes" touches the API, the database schema, the checkout UI and the shared types. If two agents each take half the ticket, both will edit the types. Instead, split along the code's own seams: | Agent | Owns | May read | Must not change | |---|---|---|---| | Agent A (Ana, Claude Code) | `api/discounts/` | everything | `shared/types.ts` | | Agent B (Ben, Codex) | `web/checkout/` | everything | `shared/types.ts` | | Agent C (Ana, Cursor) | `shared/types.ts`, `db/migrations/` | everything | nothing else | One agent owns each shared file. Others propose changes to it by message or by waiting for its branch. ## Rule 2: write the split where every agent reads it Claude Code, Codex and Cursor all read `AGENTS.md` (Claude Code when no `CLAUDE.md` is present, or through an `@AGENTS.md` import). Put the ownership table there, or in a nested `AGENTS.md` inside each directory, which Codex and Cursor both support. Keep it current: a stale split is worse than none because agents trust it. Claude Code's docs recommend keeping instruction files under 200 lines, and Codex caps the combined size of its `AGENTS.md` chain at 32 KiB by default, so keep the table short and link out for detail. ## Rule 3: one branch and one working tree per agent Give each agent its own git worktree so no two agents write into the same directory: ```bash git worktree add ../app-discounts-api -b ana/discounts-api git worktree add ../app-checkout-ui -b ben/checkout-ui ``` Claude Code users can run `claude --worktree discounts-api`, which creates `.claude/worktrees/discounts-api/` on a new branch. Subagents can also be isolated with `isolation: worktree` in their frontmatter. ## Rule 4: keep tasks small and merge often The longer two branches live apart, the more they diverge. Prefer tasks an agent can finish, test and merge within hours. Merge in dependency order: the agent that owns shared types lands first, the others rebase onto it and rerun tests. If your agents spend more time rebasing than coding, your slices are too big or cut across too many seams. ## Rule 5: decide how agents ask each other for changes When Agent B needs a new field in `shared/types.ts`, it should not add it. Options, from simplest to most automated: 1. B stops and tells its human, who tells Agent C's human. 2. B writes the request to a shared file such as `REQUESTS.md` that C is told to check. 3. Agents message each other through a coordination tool that routes the message to whoever is working on that file. Whatever you choose, write it into `AGENTS.md` so every agent follows the same protocol. ## Rule 6: watch for drift during the day Plans drift: an agent fixing a bug in `api/discounts/` follows a stack trace into `web/checkout/`. Have each person glance at `git diff --stat` across worktrees before merging, and run the full test suite on the merged result, not only per branch. ## How Cork helps A written split tells agents where they should work. It cannot tell them where the other agents are working right now, or that someone just changed a function they call. Cork is the [coordination layer](https://corkcli.com/blog/coordination-layer-ai-coding-agents) for multiplayer coding agents: it keeps Claude Code, Codex and Cursor agents, on one machine or across a team's machines, from overwriting each other on one codebase, and hands each agent what the others already learned. For a team splitting work: - **Live awareness**: when an agent outside your slice changes code yours depends on, your agent hears it on its next step. - **[Write gate](https://corkcli.com/blog/write-gate)**: if an agent drifts into a file another agent is changing right now, its edit is held until it has their version. - **Agent messaging**: an agent can message the others in the repo, one agent, or whoever is working on a given function, which replaces the `REQUESTS.md` workaround. - **Landing**: `git push` becomes one step that rebases onto teammates' commits, reruns the tests and pushes. - **Team dashboard and live code graph** (cloud plans) show who is on which code. Seeing teammates' agents on other machines is the paid plan ($20 a month per 100 agent hours, pooled across the workspace). In Cork's published benchmark (12 Claude Code agents at once on one repository, hard tasks), agents with Cork used 53% fewer tokens than the same agents without it. Install with: ```bash curl -fsSL https://corkcli.com/install.sh | sh ``` ## Frequently asked questions ### How many AI coding agents should one developer run in parallel? As many as you can review. The limit is usually human attention and merge effort, not the tools. Start with two and add more when your slices stay clean. ### Should parallel agents work on separate branches? Yes. One branch and worktree per agent stops live overwrites. It does not stop semantic conflicts, so merge often and rerun tests on the combined result. ### What is the best way to split a feature across multiple agents? Split by code ownership: one agent per module or directory, with a single owner for each shared file such as types, schema or config. ### How do agents on a team know what other agents are changing? Not by default. Each session only sees its own context. You need a shared instruction file for the plan and a coordination layer for live changes. ## Sources - - - - - - - ## Related reading - [How to split a big task across several AI coding agents](https://corkcli.com/blog/split-big-task-across-multiple-ai-coding-agents): Split a large coding task across parallel AI agents: land contracts first, cut units by file ownership, pick /batch, agent teams or worktrees, land in order. - [How to coordinate AI coding agents across a team's machines](https://corkcli.com/blog/coordinate-ai-coding-agents-across-team): Coordinate AI coding agents across a team's machines: shared agent instructions, branch and PR rules, CI gates, live signals, and what built-in tools cover. - [Codex hooks and Cursor hooks: how to use them for team coordination](https://corkcli.com/blog/codex-cursor-hooks-team-coordination): How Codex and Cursor hooks work as of October 2026, where the config lives, how to block or brief an agent, and how to use hooks to coordinate a team's agents. - [Cork vs Mosaic: shared session memory, or live coordination on the code](https://corkcli.com/blog/cork-vs-mosaic): Cork vs Mosaic: Mosaic syncs AI coding sessions into shared team memory; Cork keeps parallel agents from overwriting each other. How they differ and fit. [All articles](https://corkcli.com/blog.md) · [Cork in Markdown](https://corkcli.com/index.md) · [llms.txt](https://corkcli.com/llms.txt) This page in HTML: https://corkcli.com/blog/split-work-parallel-ai-coding-agents-team