Ending Multi-AI Agent Collaboration Conflicts: A Practical Guide to Git Worktrees

When multiple AI coding agents share the same codebase, the most frustrating scenario is when a bug one agent just fixed gets accidentally overwritten by another. Such conflicts not only waste development time but can also introduce hard-to-track errors. The root cause is that all agents run on the same branch and in the same working directory, so they may modify the same files simultaneously. The solution has actually existed for a long time: Git worktrees.

Why Do Your AI Agents Overwrite Each Other?

According to a developer in the Reddit community r/claudeAI, running multiple agents in parallel without worktrees was simply "chaos"—agents edited the same files and duplicated work, until he switched to one worktree per agent paired with written task lists. A worktree gives each agent an independent working directory and branch while sharing the same repository history. This way, agent A's changes don't affect agent B's workspace.

Claude Code's One-Flag Worktree Support

Setting up worktrees manually is feasible, but there are now easier ways. Claude Code added the --worktree flag, which automatically runs git worktree add, creates a branch, and starts an isolated session. A single flag keeps agents from stepping on each other's toes. However, the effectiveness of isolation depends on how tight the boundaries are. According to the August 4, 2026 Claude Code patch, there was previously a bug: subagents in a worktree session could still execute destructive Git commands against the main checkout. After that patch, isolation covers file editing and Bash operations across all session types. Therefore, users relying on this feature should update as a priority.

git worktree and subagents

git worktree add is a command built into Git since version 2.5. It allows checking out multiple working directories on top of the same repository object database, with each working directory bound to an independent branch or detached HEAD. Unlike git clone, a worktree does not copy .git object data, so it saves disk space and time, and commits in any worktree are immediately visible to the others, making cross-agent comparison and merging convenient. The trade-off is that all worktrees share the same set of refs and index locks, so you need to be careful that branches cannot be checked out twice.

Subagents are auxiliary agents spawned by Claude Code within a session to execute subtasks such as searching and editing in parallel. By default, they share the parent session's permissions and execution environment. Because of this, in earlier versions, commands like git reset --hard and git checkout -- . issued by subagents would act on the main checkout directory, bypassing worktree isolation. The August 2026 patch pushed the restrictions on file editing and Bash operations down to all session types, so isolation truly covers subagents.

Worktrees Solve Conflicts, but Who Solves "Stuck" Agents?

Worktrees prevent file collisions, but they can't tell you which agent is stuck waiting for your input. When you're running five agents, the real problem is no longer corrupted files but that one agent has been waiting for you for 20 minutes while you stare at another. Anthropic's answer is Agent View, released as a research preview on May 11, 2026. It provides an interface in the Claude Code CLI that lists all sessions and their status: working, waiting for input, completed, or failed. Background sessions can keep running even without a terminal open. Note, however, that it only supports paid Claude plans and the API, and can only monitor Claude Code.

Mixed-Vendor Scenarios: Claude Squad

If your agent fleet mixes different vendors, the open-source tool Claude Squad is a viable route. It combines tmux (one terminal session per agent) with git worktree, one branch per agent, and can run Claude Code, Codex, Gemini CLI, and Aider side by side. The tool itself is free, but each agent is still billed through its respective vendor's account. It is licensed under AGPL 3.0, so enterprise legal teams may need to review it before using it on work code.

What tmux and AGPL 3.0 actually mean

tmux is a terminal multiplexer that can split a terminal window into multiple persistent sessions and panes. Claude Squad uses it to allocate an independent pseudo-terminal to each agent, allowing you to observe the output of multiple agents side by side in a single terminal interface and keeping sessions alive after an agent process crashes or an SSH connection drops. This also means its way of working is tied to Unix-like environments; Windows requires WSL to get an equivalent experience.

AGPL 3.0 is a strengthened version of the GPL: if a modified program provides services to users over a network, the modified source code must also be disclosed. For internal use, most companies merely "run" rather than "distribute" the software, which usually does not trigger the source-disclosure obligation; but once it is integrated into a product offered externally, or customized and then distributed, legal teams need to assess the viral clauses. This is also why the original article recommends that enterprises review the license first.

Review Is Also a Bottleneck: Conductor and Conductor Cloud

When ten agents produce ten pull requests waiting for your review, terminal panels are stretched thin. Conductor (developed by YC-backed Melty Labs) is a desktop app that runs Claude Code, Codex, and Cursor in their own worktrees, with a built-in diff viewer so you can review changes before merging. It is free for individuals, with a Pro version at $50 per month—that price covers only the app, and agents still run on your own plan. Main limitation: it only supports macOS on Apple Silicon, so Windows and Linux users can't use it.

Conductor Cloud runs agents in Vercel-hosted sandboxes, so they can continue even after you close your Mac. That's convenient, but your fleet now lives on someone else's machines, subject to someone else's business model.

The Vibe Kanban Lesson: Boards Disappear, Branches Don't

Vibe Kanban is an Apache 2.0-licensed open-source Kanban board launched via npx vibe-kanban. You drag tasks onto the board and hand them to agents like Claude Code, Codex, and Cursor, with each agent running in its own worktree. It gained 28,400 stars on GitHub. However, on April 10, 2026, its creator Bloop announced it was shutting down the hosted product, citing that "the vast majority of users were free" and that it could not find a sustainable business model.

