Claude Code Projects Explained: How Multiple AI Agents Work in Parallel
Claude Code Projects used to be a folder: a place to keep files, notes, and a chat thread tied to one codebase. On September 17, 2026, Anthropic rebuilt it into something closer to a small engineering team you manage through conversation. One coordinator now splits a goal into several parallel cloud threads, each a full Claude Code session with its own branch and its own copy of the repository, working at the same time instead of one after another. Here's what actually changed and how the coordinator-and-threads model works.
Each thread in a Claude Code Project runs as an independent cloud session with its own git branch.
From Folder to Conversation
Anthropic titled its own announcement "from folder to conversation," and that's a fair summary of the shift. The old Claude Code Projects was mostly a static container — files, a knowledge base, one ongoing chat. The new version is a standing conversation where you describe a goal, and Claude acts as a coordinator: it scopes the work, splits it into pieces, launches a separate cloud thread for each piece, checks the results as they come in, and assembles a final answer once everything is done.
Each of those threads isn't a lightweight sub-task — it's a complete Claude Code cloud session, with its own checkout of the repository and its own git branch. That matters because it means two threads working on unrelated parts of a codebase genuinely run in parallel without stepping on each other's changes, the way two human contributors on separate branches would.
Scopes, Delegates, Coordinates, Reviews, Assembles
Anthropic describes the coordinator's job in five verbs: it scopes an objective, delegates pieces of it to threads, coordinates their progress, reviews what each one produces, and assembles the finished result. In practice, that looks like handing Claude a broad goal — say, reducing a checkout flow's latency — and having it decide on its own to profile several endpoints in parallel, test different optimizations in separate threads, and open pull requests for whichever changes actually help.
Shared Project Memory
Context about the goal and decisions made persists across threads, so a new thread doesn't start from zero.
Independent Branches
Every thread works on its own branch and copy of the repo, so parallel work doesn't silently overwrite itself.
Mobile Oversight
Threads keep running with a laptop closed, and progress can be checked and redirected from a phone.
Files & Artifacts Library
A shared library holds files and outputs across threads, turning the Project into a real workspace rather than a single prompt.
Cost, Merge Conflicts, and Complexity
Every thread runs as a full Claude Code cloud session on Opus at high reasoning effort by default, and every thread draws on the same subscription's usage limits. That means a Project that fans out into five or six parallel threads can burn through a Pro or Max plan's usage considerably faster than a single linear conversation would — a real cost trade-off for the speed gained. Overlapping changes across threads also still produce ordinary git merge conflicts that a developer has to resolve; Anthropic's design doesn't silently overwrite one thread's work with another's, but it doesn't make conflicts disappear either.
Bottom Line
The redesigned Claude Code Projects is a genuine architectural shift, not a rebrand — a coordinator managing several full agent sessions in parallel is a different thing than one long chat. It's best suited to a task that actually decomposes into independent pieces, like migrating callers across several repositories or profiling multiple endpoints at once. For a single, tightly sequential change, the added coordination overhead and faster usage burn may not be worth it over a normal Claude Code session.
What a Real Project Might Look Like
Consider a team retiring a deprecated v1 API endpoint across three separate repositories — an API service, a web frontend, and a mobile app. Under the old Claude Code Projects, a developer would work through each repository sequentially, one Claude Code session at a time, manually tracking which caller had already been migrated. Under the redesigned system, the same developer can describe the overall goal once, and the coordinator opens a separate thread for each repository, migrates callers in parallel, runs each project's own test suite, and opens three pull requests — one per repository — while the coordinator tracks which threads have finished and which still need attention.
The developer's job shifts from doing each migration by hand to reviewing three finished pull requests and deciding which order to merge them in, which is a meaningfully different, and for a task like this, faster way to work.
Deciding When to Actually Use Parallel Threads
Not every coding task benefits from being split into parallel threads, and part of using the redesigned Projects well is recognizing which kind of work actually decomposes cleanly. A task with a lot of interdependency — where one change fundamentally affects how another part of the code needs to be written — tends to fight against parallelization, generating merge conflicts and duplicated context that can end up costing more time than a single linear session would have. Tasks that are naturally independent, like migrating similar code across unrelated repositories or profiling several unrelated endpoints, are where the coordinator model earns its usage cost.
Given that every thread draws on the same subscription's usage limits at Opus-level effort by default, it's also worth treating "how many threads should this Project spin up" as a real cost decision, not just a technical one — a Project that could reasonably use two threads but ends up launching six isn't necessarily working faster, just spending faster.
More AI Guides, Written Clearly
Browse our full library of AI tool guides, updated regularly as models and features change.
Common Questions
What is Claude Code Projects now?
As of September 17, 2026, it's a redesigned system where a coordinator conversation splits a development goal into parallel cloud threads, each a full Claude Code session with its own branch, working at the same time and reporting back when finished.
How is this different from the old Claude Code Projects?
The previous version was largely a static container for files and a single chat thread tied to a codebase. The new version actively coordinates multiple independent working sessions instead of running one conversation at a time.
What model do the threads run on?
Every thread runs on Opus at high reasoning effort by default, while the coordinator itself runs at low effort since its job is mostly routing and assembling rather than doing the heavy work directly.
Does a thread limit I set actually get enforced?
Not strictly. Anthropic's documentation describes a requested thread limit as a preference the coordinator takes into account, not a hard cap it will never exceed.
Is Claude Code Projects available to everyone?
It launched in beta on September 17, 2026 to only a portion of Pro and Max subscribers, so availability is still limited as it rolls out further.
Can I see what each thread is doing individually?
Yes. Anthropic's overview panel groups threads by their current status, and progress can be checked either from the main project conversation or by opening an individual thread directly.
Do threads share memory with each other?
Shared project memory persists context about the overall goal and prior decisions across threads, so a new thread doesn't start from a blank slate even though it runs independently.
Does splitting work into threads always finish faster than one session?
Not necessarily. Tasks with a lot of interdependency between changes can generate merge conflicts that offset the speed gained from parallel execution, so parallel threads work best for genuinely independent pieces of work.
More from the creator
Explore two other projects from the same creator.