On September 17, 2026, Anthropic announced a complete overhaul of "Projects," the core feature of its developer-focused agentic tool Claude Code. What was once a static folder for storing instructions and reference materials has been redefined as a conversational coordinator that autonomously directs multiple agents once given a goal. Clusters of parallel cloud sessions—each with its own branch and repository—now spring into action, automatically driving forward changes, tests, and pull requests across multiple repositories. Having shifted from single-prompt responses to multi-agent collaboration, how does the new Projects change the practice of autonomous development?
From Folder to Conversation: Claude Code's Leap Into Agentic Coding
In the previous version of Claude, Projects functioned as a static context folder that bundled together reference files created by users—collections of prompts, design documents, API specifications, and the like. Breaking work into multiple tasks, handing off context between sessions, and manually integrating generated code and review results were all responsibilities that fell to the developer.
The redesigned Projects flips this premise on its head. When a developer specifies a high-level goal and the relevant repositories, Claude itself behaves like a "chief of staff," overseeing everything from scoping requirements and breaking down tasks, to delegating work to parallel workers, verifying outputs, and assembling the final deliverables.
Developers can get a bird's-eye view of overall progress from the main project chat, while also being able to step directly into individual work threads at any time to revise instructions or perform additional verification. The feature also supports checking progress and issuing instructions from a smartphone, allowing developers to keep a cloud-based development team running in the background without being tied to a desktop.
Parallel Threads and Cloud Sessions: Automatic Arbitration of Multi-Repo Changes and Git Merge Conflicts
Underpinning the execution engine of the new Projects are "Threads," which run concurrently in the background. Each thread operates as a complete Claude Code cloud session, assigned an independent copy of the target repository and its own branch. Rather than consuming local resources, a virtual development machine spins up in the cloud for each one.
The power of this parallel processing becomes evident in tasks like profiling multiple endpoints or executing large-scale cross-cutting refactors. For example, given a goal such as "reduce p75 latency in the checkout process," the coordinator simultaneously assigns multiple threads to profile each bottleneck endpoint, optimize code, run performance tests, and create pull requests.
Even more powerful is its ability to coordinate changes across multiple repositories. Given a goal like deprecating an obsolete v1 endpoint, Projects will simultaneously connect to the API repository, the web frontend repository, and the mobile app repository. It spins up dedicated threads for each repository to migrate calling code and run unit tests in parallel, and even lays out the dependency order in which pull requests should be merged.
Even when multiple threads modify the same codebase, mechanisms are built in to prevent breakage. Conflicting code changes are automatically detected and arbitrated as git merge conflicts, just as they would be in an ordinary pull request. In addition, each thread autonomously advances its assigned work, deploying sub-agents, iteration loops, and additional workflows internally to break down complex tasks.
Shared Memory and Library: A Context-Persistence Mechanism That Eliminates Prompt Redundancy
When multiple threads collaborate over an extended period, the scattering of context and redundancy in prompts becomes a major obstacle. Having to re-enter preconditions and coding conventions every time a session ends was a factor that undermined the practicality of agentic development.
To resolve this issue, the new Projects introduces "Shared Memory," which is referenced across all threads. Design decisions made throughout the project, along with operational rules—such as "the release date has changed" or "who to check with before modifying a particular service"—are automatically remembered and accumulated. This means that even when a new thread is spun up, the latest preconditions are immediately carried over, eliminating the need to repeatedly engineer complex prompts.
In addition to project-specific rules, Shared Memory also learns an individual developer's working style and communication preferences. Behaviors such as how often to report progress, whether to automatically spin up new threads or check in first, and the level of detail in reports are recorded and flexibly adjusted according to the developer's instructions.
Furthermore, a "Library" has been introduced to centrally collect reference files added within a project, as well as artifacts generated by Claude itself—such as design diagrams, logs, and implementation plans. Past work outputs and context are automatically organized and made searchable, functioning as a knowledge base for the entire project.
Usage Limits and Model/Effort Routing: Controls to Counter Rising Token Consumption
An architecture in which multiple autonomous agents simultaneously write code and run tests in the cloud will naturally accelerate the pace of computational resource consumption. Because each thread runs as a full-fledged Claude Code session, accounts reach their usage limits far faster than they would with conventional interactive chat.
Anthropic has introduced control mechanisms to address this practical operational challenge. In addition to a tracking feature that visualizes usage across an entire project, the company has added settings that let users independently select the model and thinking-effort level (effort) for the overarching "coordinator chat" and for the individual "worker threads" that carry out the work.
This allows for flexible resource allocation—for instance, assigning a top-tier model and high effort to the coordinator role, which requires precise situational awareness and task decomposition, while assigning a standard model and lower effort to workers handling routine test execution or single-feature refactors. It is an engineering approach designed to maintain task-completion quality while curbing excessive token consumption.
Rollout Schedule and Future Roadmap: Cloud First, Then Local
For its rollout plan, Anthropic has adopted a cloud-first approach. Starting September 17, 2026, the new Projects feature in Claude Code will begin beta availability for a subset of Pro/Max subscribers who use cloud sessions, with plans to expand to more Pro/Max users over the coming weeks, followed by rollout to Team/Enterprise and integration into chat and Cowork, and eventually support for local execution.
The current beta is aimed at users who do not have existing projects on the web or desktop and who are using cloud sessions in Claude Code. Users with existing Projects will, for the time being, retain their current environment and will be migrated to the new environment in stages as integration with chat and Cowork progresses.
The current restriction to cloud sessions only offers the convenience of not burdening a developer's local machine, but it poses an adoption barrier for enterprises with security policies that prohibit sending sensitive code to external clouds. In response, Anthropic has signaled that it will soon offer "running on your machine" support, which will allow the use of local tools and internal network environments.
From an era of issuing instructions to a single AI assistant to one of directing a team of parallel agents in the cloud—the way development teams operate and manage resources is entering a new phase.