The local app did not die; it continues as a community-maintained open-source project. What about users' work? It has always been kept in branches and worktrees—that is, in users' own repositories, because the board put the work there from the very beginning. This raises a key question: if the board can disappear and the branches survive, which one are you really depending on?

What usually happens after an open-source project's "hosted product shuts down"

When a commercial company shuts down its hosted service, an open-source codebase typically follows one of three paths: first, the core maintainers stop committing, and the community forks take over but at a slower pace; second, the community obtains trademark or organizational rights and shifts to foundation-style governance; third, the repository enters a long-term read-only state, forcing users to maintain it themselves. To judge whether a tool can be used long-term, look at its license (Apache 2.0 allows free forking and commercial use), whether code hosting is distributed, and whether there are active issues and release cadence.

More critical is the data boundary: if tasks, branches, and commits all live in the user's own Git repository, the board is just a view layer, and changing views does not affect the assets; conversely, if task status, review records, and agent logs exist only in the vendor's database, shutting down the product means losing that metadata. When selecting tools, you should list item by item "which data is in the local repository and which is on the vendor side."

Agent Fleets in the Cloud: Vendors Determine Scale

At its Dev Day on September 29, 2026, OpenAI announced Codex Cloud, which moves Codex sessions into OpenAI-hosted containers. Tasks continue running after you close your laptop and can be checked from your phone. Codex CLI also added an /agents view for managing parallel sessions and a /fork command for branching sessions, usable without configuration.

Google's Jules makes the ceiling explicit: the free plan allows 3 concurrent tasks, Jules in Pro allows 15, and Jules in Ultra allows 60. These tiers cannot be purchased separately from Jules; they are only available with a Google AI Pro or Ultra subscription, and the materials do not list the prices of those subscriptions. In the cloud, the vendor determines the size of your fleet, and agents run on hardware you will never see.

An Attempt at a Unified Console: Cognition Devin Desktop

In June 2026, Cognition renamed its Windsurf editor to Devin Desktop and added Agent Command Center—a Kanban-style panel for managing multiple agents in one place. It was released as a free update, with existing pricing and settings unchanged. The materials do not specify exact pricing, but the same applies to the product. It is designed specifically for... (the original text is vague here), so verify before planning a team around it.

The Agent Client Protocol (ACP) is an open standard, and any agent that supports it (Codex Cloud Agent or OpenCode) can run with Devin in the same editor. A feature called Spaces can share context, pull requests, and files across session groups. But this is still one company's editor, and you have just witnessed a board lose its hosted home. Open protocols are the part that may outlast the product.

Why the Agent Client Protocol (ACP) matters

ACP is an open communication protocol between "editors/clients" and "coding agents," similar in concept to LSP for language servers: an editor only needs to implement the protocol once to connect to any compatible agent, and agents don't need to build separate integrations for each editor. It typically defines interaction primitives such as session creation, streaming message returns, tool calls and permission requests, and file reads and writes.

The value of an open protocol lies in decoupling. When a vendor's editor or board disappears, as long as the agent still implements ACP, it can be taken over by another client, so the workflow doesn't have to be rebuilt from scratch. When evaluating a multi-agent tool, you can ask three questions: does it publish the protocol specification, is there a second implementation independent of a single vendor, and are protocol version changes backward compatible? If the answer to all three is yes, its lifecycle is more likely to outlast any one company behind it.

Where Should You Place Your Trust?

The answer is clear: Git worktrees. It is the foundation of every tool in this video, a pure Git feature that you own. When Vibe Kanban's hosted board shut down, people's work still sat safely inside it. Everything on top is a replaceable dashboard.

Specific recommendations:

• If you only use Claude Code, use the --worktree flag and Agent View, and keep Claude Code updated.
• If you mix multi-vendor agents in the terminal, check Claude Squad's license first.
• If you use an Apple Silicon Mac and are drowning in diffs, start with Conductor's free tier.
• If you want agents to keep running while your laptop sleeps, Codex Cloud or Jules can do that, provided you accept their limitations and hardware.

Whatever you choose, keep your work in branches you control. Rent the dashboard, own the branch.

One-line Summary

Multi-AI agent parallel development should use Git worktrees for isolation; dashboards are all replaceable, but the branches are yours.

Paragraph Summary

The article points out that when multiple AI coding agents share the same codebase, overwriting each other's changes is the core pain point of parallel development, rooted in shared branches and working directories. Git worktrees give each agent an independent directory and branch while sharing repository history, and are the common technical foundation of all solutions. Claude Code's --worktree flag can create isolated sessions with one command, but you need to update to the August 2026 patch to ensure subagents are also constrained by isolation. Worktrees cannot solve "agents stuck waiting for input" or "review bottlenecks," so status monitoring and review tools such as Agent View, Claude Squad, Conductor and Conductor Cloud, and Cognition Devin Desktop have emerged, while cloud solutions have their parallel scale determined by vendor pricing. The shutdown of Vibe Kanban's hosted product shows that boards and dashboards can disappear, but only work kept in your own branches and worktrees survives. The author recommends placing your trust in Git worktrees: rent the dashboard, own the branch.