Anthropic launches new Claude Code Projects with parallel AI agents and shared memory

Anthropic has redesigned Claude Code Projects around a coordinator that can divide a larger objective into multiple parallel Claude Code sessions, direct their work and combine the resulting outputs.

The new Projects experience, released in beta on September 17, changes the unit of work from a collection of manually managed sessions into a persistent project in which Claude can scope an objective, create threads, delegate tasks, review results and coordinate dependencies.

Each thread is a full Claude Code cloud session operating on its own branch and copy of a repository, rather than a lightweight subtask inside one model conversation.

Projects also introduce shared memory across threads and a common library for files and artifacts, allowing later work to reuse project decisions and context accumulated during earlier sessions.

Initial access is limited: the redesigned Projects are starting with selected Claude Pro and Max subscribers using cloud sessions in Claude Code, before Anthropic expands availability.

··········

PROJECTS NOW ADD AN ORCHESTRATION LAYER ABOVE INDIVIDUAL CLAUDE CODE SESSIONS.

The coordinator manages the project-level objective while separate threads perform delegated work in parallel.

A user starts with a goal and the relevant repository or other context rather than manually creating and coordinating every Claude Code session required to complete the work.

The project coordinator can scope the request, identify work that can proceed independently, route tasks to new or existing threads, monitor their outputs and assemble the results.

Users can configure the project's cloud environment, connectors, plugins, instructions and model, while individual threads remain independently inspectable and steerable.

The architecture therefore separates coordination from execution: the main project conversation maintains the overall objective and directs work, while worker threads perform the underlying coding or document tasks.

A simplified workflow is project goal → coordinator → parallel Claude Code threads → tests and outputs → coordinator review → integrated result

Anthropic gives the example of reducing an application's checkout p75 latency: Claude can assign different endpoint investigations to separate threads, test optimizations and open pull requests in parallel.

Another example spans API, web and mobile repositories during the retirement of a deprecated endpoint, with separate threads migrating callers and testing each repository before the coordinator identifies the required merge order.

........

Component	Role	Technical behavior
Project coordinator	Orchestration	Scopes work, delegates tasks and reviews results
Thread	Execution	Runs as a separate Claude Code cloud session
Repository environment	Code isolation	Each thread works on its own branch and repo copy
Subagents and workflows	Further decomposition	A thread can divide delegated work again
Main project chat	Human control	User monitors and redirects project-level work
Pull requests and tests	Delivery	Threads can test changes and open PRs

........

Parallel execution does not eliminate ordinary software integration problems.

If two threads modify overlapping code, Anthropic says the collision is handled as a merge conflict, in the same way that conflicting pull requests from human developers must be reconciled.

The system therefore increases the amount of work that can proceed concurrently without providing automatic immunity from dependencies, conflicting edits or incorrect task decomposition.

··········

SHARED MEMORY TURNS PROJECT CONTEXT INTO A PERSISTENT WORKING RESOURCE.

Threads can contribute to and retrieve project-level memory instead of requiring the user to reconstruct relevant context in every new session.

Anthropic positions Projects for long-running and agentic work that extends beyond a single response and contains multiple related tasks.

Every thread can now add information to shared project memory and draw information from it later.

That memory can contain operational decisions such as a changed release date, the reason a feature was removed or an instruction about who must be consulted before modifying a particular service.

Claude can also retain aspects of the user's working and communication preferences within the project, including how frequently it should report progress, create additional threads or provide detailed updates.

A separate project library collects files supplied by the user and artifacts generated by Claude, giving subsequent threads another persistent source of project context.

This changes the practical coordination burden in multi-session work.

Without shared state, parallel agents may repeatedly require the same repository conventions, architectural decisions and project constraints to be supplied manually; persistent project context allows those decisions to become inputs to later tasks.

The mechanism still requires careful context management because persistence can propagate an incorrect assumption as efficiently as a correct one.

A mistaken architectural decision stored in shared memory can influence multiple subsequent threads, making review of important project-level assumptions more consequential as the number of delegated tasks grows.

··········

PARALLEL FULL SESSIONS INCREASE CAPABILITY AND RESOURCE CONSUMPTION TOGETHER.

Projects can accelerate independent work, but each worker remains a complete Claude Code session with its own model usage and execution environment.

Anthropic explicitly warns that Projects can reach usage limits faster because several threads can run simultaneously and each thread is a full Claude Code session.

Users can inspect project-specific usage and select model and effort levels for both the coordinator and worker threads, creating a direct operational trade-off between concurrency, model capability and available usage.

The redesigned Projects currently execute their threads in Anthropic's cloud.

Anthropic says support for running threads on the user's machine alongside local tools, local code and resources behind the user's network is coming, but this is a roadmap statement rather than a currently available capability.

........

Constraint	Current position	Practical consequence
Availability	Beta rollout	Not all Claude users can access redesigned Projects yet
Initial plans	Selected Pro and Max users	Access begins with a restricted paid-user group
Worker execution	Claude Code cloud sessions	Work currently runs in cloud environments
Parallelism	Several threads can run simultaneously	Independent tasks can proceed concurrently
Usage	Every thread consumes a full session	Parallel projects may reach usage limits faster
Code overlap	Standard merge conflicts can occur	Parallel edits still require integration handling
Local execution	Announced as coming soon	Current cloud model remains a limitation for some environments

........

The initial rollout specifically targets selected Pro and Max subscribers who use cloud sessions in Claude Code and do not already have Projects on web or desktop.

Anthropic says access will expand to more Claude Code users on those plans over the following week, with broader updated Projects support across Claude and Team and Enterprise plans planned later.

Existing Projects are not immediately converted for every user; Anthropic says current Pro and Max Projects will continue operating as they do today until the broader rollout reaches them.

··········

CLAUDE CODE PROJECTS MOVE AGENTIC CODING FROM SESSION MANAGEMENT TO WORK MANAGEMENT.

The redesign is most useful when a goal contains independent workstreams that can genuinely proceed in parallel and share durable project context.

The technical change is larger than adding a multi-session interface because Anthropic is placing an orchestration layer above complete Claude Code environments and giving those environments persistent shared state.

For workloads such as multi-repository migrations, independent endpoint optimization, test generation or other decomposable engineering tasks, the coordinator can remove part of the manual work previously required to divide tasks, maintain context and reconcile progress across sessions.

The architecture offers less advantage when a task is intrinsically sequential, when multiple agents would repeatedly modify the same code or when project decisions require continuous human judgment before downstream work can safely proceed.

It also changes the cost of delegation: launching another thread can increase throughput, but it launches another full Claude Code session rather than providing effectively free background parallelism.

The practical boundary is therefore determined by task decomposability, shared-context quality, integration risk and available Claude usage. Projects can coordinate substantially more work when those conditions are favorable, while tightly coupled codebases and poorly defined project state can turn additional parallelism into additional review and merge work.

··········

FOLLOW US FOR MORE.

·····

DATA STUDIOS

·····

[datastudios.org]