Claude Code turns Projects into the conductor of cloud sessions

Anthropic is deploying Projects in Claude Code: a conversation can now distribute a task across multiple parallel cloud sessions, share their context, and continue the work even with the computer closed.

One conversation can now distribute a migration across several repositories, run tests, open pull requests, and monitor their results. With the redesigned Projects experience, Claude Code no longer merely groups chats and files: it coordinates multiple sessions working in parallel toward a shared objective.

The experience is available in beta to a subset of Pro and Max subscribers. The rollout begins with people who already use Claude Code cloud sessions and have not created a project in Claude’s previous Projects interface.

A project takes the form of an ongoing conversation with Claude. The user describes the desired outcome, adds the relevant repositories, documents, and instructions, then lets a coordinator divide the work into separate threads.

Each thread is a complete Claude Code session running in the cloud. It has its own context window, isolated environment, repository copy, and, when software development is involved, its own Git branch. Multiple threads can operate simultaneously without directly sharing the same workspace.

The coordinator sits above these sessions. It analyzes the request, decides which work to delegate, creates new threads or reuses existing ones, then consolidates their status reports in the main conversation. Users can remain in this overview or open a specific thread to inspect its actions and provide additional instructions.

The structure is primarily intended for work that cannot be completed in a single response. A migration might require changes to an API, several client applications, and their documentation. Claude can create one thread for each repository, run tests separately, open the corresponding pull requests, and then indicate the order in which they should be merged.

Anthropic also gives the example of an optimization effort distributed across several components. One thread can establish baseline measurements, others can test different changes, and another can verify the results. The project then acts as a coordination layer between sessions that previously had to be launched and monitored manually.

The system is not limited to programming. Contracts, reports, support tickets, and other documents can be added to a project. Claude can assign their analysis to multiple threads, produce summaries, and save the resulting files in the project’s library.

Threads continue running on Anthropic’s infrastructure after the user closes their computer. Progress can be monitored through the web interface, desktop app, or a phone. That persistence already existed for individual cloud sessions, but Projects adds task distribution and result consolidation.

Context is not fully duplicated across every participant. Each thread maintains its own history, while the coordinator primarily receives progress reports. Information that needs to remain available over time is stored in a shared project memory.

This memory can retain an architectural decision, a schedule change, an internal convention, or the reason an option was abandoned. New threads can then use that information without requiring the user to repeat it in every request.

Repositories, files, instructions, skills, connectors, and plugins configured at the project level also provide a shared foundation. A persistent instruction can specify which test command to run, how status reports should be formatted, or which parts of the product require human approval.

Memory does not amount to an exhaustive history. The main conversation is reconstructed from recent messages, the most relevant threads, and stored project information. Long sessions are progressively compacted. An important decision should therefore be recorded explicitly in project memory rather than left inside an older exchange.

The interface groups threads according to their status. Some may be waiting for the user, while others are still working, ready for review, or associated with a pull request. Separate views collect generated files, pull requests, and automated routines.

When a GitHub repository is connected, a thread can modify code on its branch, run tests, and open a pull request. It can then monitor continuous integration checks, address certain review comments, and report when the change is ready.

Branch isolation limits direct interference but does not eliminate conflicts. If two threads modify the same section of code, merging their work creates the same difficulties as reconciling two human contributions. The coordinator can organize the work, but it cannot automatically make contradictory changes compatible.

A thread can also use subagents or iterative workflows to divide its own assignment. The structure therefore has several levels: the main conversation coordinates the threads, while each thread may further split the work it has been given. This can accelerate complex projects, but it also increases the number of active sessions.

Every session counts against the user’s Claude Code plan limits. Anthropic warns that a project can consume available usage more quickly than a traditional conversation because each thread is a complete session. Monitoring a pull request also uses resources whenever a test result or new review comment reactivates the thread.

By default, new projects use Opus with high effort for worker threads and lower effort for the coordinator. Users can change these settings. Anthropic does not publish a fixed limit on simultaneous threads, but the documentation imposes a maximum of 200 new threads per day across all projects.

An instruction asking Claude to stay below a particular number of threads is treated as a preference rather than an enforced technical limit. Users who need strict control over consumption will therefore have to monitor project activity rather than rely solely on a sentence placed in the conversation.

If the plan’s usage limit is reached, the affected threads pause. They are expected to resume automatically after the quota resets. Additional usage credits are consumed only if the account holder has previously