Anthropic just turned Claude Code Projects from a shared folder into a fleet manager. The redesigned feature, launched in beta on September 17, 2026, lets a single coordinator agent break an engineering goal into pieces and hand them to multiple Claude Code sessions running in parallel. Each thread works on its own branch, opens its own PRs, and draws from a shared memory that persists across days.
The shift is structural. Old Projects were containers: a knowledge base, some instructions, a set of files. New Projects are orchestrators. You describe a goal like "retire the v1 API endpoint across all three repos," and Claude decides how to split the work, assigns threads, reviews results, and assembles the output. Claude Code Projects has moved from a passive knowledge store to an active multi-agent system, and the implications for your token budget are immediate.
Each parallel thread counts as a full Claude Code session, so usage scales linearly with every agent you spawn.
What exactly did Anthropic ship on September 17?
The core unit is the "thread." Anthropic's announcement describes each thread as a full Claude Code cloud session with its own branch and copy of the repository. A coordinator agent sits above the threads, scoping requests, delegating work, and reviewing outputs. When two threads touch the same code, the overlap lands as a standard merge conflict, resolved the same way any PR conflict would be.
Threads can also spawn their own subagents, loops, and workflows to break large assignments into smaller pieces. The architecture is nested: a project contains a coordinator, the coordinator directs threads, and each thread can further decompose its work. The Verge reported that the design resembles tools like Grok Bot that manage groups of AI agents, with the coordinator keeping work organized across parallel sessions.
Anthropic also added shared memory across threads. Decisions made in one thread, like a changed release date or the reason a feature was dropped, carry forward to others. A library collects files and artifacts produced during the project, so later threads can reference earlier work without you re-pasting context. The coordinator also learns your communication style: how often to check in, how frequently to start new threads, how detailed to make updates.
The beta opened to select Pro and Max subscribers who use Claude Code cloud sessions and have no existing projects on web or desktop. Anthropic says access will expand to more Pro and Max users over the coming week, with Team, Enterprise, and eventually regular Claude chats and Cowork following after. Existing projects on Pro and Max plans keep working as they do today and will be upgraded as the rollout expands.
How does the coordinator model work under the hood?
The mechanics are straightforward if you have used Git. Each thread gets its own branch and repository copy. The coordinator assigns work to threads, monitors progress, and reviews outputs. You can interact with individual threads to steer details, or stay in the main project chat to monitor at a higher level. Anthropic's framing is that you brief Claude "the way you'd brief a chief of staff," and it routes work accordingly.
When threads produce overlapping changes to the same code, the system handles it as a merge conflict. The New Stack noted that this keeps work separate but does not prevent two threads from modifying the same file. The conflict resolution follows standard pull request mechanics, which means your CI pipeline, review process, and branch protections still apply. That is a design choice worth pausing on: Anthropic did not build a custom conflict-resolution system. It leaned on Git, which is the right call for compatibility but means you need solid CI to catch problems the coordinator misses.
The shared memory is the more novel piece. Every thread adds to and draws from a project-level memory store. If a thread learns that the billing service requires sign-off from a specific person, that fact propagates to future threads. Anthropic says this reduces the need for complex prompt engineering, since context accumulates organically. The memory persists across days and weeks, which positions Projects for long-running work rather than single-shot coding tasks.
The library feature complements memory by storing both user-added files and Claude-produced artifacts. A new thread starting work on a project can pull relevant materials from the library without asking you to upload them again. This matters for repos with extensive documentation or design specs that would otherwise need to be re-supplied with each session.
Will parallel agents drain your plan before lunch?
This is where the excitement meets the invoice. Anthropic explicitly warns that Projects can reach usage limits faster because each thread counts as a full Claude Code session. Run four parallel threads and you are consuming four sessions worth of tokens simultaneously. Run six and you are at six times the usage of a single session, with no economies of scale.
The math is simple and unforgiving. One thread is your baseline. Two threads doubles usage. Six threads sextuples it. The relationship is perfectly linear because there is no sharing or deduplication happening at the session level. Each thread is an independent Claude Code instance with its own context window, its own API calls, and its own token budget.
For Pro subscribers on a fixed plan, this is the constraint that will define how you use Projects. A coordinator that spawns four threads to parallelize a migration could exhaust your daily allocation in a single work session. Max subscribers have more headroom but face the same proportional scaling. Anthropic lets you configure the model and effort level for both the coordinator and worker threads, which gives you a throttle, but the fundamental math does not change: more parallelism means more tokens.
The practical implication is that Projects rewards thoughtful task decomposition. If you let the coordinator spawn threads indiscriminately, you will burn through your plan on low-value work. If you scope goals tightly and let the coordinator parallelize only the parts that genuinely benefit from concurrent execution, the cost-to-value ratio improves. This is an orchestration skill that most teams do not have yet.
When can your team actually use this?
The rollout is phased. Beta access started September 17 for select Pro and Max subscribers using Claude Code cloud sessions, with the caveat that users with existing projects on web or desktop are excluded for now. Anthropic plans to expand access to more Pro and Max users over the coming week, then open Team and Enterprise plans, followed by Cowork and regular Claude chats. Local tool support, which would let threads run on your machine alongside your existing tools and code behind your private network, is coming "very soon" but has no firm date.
The chart above shows the approximate rollout sequence based on Anthropic's stated timeline. The later phases lack specific dates, so the durations are estimates derived from phrases like "coming week" and "after that." If you are on Team or Enterprise, you are likely looking at weeks, not days, before access opens. If you need local execution rather than cloud sessions, the wait is indefinite.
Can an LLM coordinator actually manage your codebase?
This is the question that determines whether Projects is a productivity tool or a novelty, and the honest answer is that nobody has production data yet. The beta is days old. But the design raises specific concerns that builders should think through now.
First, coordinator quality determines everything. If the coordinator misjudges how to split work across threads, you get parallel sessions producing overlapping or contradictory changes. The merge conflict fallback handles the Git mechanics, but reviewing six conflicting PRs from an agent that misunderstood the task is worse than doing the work sequentially. Research on coding agent harnesses suggests that the orchestration layer around the model matters at least as much as the model itself. Anthropic is now building that harness, and its quality will make or break Projects.
Second, the failure rate for enterprise agent pilots looms over any multi-agent launch. Our coverage of the 89 percent figure highlighted that orchestration and reliability, not model capability, are the top reasons agent deployments stall. A coordinator that works in Anthropic's demos but breaks on a messy production codebase with interdependent services, partial test coverage, and undocumented dependencies would fit that pattern perfectly.
Third, the cloud-only constraint limits real-world utility in the short term. Teams that need agents to access private networks, internal tools, or local databases cannot use Projects as shipped. The local execution promise is real, but until it ships, Projects is a tool for repos you can mirror to Anthropic's cloud.
What should builders do right now?
If you have Pro or Max access and no existing projects, try it on a contained task. Give the coordinator a goal with clear boundaries: "add input validation to these five endpoints and open PRs for each." Monitor how it splits the work, how many tokens it consumes, and whether the PRs are reviewable. That will tell you more about the coordinator's judgment than any demo.
If you are on Team or Enterprise, prepare your repos. Make sure CI is solid, branch protections are in place, and your review process can handle multiple concurrent PRs from the same project. The merge conflict model means your team will be reviewing agent-generated PRs, possibly several at once, and your review pipeline needs to handle that volume without becoming a bottleneck.
For everyone, the cost question is the one to model now. If you currently spend X tokens per day on Claude Code, figure out what 3X or 4X looks like against your plan. Projects adds to your current usage rather than replacing it. The teams that get value from this feature will be the ones who learn to scope parallel work tightly enough that the multiplier buys them speed rather than waste.
The coordinator is the product
The model inside Claude Code is already good at writing code. What Anthropic is testing now is whether an LLM can manage other LLMs effectively. The threads, the memory, the library, the merge conflict handling: all of that is infrastructure. The coordinator is the product. If it decomposes tasks well, allocates threads sensibly, and catches its own mistakes before opening PRs, Projects becomes a genuine force multiplier. If it does not, you have just built an expensive way to generate six bad pull requests at once. The beta will tell us which, but only if builders push it hard enough to find the edge cases.
Sources
- Anthropic, "Projects redesigned: from folder to conversation"
- The Verge, "Claude Code relaunches Projects to manage multiple AI agents in the cloud"
- The New Stack, "Anthropic's new Claude Code feature could drain your plan before lunch"
