The feature entered beta on September 17 for a subset of Claude Pro and Max subscribers, according to Anthropic’s product announcement and support documentation. The Register first highlighted the commercial tension in the rollout: parallel work means more model activity at once. But “pay in parallel” is only literally true for users who choose consumption billing after their included usage runs out. Subscribers otherwise hit their plan limits and wait for them to reset.
This is also not merely the existing Claude.ai “Projects” feature with a coding option bolted on. Anthropic is using the same name for a substantially different workflow: a persistent, cloud-run coordinator conversation that creates and oversees several Claude Code sessions.
A coordinator above separate Claude Code sessions
Under the new design, a user describes an objective rather than opening and directing each coding session individually. Anthropic says the coordinator scopes the request, delegates work into threads, reviews their results, and assembles the final outcome. Threads can be monitored and redirected from the project chat while their work continues in the cloud after the user leaves the desktop app or browser.
For a routine one-repository bug fix, that architecture is probably excessive. The practical use case is work with natural boundaries: moving API clients off a deprecated endpoint, making coordinated changes across web, mobile, and backend repositories, or dividing a performance investigation into profiling, code changes, tests, and documentation.
Anthropic’s example is a checkout-latency project: the service can profile endpoints, try optimizations, and open pull requests in parallel. That represents a change in orchestration, not a claim that the underlying model has suddenly become better at performance engineering. Projects reduce the human work of setting up separate jobs and collecting their output. Developers remain responsible for determining whether the proposed changes are correct and whether the resulting pull requests fit together.
Each coding thread is a full Claude Code cloud session with its own copy of the repository and its own branch. That isolation is sensible: parallel agents editing the same working directory would otherwise overwrite one another’s changes. It also means the project behaves more like a queue of AI-authored pull requests than a single agent making one coherent set of edits.
Anthropic explicitly says that when two threads touch the same code, the conflict will appear as a Git merge conflict, the same way it would between ordinary pull requests. The coordinator can identify and organize work, but it does not eliminate the fundamental integration problem. Teams that ask several agents to refactor a shared authentication module, database schema, or build pipeline should expect the human review and merge stage to become the critical path.
Shared memory helps continuity, but Git remains the record
The new Projects beta adds shared memory and a library of user-provided and Claude-produced files. Anthropic says each thread can draw from project context and add back decisions, results, and relevant details over time. In theory, that should reduce the familiar agentic-coding problem where each fresh session must be re-taught the repository conventions, architectural decisions, and current priorities.
The important limitation is that shared memory is not a substitute for engineering controls. A remembered statement such as “the billing service must not be changed before Friday” may inform the coordinator’s choices, but it does not enforce a branch rule, a required reviewer, a protected deployment gate, or a passing test suite. For Windows developers using GitHub, Azure DevOps, GitLab, or a self-hosted Git server, existing branch protections and CI checks remain the durable safeguards.
Projects also creates a new review burden. A developer who previously reviewed one agent’s diff now may receive several parallel diffs based on overlapping assumptions. The apparent time savings at the task-execution stage can be lost if the work was divided poorly or if no one defines ownership boundaries before dispatching it.
A more defensible early workflow is to give threads non-overlapping responsibilities. One might map and document a codebase, another update a client library, another write focused tests, and a fourth review migration risks without editing production code. A project can then make the dependencies explicit before it begins creating branches.
Claude Code already offered ways to run work concurrently, including subagents, background work, agent-oriented views, and agent teams. Projects places a supervisory layer above those capabilities: a thread can itself use subagents and workflows where necessary. That nesting is useful for large assignments, but it also makes the cost and review surface less intuitive. A request that sounds like “upgrade this service” may create a coordinator session, several worker sessions, and additional delegated tasks beneath them.
Subscription limits are the feature’s real boundary
Anthropic is unusually direct on the central operational caveat: each project thread is a full Claude Code session, and several running at once use plan capacity faster. The company’s support documentation confirms that Claude and Claude Code share usage limits for Pro and Max subscribers across the web, desktop, and coding tool.
That makes Projects less like free parallelism and more like an interface for spending a finite amount of capacity faster. A Pro or Max customer who opens several long-running cloud threads can use the allowance that would otherwise support an extended interactive coding session, research conversation, or desktop task.
Users who hit those included limits have choices: wait for a reset, move to a higher plan tier where available, or enable usage credits. Anthropic says usage credits can shift a paid subscriber to pay-as-you-go billing at standard API rates after the included limit is reached, but that change requires explicit user action. The feature does not automatically turn a capped Pro subscription into an uncapped bill.
That distinction matters for IT managers and developers who use an API key inside Claude Code. Anthropic’s support guidance says an ANTHROPIC_API_KEY environment variable makes Claude Code authenticate against that API account instead of the user’s subscription, with usage billed to the associated Console or cloud-provider account. A local Windows development environment with an inherited API key can therefore produce pay-as-you-go charges even if the user expects their Pro or Max allowance to be used.
Before experimenting with Projects, administrators should establish whether developers are using subscription authentication or API credentials, who owns the billed account, and whether Console auto-reload is enabled. Those checks are more important with parallel cloud sessions because a single user can initiate several consumption streams through one project interface.
The beta is consumer-first, not an enterprise rollout
The availability details narrow the immediate audience. The redesigned Projects experience is rolling out to select Pro and Max users who use Claude Code; those users see Projects in the Claude Code web surface and the Code portion of the Claude desktop app. Anthropic says the beta will expand to more eligible Pro and Max customers over the coming week, with chat, Cowork, Team, and Enterprise availability following later.
Existing Projects have not been converted across the board. Anthropic’s help documentation says the older self-contained workspaces and knowledge bases continue functioning as they do today, while the company stages upgrades for Pro and Max users as the new experience reaches chat and Cowork. The initial beta eligibility also excludes some users with existing web or desktop projects.
That naming overlap will cause confusion. In the older model, a Project was a container for files, instructions, chat history, and knowledge. In the new Claude Code beta, a Project is closer to an operating queue: one conversation directs cloud threads, accumulates memory, and produces artifacts over time. Organizations should not assume that an existing knowledge-base project will instantly gain autonomous multi-session coding behavior.
The enterprise delay is consequential. The feature is aimed squarely at work that spans repositories, long-running migrations, documentation, and support material—exactly the categories where companies are likeliest to need access controls, auditability, source-code handling rules, and predictable spend. Anthropic has announced the eventual expansion, but it has not yet provided a date for Team and Enterprise support or described enterprise-specific governance for the Projects beta.
Treat Projects as a pull-request generator
The responsible way to evaluate the new beta is as a faster generator and coordinator of proposed work, not as an autonomous software-delivery system. Start with an isolated repository or a low-risk migration, require each thread to open a separate pull request, keep CI mandatory, and give only one thread authority over any shared high-conflict area such as schema definitions, dependency locks, authentication, or deployment configuration.
Projects can reduce idle time for developers who already know how to partition work and review branches. It cannot resolve conflicts it helped create, validate business requirements absent from the prompt, or restore subscription capacity spent by an over-ambitious fan-out. For now, its clearest payoff is operational: Claude Code users can run several bounded tasks from one place. Its clearest cost is equally operational: those tasks now consume a limited AI budget at the same time.