Claude Code Projects: One AI now runs a whole team of parallel AI workers

What's going on

Anthropic has rebuilt "Projects" in Claude Code. Claude Code is the company's coding tool: it reads and edits code on its own, runs tests and submits changes. Until now, a project was basically a folder of files and instructions. Now it's an ongoing conversation in which Claude organizes the work itself. You describe what needs doing. Claude breaks the job down, hands the pieces to several sessions working in parallel, checks the results and merges them.

According to the trade site ADTmag, Anthropic announced the beta on September 17, 2026. First in line were selected Claude Pro and Max subscribers who use cloud sessions in Claude Code and don't yet have existing projects on the web or in the desktop app. More Pro and Max users are set to follow, and later the rest of Claude plus the Team and Enterprise plans. If you don't have access yet, you can join a waitlist. Anthropic says existing projects keep working as before for now and will be migrated later. A major update followed on November 13, covered by explainx.ai among others.

Coordinator and threads: how the system works

Anthropic sums up the idea like this:

"Projects have threads that do the work, and a coordinator that directs them."

When you create a project, you give it a name, a one-sentence goal and some context. That context might be a GitHub repository (where your code lives) or files and folders. Claude then suggests tasks it can take on right away. You can also configure the cloud environment, connectors (links to external services), plugins, instructions and the model.

In the central project chat, the coordinator sorts every request into one of three buckets:

• It answers right away itself.
• It starts a new thread.
• It routes the request to a thread that's already running.

Anthropic recommends briefing the coordinator the way you'd brief a chief of staff. Under the hood, every thread is a full Claude Code session in the cloud. It works on its own branch – a separate line of development in the code – and on its own copy of the repository. If two threads change the same spot, you get a perfectly ordinary merge conflict: two changes contradict each other and have to be reconciled by hand, just like with any other pull request (PR), a proposed change waiting to be merged into the main code.

Each thread can split its task further across subagents (helper agents inside a single session), or across loops and workflows. According to ADTmag, the coordinator doesn't see every action its workers take. It only gets the results the threads report back, while keeping track of which tasks are assigned.

Anthropic gives two examples. In the first, the goal is to cut the p75 latency of an app's checkout – the response time that three out of four requests beat. Claude profiles every endpoint, tests optimizations and opens PRs in parallel threads. In the second, a deprecated v1 endpoint needs to be retired across API, web and mobile repos. Claude creates one thread per repo, migrates the calls, runs the tests and tells you at the end which PRs need to be merged first.

A guide on note.com fills in more details. Threads that have opened a PR keep watching it. If automated tests (CI) fail, they push fixes and respond to review comments. An overview sorts all threads by status: "Ready for review", "Waiting on you", "Working" and "Resolved". One gotcha: if a thread is waiting for your approval, you have to reply inside that thread. Typing "go ahead" in the project chat won't reach it.

Shared memory and a library

Projects are built for long, multi-part work. All threads write to and read from a shared project memory. Anthropic promises this will cut down on elaborate prompt engineering, the art of carefully crafting instructions. Claude might remember, for instance, that the release slipped to Friday, why an export feature got cut, or who you need to ask before touching the billing service. It also stores your working and communication style, such as how often Claude should check in or how detailed its updates should be. On top of that, there's a library of uploaded files and the artifacts Claude has produced.

The note.com guide distinguishes three places for persistent context:

• CLAUDE.md in the repository for build instructions and coding standards.
• Project memory for decisions and pitfalls. It fills up when you ask Claude to "remember" something.
• Project instructions for rules every thread must follow strictly, such as "ask before merges, force pushes or CI changes".

According to the guide, wishes you only mention in chat are mere preferences, not hard rules.

Also important: threads don't inherit local settings such as skills or locally installed MCP servers. MCP servers are interfaces the AI uses to access external tools. Anything you need has to live in the repository or be set up as a connector on claude.ai. To access code, the Claude GitHub App must also be installed on the repository. Connecting via /web-setup isn't enough.

The November update: a coordinator that checks in on its own

In the early beta, Projects still demanded a lot of attention. According to explainx.ai, you had to keep checking the overview to see which thread was stuck or which PR was done. Since November 13, the coordinator has been "much more proactive", according to Anthropic's ClaudeDevs account. It replies in the project chat and reports on the status of running threads unprompted. You can control how talkative it is, for example with instructions like "Only check in when something is done or blocked."

Other new features:

You still can't collaborate on a project in the beta. Each project belongs to a single user. For team collaboration, explainx.ai points to Claude Tag in Slack.

Limits, caps and costs

Anthropic itself warns that because every thread is a full Claude Code session, you'll hit usage limits faster. There's no separate plan. Everything runs on your regular Pro or Max allowance. According to the official documentation, as quoted by explainx.ai, each account can start up to 500 new threads per day. New projects use Opus, Anthropic's largest model, everywhere by default. Threads run at high "effort" – meaning a lot of compute spent on reasoning – while the coordinator runs at low effort. You can set model and effort separately for the coordinator and the threads, and each project gets its own usage meter.

The note.com guide flags one trap: when a thread hits the limit, it waits and automatically resumes as soon as your allowance resets. That means unattended tasks can quietly eat into your next allowance. The fix is the stop button in the thread or pausing the project in its settings. The guide recommends testing with a small task first and lowering the model or effort. It also suggests capping things at two threads running at once.

Other restrictions:

• Only github.com is supported. GitHub Enterprise Server, GitLab and Bitbucket are missing.
• Threads run exclusively in Anthropic's cloud. According to ADTmag, local files, databases, emulators and services behind a corporate network are currently out of reach.

Anthropic says threads will be able to run on your own machine "very soon". The company hasn't given a date.

Reactions

The discussion on Hacker News was small but pointed. User augment_me warned that proactive parallel workers are "a great way to automatically increase API usage". User kami23 said he had built a similar system himself at work, and that the release helped him better understand the architecture decisions behind other multi-agent systems.

ADTmag editor-in-chief John K. Waters sees a fundamental shift: development is turning into a management job. Generating code can be parallelized; human review can't. If you're supervising several agents, you may end up with more pull requests than you can responsibly review. Organizations also face new questions: which repositories, credentials and services should an agent be allowed to use? According to the documentation, threads can be given network access, environment variables, API keys and connectors. That makes permissions part of the risk.

Our take

Projects is Anthropic's most decisive step yet from AI assistant to AI team. Claude Code already had subagents inside a session, Agent View for manually dispatching sessions, Agent Teams and dynamic workflows. What's new is a persistent coordination layer that spans days and weeks, with shared memory. It makes sense for work that splits cleanly: migrations across several repos, per-endpoint performance analysis, or a steady stream of bug reports. For small one-off fixes, a regular session is still simpler and cheaper.

Three concerns remain. First, consumption: Opus as the default, parallel threads and automatic resumption after hitting the limit can drain your allowance fast. Second, the beta is limited. There are no team features, and only github.com and the cloud are supported. Third, and most important: more code generated in parallel doesn't automatically mean more correct code. None of the sources back up with independent testing how well the coordinator actually breaks down and merges work in practice. The claims about capability and time savings come from the vendor. Responsibility for what ends up in your code still lies with you.