Claude Code Projects Gains a Coordinator to Run Parallel AI Agents Without Collisions
一个项目五个 AI 同时干活,Claude Code 怎么让它们不互相打架
Five AIs modifying code at the same time in one project, who guarantees they don't fight each other? This question used to belong only to hobbyists who hacked together multi-agent systems; after November 15, 2026, it becomes a reality every Claude Code user faces. Anthropic redesigned Claude Code's Projects: a project has a coordinator and several parallel working threads, each opening an independent branch and an independent copy in the cloud, and conflicts are handled according to ordinary PR merge conflicts. Multi-agent parallelism has officially transformed from a community workaround to a product form. This step changes the competitive dimension of coding agents.
This change is not about a feature, but a division of labor
To understand this update, first understand how people used Claude Code for multi-tasking in the past. Models got stronger, tokens got cheaper, and auto mode and cloud sessions let agents run longer; so many natural users started running several sessions at once, one changing interfaces, one writing tests, one refactoring modules. The tool itself didn't handle this, parallelism was entirely a user behavior.
Anthropic's team member Boris stated the motivation plainly on Hacker News: multi-Claude play is becoming common, but the experience hasn't kept up; switching between multiple sessions is a disaster of attention. People were forced to be schedulers, watching each session's progress, remembering who was doing which part, and manually stitching results back together.
At the same time, another real need exists: some work requires single-threaded deep focus, back-and-forth discussion, and doesn't want to be interrupted by other tasks. Not all work needs parallelization; single-threaded concentration still matters. New design must serve both groups.
So the refactoring direction of Projects is clear: take scheduling out of human hands. The official description changes from folders to conversations. Previously you had to break up work yourself, hand off, and stitch results; now you describe what to do, and Claude manages the work. Scope definition, task delegation, parallel coordination, result review, and assembly of final artifacts are all handled by the system.
In other words, the core of this release is not a new button; it's that Claude Code changes from a single-session tool to a multi-worker engineering organization. You are no longer an operator, but more like the manager giving goals to an engineering team.
Who does the work, who directs
The new Projects structure has only two layers: threads do the work, the coordinator directs. You select the goal and the corresponding repository or context in the project; the coordinator first lists what it considers immediately actionable work, then routes specific tasks to newly created or existing threads.
Each thread is a complete Claude Code cloud session, not an accessory to a main session, but a full working environment with its own branch and its own repository copy. This design guarantees the foundation for parallel safety: threads are physically isolated, and no one steps on another's files.
The coordinator, in official terms, needs to be briefed like a chief of staff. It receives the goal, decides how many lines to split into, who gets which, and in what order. During the process, it actively checks in and follows up, bubbling up issues that need your decision to the main thread, and you can jump into any thread from the main thread at any time to see details or change direction.
If a thread finds its assigned task too large, it can further split it down, using sub-agents, loops, and workflows to break large tasks into small pieces. This means a project can actually grow into a three-layer work tree: coordinator at the top, threads in the middle, sub-agents at the bottom.
This layering is not novel; anyone who has done multi-agent orchestration will recognize it as the classic orchestrator-worker structure. The real difference is that it appears for the first time as an official product form, with configuration, memory, permissions, and interface all packaged, no need to assemble yourself. Each layer is responsible only to its superior layer, with clear responsibility boundaries.
If it gets messed up, treat it as a merge conflict
The biggest fear of parallel code modification is messing up: two threads modified the same function, whose version wins in the end. Anthropic's answer is crisp: conflicts are not eliminated, but institutionalized. If multiple threads touch the same code, the overlapping part is resolved as an ordinary PR merge conflict, exactly the way you handle human colleagues' conflicts daily.
This choice is restrained and clever. It doesn't invent a new conflict protocol, but directly reuses software engineering's most mature mechanism. Each thread's work eventually becomes a commit on a branch and a PR waiting to merge; when conflicts surface, the resolution path is already familiar diff and review.
Threads can also automatically close the engineering loop: after connecting a repository, threads open PRs, run your tests, and tell you which PRs need merging first. The official example is retiring a deprecated interface: connect API, web, and mobile three repositories into the project, set a goal, each repository opens a thread to migrate callers, run tests, open PRs, and finally the coordinator aggregates the merge order.
This isolation model's physical basis, local developers have long experienced with git worktree. The concept of one independent working directory per thread, a manual version roughly looks like this:
git worktree add ../proj-thread-auth feature/auth
git worktree add ../proj-thread-api feature/api
git worktree add ../proj-thread-test feature/tests
git worktree list
The pain point of manual play is exactly what official aims to eliminate: worktree only gives you isolated file systems, but not the person to split work, track progress, and order merges. Projects adds these three things; this is the leap from tool to organization. The older the protocol, the lower the mental cost, the more familiar the troubleshooting path.
Memory and materials begin to accumulate across sessions
In the single-session era, memory strategy relied on prompt engineering: you had to feed context again each time. Projects introduces a layer of shared memory: each thread both writes and reads, and project-level facts accumulate over time.
Official examples are daily: it remembers the release date moved to Friday, remembers why the export feature was cut, remembers who must be notified before touching billing service. These scatters of project knowledge used to be spread across chat logs and documents; now they become long-term project assets.
Along with memory comes a library. Files you add to the project and artifacts Claude produces during work are collected in this library, and new tasks can build directly on past results instead of starting from zero.
Communication style is customizable. You can ask it to adjust reporting frequency, eagerness to open new threads, and detail level of each update. Memory plus adjustable working style makes the coordinator increasingly like a familiar colleague, not an amnesiac temp worker.
This layer is easy to underestimate. Parallel capability solves the speed problem; shared memory solves the continuity problem, and continuity is exactly the scarce thing in long-cycle engineering. A worker who remembers last week's decisions is worth far more than one who needs background re-explained every time. More importantly, this memory is shared across threads; any lesson one thread learns is immediately available to others, so knowledge in the project only appreciates and never evaporates.
Two real costs: quota and cloud
Parallelism doesn't come without a bill. Each thread is a complete Claude Code session; a project running several threads concurrently consumes quota several times faster than a single session. Official also states projects will hit usage limits sooner; the remedy is to choose model and compute tiers for coordinator and worker threads separately.
Coordination itself also costs money, but the numbers aren't bad. Boris revealed on HN that A/B testing and evaluation show the coordinator's token overhead is less than 10% compared to running sessions directly. Spending about 10% extra to free attention is a good deal for heavy parallel users.
The second constraint is where it runs. All threads currently run in the cloud, automatically checking out the relevant repository, no need to specify. But that also means your local toolchain, private network environment, and un-pushed code are not connected for now. Official promises a version that runs locally, with your local tools and network, but it's not available today.
Community feedback concentrates here: some complain that connecting a local project requires too many permissions, some wonder why the feature is cloud-first, and some find there is no entry in the Claude Code CLI. These voices show the official solution is still a distance from heavy engineering sites; today it suits cloud-standardized repository workflows. For teams that require fully offline or compliance-mandated private networking, they can only wait. Anthropic's priority is clear: polish the cloud-standardized scenario first, then tackle local environment's harder problems. This order almost exactly mirrors the path CI cloud services took.
Compare with your own multi-agent team
Official solution is not the only game. The HN comment section has many DIY builders. Some keep ten sub-orchestrators alive, each with twenty workers, using GitHub issues for task assignment and worktree plus PRs to avoid collisions, claiming it runs smoothly. Others wrote dedicated scheduling tools for the same purpose.
| Dimension | Official Projects coordination | Community DIY setup | Single-thread session |
|---|---|---|---|
| Coordinator | Built-in coordinator for splitting and follow-up | You are the scheduler or keep another scheduling agent | None |
| Isolation | Independent branch and cloud copy per thread | worktree plus manual branch management | Naturally conflict-free |
| Conflict handling | Treated as normal PR merge conflict | Same PR dependency, but the process is self-assembled | Not involved |
| Memory | Project-level shared memory automatically accumulates | Must be built, mostly by re-feeding context | Invalid after session ends |
| Run location | Cloud only for now | Local and cloud in any combination | Both local and cloud |
| Onboarding cost | Zero setup, out of the box | Need to build scheduling and conventions | Zero |
Putting the three columns side by side, the official solution's value is not in principle, the principle has long been familiar to the community. What it truly adds is experience and continuity: no need to maintain scheduling conventions yourself, memory accumulates automatically, and you can monitor progress from your phone.
But some commenters also point out the ceiling: how far this system can automate ultimately depends on the coordinator's decision quality. Whether task splitting is correct, whether issues bubble up timely, whether merge order is reasonable are all model capability problems, not interface problems. No matter how beautiful the orchestrator, if the judgment is wrong, the work is wasted.
Who can use it now
The rollout scope is clear. The new Projects becomes available today in beta to some Claude Pro and Max subscribers, with the condition of using Claude Code's cloud sessions and having no existing projects on web or desktop. Those not covered in the same subscription tier can join a waitlist.
In terms of pace, the next week will continue to expand to more users in these two tiers; Team and Enterprise plans are later. Accounts with old projects remain unchanged; official will upgrade when the feature extends to conversation and collaboration scenarios.
The real weight of this news isn't in the feature itself, but in the direction it marks. When the largest coding agent vendor makes multi-worker parallelism a default product form, it indicates single-session interaction can no longer hold real engineering. Over the next year, competition focus will probably no longer be how smart an individual agent is, but whose orchestration layer better leads a team.
For those not yet on the list, the only thing worth doing now is to think clearly about which tasks in your project are naturally parallel and which must be serial. When the entrance opens to you, showing up with a pre-classified task list is much more effective than improvising. There's also a detail worth remembering from the official demo: you can monitor progress and approve issues from your phone, and the coordinator compresses even the scenarios that required sitting at a computer. Existing users also don't need to rush; old projects won't be force-migrated, the two versions coexist for a while, and it's fine to switch after the upgrade path matures. The standard for whether to jump in immediately is simple: if you're already running more than three parallel sessions, the coordinator immediately becomes a necessity; if you're still in single-session mode, it doesn't hurt to prepare a task list before entering.