Anthropic adds proactive coordination and branching to Claude Code Projects
Claude Code Projects now features a proactive coordinator, read-only thread sharing, and new branching commands for Pro and Max users.
Anthropic has released a significant update to Claude Code Projects, introducing proactive coordination and enhanced workflow controls for parallel AI agents. The changes, available now in public beta for Pro and Max subscribers, aim to reduce the manual monitoring required when running multiple cloud sessions simultaneously.
What happened
The core of this update is a shift in how the project coordinator interacts with developers. Previously, users had to actively monitor a list of threads to identify which sessions were waiting for input or had completed tasks. The coordinator now proactively posts status updates and answers questions directly in the main project chat. This change brings pending decisions, blocked work, and completed tasks into the primary conversation view, reducing the need for constant context switching.
Anthropic also introduced new mechanisms for managing thread lifecycle and collaboration. Individual threads can now be shared via read-only links with other signed-in Claude users, though threads that have accessed local computer data remain unshareable to prevent leakage of local file contents or shell output. Additionally, developers can use reminders to hide a thread until a scheduled time, allowing them to park work that depends on external reviews or deployments without cluttering the active workspace.
The update extends existing slash commands to the Projects environment. The /btw command opens a side thread for tangential investigations, preserving the main thread’s context, while /fork creates a new thread from the current state for testing alternative implementations. These tools, previously available in standard Claude Code sessions, now support coordinated multi-thread workflows. The interface has also been refined, with a recents row in the threads panel and artifact thumbnails to simplify navigation across large projects.
How it works
Claude Code Projects operate as long-running conversations where a central coordinator assigns tasks to independent worker threads. Each thread runs as a separate Claude Code cloud session, maintaining its own repository copy and Git branch. The coordinator manages the project by synthesizing reports from these threads, while overlapping code changes are handled as standard Git merge conflicts when branches are combined.
The new proactive coordinator monitors thread progress and pushes updates to the main chat without requiring user prompts. When a thread reaches a usage limit, it pauses automatically and resumes when capacity becomes available. All workers draw from the subscriber’s existing Claude Code allowance, with a daily limit of 200 new threads per account. Users can configure the model and effort level for both the coordinator and workers, with new projects defaulting to Opus for both roles.
Key details
- The coordinator now proactively answers questions and posts status updates in the project chat.
- Read-only share links are available for individual threads, excluding those with local computer access.
- Reminders allow threads to hide and resurface at a scheduled time, notifying the coordinator upon return.
/btwopens a side thread for tangents, and/forkbranches a new thread from the current state.- The public beta is available on web, desktop, and mobile for Pro and Max subscribers; Team and Enterprise plans are excluded.
- Accounts are limited to 200 new threads per day, with all workers consuming the subscriber’s existing plan allowance.
Why it matters
For engineering teams, this update reduces the operational overhead of managing parallel AI agents. By making the coordinator proactive, Anthropic addresses a key friction point in multi-agent workflows: the need for developers to constantly poll for status. This allows engineers to focus on high-level direction and code review rather than session management. The ability to share specific threads also facilitates better collaboration, enabling team members to inspect AI-generated logic without exposing the entire project context or local machine data.
However, the cost structure remains a critical consideration. Since every worker thread consumes from the same plan allowance, running several high-effort sessions in parallel can exhaust limits significantly faster than single-session workflows. Developers must carefully evaluate whether tasks are truly independent enough to benefit from parallelism. Small changes that fit within a single context window may still be more resource-efficient in a standard Claude Code session, while large-scale refactors or cross-repository migrations are better suited for the Projects framework.
What you can do
- Evaluate your current workflows to identify tasks that can be divided into independent units, such as performance profiling or batch dependency upgrades.
- Configure default effort levels for coordinators and workers to balance speed and cost, noting that high-effort workers consume more allowance.
- Use the
/forkcommand to test alternative implementation paths without losing progress in the main thread. - Leverage reminders to park threads waiting for external inputs, keeping the active workspace clean and focused.
- Monitor your daily thread usage closely, as the 200-thread daily limit applies across all projects and can be reached quickly with parallel high-effort sessions.
- Share read-only thread links with teammates for code review, ensuring no local machine data is exposed in the process.



