Anthropic redesigned Claude Code Projects on September 17, 2026, launching a beta version where a coordinator directs parallel cloud threads that work on different pieces of a larger development goal. The shift moves developers from manually managing separate coding sessions toward a more integrated project-level orchestration model.
What changed: Instead of dividing work, juggling handoffs, and stitching results back together manually, developers now describe what needs to get done and Claude manages the work across parallel threads. This represents a meaningful architectural change in how Claude Code handles multi-session development.
Quick Take
Projects are available in beta for select Claude Pro and Max subscribers who use cloud sessions and have no existing projects on the web or desktop, with access expanding over the coming week. The redesigned feature uses a coordinator that directs multiple parallel cloud threads. Each thread is a full Claude Code session. Shared project memory connects the work. The approach differs fundamentally from subagents (delegated workers in one session) and Agent Teams (experimental, currently disabled by default). Projects represent a new orchestration layer specifically for ongoing, multi-session development work.
Claude Code Projects: What’s New
The redesigned Projects experience turns a project from a static folder into an ongoing conversation where Claude acts as coordinator. When you start a project, you select a goal as well as the repository or context, and Claude suggests work it can pick up right away.
The architecture differs from the previous Projects model. The old project was a folder with some files plus one chat. The new one is a single ongoing conversation where Claude acts as coordinator. This enables a fundamentally different workflow: instead of users managing multiple isolated sessions, Claude coordinates them automatically.
You can configure the project’s cloud environment, connectors, plugins, instructions, and model. Users can monitor and guide progress in the main project chat, or dive into each individual thread to examine and steer the details. The coordinator receives summaries from threads rather than tracking every step they take.
Key takeaway: Projects coordinate multiple full Claude Code sessions instead of simply creating multiple prompts or delegating side tasks.
How Claude Code Runs Multiple AI Agents
Projects follow a clear workflow when you provide a development goal.
1. Give Claude a project goal
You begin with a broader development objective rather than breaking work into predetermined tasks. Examples from Anthropic’s announcement illustrate realistic scenarios:
Configure a project and set a goal to reduce your app’s checkout p75 latency. Then ask Claude to profile each endpoint, test optimizations, and open PRs in parallel threads.
Another example: Connect your API, web, and mobile repos and set a goal to retire a deprecated v1 endpoint. Claude creates a thread per repo to migrate the callers, run the tests, open PRs, and then tells you which ones need to merge first.
These are not predetermined task sets. They reflect how developers naturally describe work.
2. Claude scopes and delegates the work
A user describes the desired outcome; the coordinator scopes the job, assigns pieces to worker threads, reviews their output, and returns a consolidated result. The coordinator decides which work should become a separate thread based on the goal provided.
In a launch thread on X, Anthropic compares the interaction to briefing a chief-of-staff: users can hand Claude several things at once, in any order, while Claude decides whether each request belongs in a new or existing thread.
3. Claude creates parallel threads
Each thread is a full Claude Code cloud session running on its own branch and its own copy of the repository. Threads work simultaneously. The number of threads created depends on the work scope, not a fixed allocation.
Every thread runs Opus at high effort by default, and a thread limit you ask for is only a preference. This means developers don’t manually configure model settings per thread; the system defaults to high-capability execution.
4. Threads work on the project
Each thread operates independently on its assigned work. With repositories connected, a thread opens pull requests and runs your tests; with documents, it reads them and drafts. A thread opens a pull request when the work calls for one, then watches that pull request with auto-fix enabled.
Threads can also subdivide their own work. Each thread can further split its delegated work into pieces using subagents, loops, and workflows when needed so large assignments finish faster.
5. Claude reviews and assembles results
Claude reviews their results and coordinates the final output. You can steer progress throughout, even from your phone, and it keeps working after you step away from your computer.
Key takeaway: Shared project memory lets work accumulate across threads.
What Are Claude Code Threads?
A Claude Code Project thread is a full Claude Code cloud session that works on part of a larger project under the direction of the project’s coordinator.
Each thread is a full cloud session with its own branch and repository copy. Threads run in parallel, report back to the conversation, and keep going after you close your laptop.
Unlike subagents (which exist within a single parent session), each thread in a Project is a complete, independent Claude Code environment. Because those workers run remotely, they can continue after the user’s laptop closes. This persistent, remote execution enables Projects to handle work spanning multiple days or weeks.
How Claude Code Shared Memory Works
Shared project memory allows every thread to contribute context and retrieve it later. This is distinct from individual thread context. Rather than repeating project requirements in every conversation, the coordinator maintains a unified project context that all threads access.
Claude can retain details such as a delayed release date, the reason an export was removed, or the team that owns a billing service, reducing the need to paste the same background into each conversation.
Shared Memory also learns an individual developer’s working style and communication preferences. Behaviors such as how often to report progress, whether to automatically spin up new threads or check in first, and the level of detail in reports are recorded and flexibly adjusted according to the developer’s instructions.
A project library stores uploaded files and artifacts produced by Claude, giving later threads access to earlier outputs. This creates a searchable knowledge base for the entire project rather than scattering work across separate sessions.
Claude Code Projects vs Subagents vs Agent Teams
Claude Code offers five approaches to parallel work. Projects represent one of these, not the only option.
| Approach | Coordinator Model | Parallel Work | Cloud Execution | Best Suited For |
| Subagents | Parent session | Yes | Context-dependent | Side tasks within one session |
| Agent View | User | Yes | Background sessions | Independent tasks you manage |
| Agent Teams | Lead agent | Yes | Context-dependent | Coordinated teams (experimental, disabled by default) |
| Dynamic Workflows | Script | Yes | Context-dependent | Large repeatable workflows |
| Projects | Project coordinator | Yes | Cloud | Long-running, multi-session development |
Each approach is designed for different scenarios. Subagents work well when a parent task needs side work handled in isolation. Agent View suits developers who prefer managing multiple independent sessions themselves. Agent Teams (currently experimental) are designed for coordinated multi-agent scenarios. Dynamic Workflows excel for scripted, repeatable large-scale operations. Projects address the need for ongoing project-level orchestration with persistent context.
Key takeaway: Parallel agents do not eliminate the need for Git isolation, code review, or merge-conflict handling.
Claude Code Projects vs Multiple Coding Sessions
The value of Projects is not simply having multiple sessions. The key difference is the coordination layer.
Traditionally, developers opening several Claude Code sessions face three challenges:
Manual task assignment. The developer decides which task goes into which session.
Context management. Each session must be briefed separately, with repeated context.
Monitoring and merging. The developer tracks progress and manually combines results.
Projects address each:
A coordinator (Claude) assigns work to threads based on the project goal.
Shared memory eliminates context repetition across threads.
The coordinator tracks progress and helps assemble results.
The underlying technical difference is architectural. The redesigned architecture gives each project two layers: a coordinator that receives instructions and worker threads that execute them. This two-layer design is what distinguishes Projects from simply running multiple sessions in parallel.
How Branch Isolation and Merge Conflicts Work
Under the hood, each thread is a Claude Code cloud session working on its own branch and copy of the repo. The coordinator keeps work organized, but if any threads work on the same code, the overlap is resolved as a merge conflict just like any other PR.
This is important: multi-agent workflows do not eliminate Git conflicts. They require thoughtful task partitioning to minimize overlap.
Good parallel task splits isolate work:
Thread 1: API endpoint updates
Thread 2: Frontend components
Thread 3: Test coverage
Thread 4: Documentation
Potentially conflicting splits create merge complexity:
Multiple threads modifying the same core service file simultaneously
Overlapping changes to configuration files
Shared state modifications without coordination
The lesson: Projects reduce manual coordination overhead but still require sensible task boundaries. Developers should partition work by architectural boundaries, file ownership, or feature separation rather than arbitrarily dividing work across threads.
What Can You Use Claude Code Projects For
Real-world applications where Projects show value:
Large feature development
Frontend, backend, tests, and documentation can potentially be separated into independent threads. One thread handles the API layer, another the UI components, another the test suite, and another the documentation. Work proceeds in parallel rather than sequentially.
API migrations
Connect your API, web, and mobile repos and set a goal to retire a deprecated v1 endpoint. Claude creates a thread per repo to migrate the callers, run the tests, open PRs, and then tells you which ones need to merge first. This workflow is particularly suited to Projects because each repository represents a natural thread boundary.
Performance optimization
Set a goal to reduce your app’s checkout p75 latency. Then ask Claude to profile each endpoint, test optimizations, and open PRs in parallel threads. One thread profiles, another tests optimizations, another handles database changes, all in parallel.
Long-running development projects
Projects are designed for long-running or agentic workflows: work that takes longer than one reply and has more than one part. Work continues after you close your laptop. This makes Projects suitable for multi-day or multi-week development efforts.
Claude Code Projects: Limitations You Should Know
Understanding current constraints helps developers use Projects effectively.
Cloud dependency
Project threads currently run in the cloud. Anthropic says users can check project-specific usage and select the models and effort levels used by the coordinator and worker threads. Anthropic has signaled that it will soon offer “running on your machine” support, which will allow the use of local tools and internal network environments. Local execution is not yet available at launch.
Usage consumption
Running several full Claude Code sessions at once can also reach usage limits faster. Each thread runs Opus at high effort by default, and a thread limit you ask for is only a preference. There is no fixed thread cap below 200 a day. Developers should monitor usage carefully when running multiple parallel threads.
Merge conflicts remain
Multi-agent work does not eliminate Git conflicts. Poorly partitioned tasks increase merge complexity. Developers still review and validate all generated code.
Task decomposition matters
Work must be divided sensibly for parallel execution to add value. Tasks with heavy interdependencies or shared file ownership may not benefit from parallelization.
Human oversight is essential
Claude checks in and follows through on work. Developers still need to review generated code, tests, PRs, and architectural decisions. Projects reduce coordination overhead but do not replace human engineering judgment.
Who Should Use Claude Code Projects
Best suited for developers
Who regularly handle multi-step development tasks spanning several days or require coordination across multiple repositories or components.
Best suited for engineering teams
Who work across repositories, components, or features and would benefit from orchestrated parallel work rather than sequential task management.
Best suited for startups
Where small teams need to coordinate multiple development tasks without hiring additional engineers.
Less suitable for simple tasks
If a task can be completed cleanly in one Claude Code session, Projects may add unnecessary complexity. Use Projects when work naturally divides into multiple parallel subtasks.
Claude Code Multi-Agent Workflow Example
Here’s a complete practical scenario based on Anthropic’s examples:
Goal: Retire a deprecated API endpoint.
Workflow:
- Developer describes the goal to the project coordinator: “Migrate all callers from the v1 checkout endpoint to v2 across our API, web, and mobile repositories.”
- Claude identifies the work: API repository cleanup, web application updates, mobile app updates, integration tests, and deployment documentation.
- Threads are created per repository:
- Thread 1: API repository removes v1 endpoint, adds deprecation warnings to v1.1, ensures v2 is stable
- Thread 2: Web application updates all v1 calls to v2, runs web tests
- Thread 3: Mobile app updates all v1 calls to v2, runs mobile tests
- Each thread runs in parallel in the cloud, opening PRs as work completes.
- The coordinator reviews dependencies: “Thread 1 must merge before Threads 2 and 3.”
- Developer reviews the PRs and merge order, then merges changes.
The entire process runs with Claude coordinating the work rather than the developer manually tracking three separate sessions.
How Claude Code Projects Change AI Coding Workflows
The shift represents a progression in how developers interact with AI coding tools.
Traditional single-session workflow:
Developer → Claude Code session → Task → Result
Multiple-session workflow (manual coordination):
Developer → Multiple sessions → Manual task assignment → Manual result coordination → Results
Projects workflow (automatic coordination):
Developer → Project goal → Coordinator → Parallel threads → Shared context → Results
The difference matters. In the manual coordination model, the developer still orchestrates everything. In the Projects model, Claude handles scoping, delegation, monitoring, and result assembly. The developer steers overall direction rather than managing individual sessions.
According to Anthropic’s announcement, developers can now tell Claude what they want accomplished rather than manually organizing every individual session required to accomplish it. This shifts cognitive load from task management to outcome definition.
Conclusion
Anthropic’s September 17, 2026 redesign of Claude Code Projects introduces a new way to manage multi-session development work through a coordinator that directs parallel cloud threads. Projects shift development from manual session orchestration toward automatic coordination around project goals.
The key differences from other parallel-work approaches are clear. Subagents work within a single session. Agent Teams remain experimental. Agent View puts users in control. Dynamic Workflows use scripts. Projects introduce project-level orchestration with persistent context across independent cloud sessions.
Current limitations matter: cloud-only execution, increased token consumption, and the persistent need for thoughtful task partitioning and human code review. These are not failures but realistic constraints of current architecture.Projects work best for multi-step development efforts that naturally partition into independent tasks and benefit from weeks of persistent project context. For simple tasks or highly interdependent work, traditional single-session Claude Code remains simpler.
As of September 2026, Projects represent the latest step in Claude Code’s evolution from autocomplete toward coordinated multi-agent development. The feature is in beta for Pro and Max subscribers, with broader rollout coming to all plans and expanded tool support planned for the future.
Frequently Asked Questions
What is Claude Code Projects?
A redesigned Projects feature in Claude Code where a coordinator directs parallel cloud threads that work on different pieces of a larger development goal, with shared memory and project context connecting the work.
Can Claude Code run multiple AI agents?
Claude Code has five ways to work on several tasks at once: subagents, agent view, agent teams, dynamic workflows, and projects. Projects represent one of these approaches.
What are Claude Code threads?
Each thread is a full Claude Code cloud session running on its own branch and its own copy of the repository. Threads are the worker units in a Project.
How do Claude Code Projects differ from subagents?
Subagents are delegated workers inside one conversation that perform side tasks and return results to the parent. Projects create separate full Claude Code sessions (threads) that work in parallel with shared memory and a coordinator managing the overall goal.
How do Claude Code Projects differ from Agent Teams?
Agent Teams are an experimental feature (currently disabled by default) where a lead agent coordinates workers and agents message each other directly. Projects use a coordinator that directs threads with summarized reporting rather than direct inter-agent messaging.
Can multiple Claude Code threads work in parallel?
Yes. Threads run in parallel, report back to the conversation, and keep going after you close your laptop.
Do Claude Code Project threads run locally?
No. Project threads currently run in the cloud. Local execution support will come in future updates.
Do multiple Claude Code agents use more tokens?
Running several sessions or subagents at once multiplies token usage. Multiple parallel threads increase usage faster than a single session.
Who currently has access to Claude Code Projects?
Beta access began September 17, 2026, for a select group of Claude Pro and Max subscribers who use cloud sessions in Claude Code and have no existing projects on the web or desktop. Access will widen over the coming week to more Claude Code users on those plans, with the updated projects reaching the rest of Claude and the Team and Enterprise plans afterward.