Anthropic today launched Claude Code Projects, a new way for developers using its hit "vibe coding" harness Claude Code to stay organized as they build something — an app, website, or other development job — that will require ongoing, persistent development work.
The new Claude Code Projects is itself a Claude-powered AI coordination agent that is, in Anthropic's words, always on, and can take the developer's natural language inputs about their specific continuous job and sub-divide them into parallel threads so the work can be done faster and more efficiently. Claude Code Projects then automatically coordinates those threads over time, maintaining a shared memory of the project as the development continues and it evolves.
For those of us who have used Claude Code across multiple sessions to continue work on an ongoing project, it's a major game changer, as previously, ongoing development work required the user to maintain their own separate, external record of the project status and feed it back into Claude Code in a new session, or to have Claude Code look up a compacted version of the last conversation about that project, re-investigate the latest status of it, and try to reconstruct where the last session left off and what the user was asking for in the current session.
For enterprises, it makes a whole lot of sense: their digital storefront, website, content management system, procurement platform, or other business application rarely has a discrete endpoint. These systems are continually updated, patched, extended and adapted over years.
Rather than having a developer spin up a fresh Claude Code session and re-establish the context, decisions and current status of that ongoing work each time a change is needed, Anthropic is proposing that Claude Code Projects can preserve shared memory and project context across that effort, coordinate new work against what has already happened, and make it easier to pick up where previous threads left off.
However, the naming convention is a bit confusing: Anthropic already has a separate feature called Claude Projects, first introduced in June 2024, which is a general-purpose Claude workspace for grouping chats, files, instructions and project knowledge. The basic Claude Projects can contain multiple chats and preserve shared knowledge across them, but each chat remains a separate conversation; context from one chat is not automatically carried into another unless it is captured in Project knowledge or memory
The new Claude Code Projects experience announced September 17 has a similar name but targets a different problem: coordinating agentic software development across multiple Claude Code sessions. The beta is initially available to select Claude Pro and Max subscribers using cloud sessions in Claude Code who do not already have Projects on the web or desktop.
Anthropic says access will expand to more Claude Code users on those plans over the coming week, with the redesigned experience eventually reaching more of Claude, including Team and Enterprise. Existing Claude Projects on Pro and Max continue operating as they do today during that rollout.
The shift matters because coding agents are increasingly capable of handling work that extends beyond a single prompt or pull request.
OpenAI, GitHub and Google have all moved toward asynchronous, parallel and longer-running agent workflows.
Anthropic’s bet with Claude Code Projects is that developers increasingly need not just another coding session, but a persistent coordination layer above several sessions that remembers the larger objective and routes work among them.
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.
From individual sessions to a coordinated development effort
Developers using multiple coding agents often have to divide a larger feature into discrete jobs, establish context for each session and eventually reconcile the results themselves. Claude Code Projects is designed to move much of that coordination into Claude.
A Claude Code Project maintains the broader goal and context while creating individual execution threads for different pieces of the work. Anthropic’s final launch post describes the architecture as “threads do the work, Claude directs it.” Each Project has a coordinator sitting above those worker threads.
Developers can continue talking to that coordinator as requirements evolve rather than waiting for one task to finish before issuing another. Claude can route a new request into an existing thread or create an additional one, while users can open a particular thread when they need to inspect or steer the underlying work.
Anthropic also exposes an Overview panel that shows items requiring the user’s attention. In its X launch thread, the company says developers can steer individual threads from a phone, allowing a human operator to intervene without keeping every Claude Code session open on a workstation.
That changes the primary unit of interaction from an isolated coding task to a longer-running body of work.
For example, Anthropic says a developer could create a Claude Code Project whose goal is reducing an application’s checkout p75 latency. Claude could then create parallel threads to profile endpoints, test optimizations and open pull requests.
In another example, a team could connect API, web and mobile repositories and ask Claude to retire a deprecated v1 endpoint. Separate threads could migrate callers and test each repository while the coordinator tracks dependencies and tells the developer which changes need to merge first.
Each worker thread is itself a Claude Code cloud session operating on its own branch and copy of the repository. Threads can further split assignments using subagents, loops and workflows. Coordination does not eliminate ordinary software-development conflicts, however: if multiple threads modify overlapping code, Anthropic says those changes can still produce conventional merge conflicts that are resolved like other pull requests.
Shared memory helps keep a project's state updated to all the agents working on it
Parallel execution alone is no longer unusual among coding agents. The more consequential part of Claude Code Projects may be the state that persists above individual sessions.
Every worker thread contributes to and draws from shared Project memory. Over a longer effort, Claude can retain decisions such as a release date moving, a feature being dropped or instructions about who needs to be consulted before modifying a particular service. Anthropic says users can also adjust how frequently Claude checks in, how often it creates new threads and how detailed its updates should be.
Claude Code Projects also include a library that collects files supplied by users and artifacts created by Claude, giving later work a persistent pool of material to draw from. The Project can be configured with its own cloud environment, connectors, plugins, instructions and model settings.
This is related to, but distinct from, the knowledge-base concept in Claude Projects. Claude Projects use uploaded knowledge and instructions to provide context for conversations. Claude Code Projects add a shared operational memory across worker threads so that decisions made while one part of an initiative is underway can affect later work elsewhere in the development effort.
For enterprise engineering teams, that distinction could matter as much as the ability to spawn more agents. The challenge is increasingly not simply whether an agent can fix a bug or implement a feature, but how teams preserve requirements, dependencies, prior decisions and human oversight while several agents work concurrently.
The distinction can therefore be summarized simply:
Claude Projects help Claude remember the context you gave it.
Claude Code Projects are designed to help Claude remember and coordinate the work it is doing.
The competitive race is shifting from coding agents to agent managers
Anthropic is not alone in recognizing the orchestration problem. OpenAI, GitHub and Google have all moved beyond the model of a developer working with one coding agent in one linear conversation.
The increasingly important competitive layer is how developers delegate a portfolio of work, preserve context, monitor concurrent agents and incorporate new requirements without becoming the human scheduler between them.
OpenAI is probably the closest direct comparison. Its Codex app is designed as a multi-agent workspace where developers can run several coding agents in parallel, isolate their changes and supervise longer-running work. The overlap with Claude Code Projects is substantial: both products normalize parallel agents rather than treating concurrency as an advanced workflow.
The notable difference in Anthropic’s published design is the explicit coordinator above the worker threads. The developer continues talking to one Claude Code Project conversation, and Claude itself can decide whether a new instruction should enter an existing stream or create another. Anthropic also explicitly describes shared Project memory spanning those worker threads.
So the differentiator is not that Claude Code Projects uniquely supports parallel or long-running coding agents. Competitors already do both. The more specific idea is that a persistent conversational coordinator becomes the top-level interface for supervising those sessions.
GitHub approaches the problem from another direction: its strength is the repository and development lifecycle itself. GitHub’s agent tooling supports multiple isolated sessions and can tie them closely to branches, issues, pull requests and CI workflows. That gives GitHub an advantage wherever the GitHub repository is already the natural control plane for development work.
Anthropic is instead trying to put a conversational coordination layer above individual repositories and sessions. Its own deprecated-endpoint example spans API, web and mobile repositories while a single Claude Code Project coordinator tracks the larger migration and merge order.
Google’s Jules presents a third model. Jules supports asynchronous coding work and repository-level memory, giving later tasks access to preferences and guidance accumulated on that repository.
Anthropic’s Claude Code Projects takes persistence to the level of the broader initiative: several worker threads can contribute to one shared memory and remain under one coordinator conversation.
The products are converging on many of the same primitives — parallel execution, isolated environments, asynchronous work, memory and human intervention — but they place the control plane in different places.
OpenAI emphasizes a multi-agent coding workspace. GitHub emphasizes repository-native execution and supervision. Google’s Jules emphasizes persistent, asynchronous work around a repository. Claude Code Projects makes one, long-running, ongoing conversation about the development initiative the coordination layer.
Cloud execution today, local execution later
Claude Code Project worker threads currently run in the cloud. That allows them to keep working after a developer closes a laptop or goes offline, but Anthropic’s launch thread makes an important limitation explicit: those cloud threads cannot yet access files or tools on the developer’s computer or systems on the internal network.
Anthropic says local support is coming “very soon,” which would allow Claude Code Projects to run alongside local code and tools and behind an organization’s network.
That distinction will matter for enterprises whose development environments depend on private packages, internal services, restricted networks or local tooling that cannot be exposed to a cloud execution environment.
Anthropic says developers can nevertheless steer ongoing work from a phone while those worker sessions execute remotely. That turns mobile into a supervision surface rather than requiring the development machine itself to remain online.
Anthropic is not introducing standalone pricing for Claude Code Projects. Projects draw from the subscriber’s existing Claude usage, and each worker thread is a full Claude Code session. Because a Project can run several threads at once, Anthropic warns that it can reach usage limits faster. Users can inspect Project-specific usage and select model and effort levels for both the coordinator and worker threads.
The broader competition is therefore moving past the question of whether an AI agent can write code. OpenAI, GitHub, Google and Anthropic can all put agents to work asynchronously and in parallel.
The harder problem is becoming who coordinates those agents, what remembers their accumulated decisions and where developers go to manage a body of work that may outlive any individual session.
With Claude Code Projects, Anthropic’s answer is one continuing coordinator conversation: developers keep briefing it as the initiative evolves, shared memory carries decisions forward, and a changing collection of Claude Code worker threads handles the execution underneath it.
That is distinct from the existing Claude Projects product, which remains the more general workspace for organizing chats, files, instructions and knowledge — at least for now.