Anthropic is overhauling one of the most consequential pieces of its developer tooling. The company has relaunched Projects inside Claude Code, the agentic coding assistant that has become a centerpiece of its pitch to professional software teams. The new version is designed for a problem that has crept up on the industry almost by accident: what happens when a single developer is suddenly supervising not one AI agent, but a dozen of them.
The revamped Projects feature lets users run multiple agents under the same roof, bound together by a shared memory, a common set of goals, and a pooled library of files and artifacts. It is a structural change to how Claude Code organizes work — less a chat window, more a small autonomous engineering department with a shared brain.
From one thread to a coordinated team
At the heart of the redesign is the concept of threads. Each project can host several threads running different tasks in parallel, with a so-called coordinator directing traffic between them. The architecture is deliberately familiar to anyone who has managed a repository: every thread is a separate Claude Code cloud session, working on its own branch and its own copy of the repo.
Under the hood, each thread is a Claude Code cloud session working on its own branch and copy of the repo.
That branch-per-agent model matters because it solves the messiest practical problem in multi-agent coding: collisions. When two threads touch the same code, the overlap is not silently overwritten or lost — it is resolved as a merge conflict, handled much like any other pull request. Threads can also split their delegated work further, spinning up sub-tasks of their own, which means a single instruction from a developer can fan out into a tree of parallel activity before anything lands back in the main branch.
An always-on conversation that remembers
The framing from venturebeat.com captures the other half of the pitch: Projects is an "always-on" conversation that remembers and delegates your long-running development work. That is a meaningful shift from the session-based model that has defined most AI coding tools to date. Instead of re-explaining context every time a developer returns to the terminal, the project itself persists — its memory, its goals and its artifacts survive between sessions.
For long-running work — a migration, a refactor, a slow-burning feature branch — that persistence is arguably more valuable than raw model capability. Much of the friction in agentic development has come not from agents being unable to code, but from them being unable to remember what they were doing, or why.
How different outlets frame it
Coverage of the relaunch has diverged in emphasis, reflecting genuine ambiguity about what the product actually is.
- The Verge leads with orchestration and comparison, placing Projects alongside Grok Bot and other tools that manage groups of AI agents — framing it as part of a fast-forming category rather than a standalone Anthropic feature.
- venturebeat.com emphasizes continuity and memory, positioning Projects as an always-on workspace for long-horizon developer work rather than a burst of parallel compute.
- unite.ai focuses on the redesign itself, describing it as a re-architecture built to coordinate agent threads — a technical story about plumbing.
- wersm.com takes the most anthropomorphic angle, describing Claude Code as turning AI agents into a coordinated team, a framing that speaks to enterprise buyers imagining virtual engineering pods.
Underneath those different lenses is the same underlying claim: that individual agents are no longer the interesting unit of work. The team is.
Why this is happening now
Claude Code launched as a research preview in early 2025 and quickly became one of Anthropic's most commercially significant products, giving the company a direct foothold with working developers rather than only API customers. But as agentic tools matured, a bottleneck emerged. Developers found themselves acting as middle managers — copy-pasting context, restarting stalled sessions, and manually reconciling what several agents had done.
Coordinator-and-thread patterns are the industry's answer. The bet is that orchestration, not model intelligence, is the next competitive frontier, and that whoever owns the layer where agents are scheduled, remembered and reconciled will own the developer's daily workflow.
The implications
The branch-and-merge model is a smart piece of design diplomacy. By mapping agent coordination onto Git concepts that engineers already trust, Anthropic avoids asking teams to adopt a new mental model — the merge conflict becomes the safety valve, and the pull request remains the moment of human judgment.
It also raises harder questions. If a project can hold shared memory across many threads, what exactly is remembered, for how long, and who can see it? Running multiple agents against separate copies of a repository multiplies cloud compute, which multiplies cost. And the coordinator itself becomes a single point of failure: if it misdirects work, the failure scales with every thread beneath it.
For now, the significance is structural. Projects signals that the era of the lone AI coding assistant is ending, and the era of managing fleets of them — with all the organizational, financial and accountability problems that implies — has begun.
