Claude Projects Rebuilt: From File Folders to Coordinated Agent Sessions

Claude Projects used to be a folder. You dropped files in, Claude read them, and the conversation stayed one thread wide. On November 14, 2026, Anthropic rebuilt it into something else entirely: a project is now a coordinated set of working sessions. You describe the work, Claude scopes it, delegates it, runs parallel threads, reviews what they produce, and assembles the result — while you watch from your phone.

I haven't used it. Almost nobody has — the beta opened today to a deliberately narrow slice of users, and the rest of us are reading Anthropic's product post, checked 14 November 2026. Where something is unconfirmed, I'll say so plainly.

What a project does now

The shape of it is a coordinator plus threads. Each thread is a Claude Code cloud session working on its own branch and copy of the repository, and a thread can split its own assignment further using subagents, loops and workflows. The coordinator keeps the work organised. Anthropic is explicit about the one sharp edge: if two threads touch the same code, the overlap surfaces as an ordinary merge conflict in a pull request. No magic resolution — the same conflict you'd get from two human developers stepping on each other.

With repositories connected, a thread opens pull requests and runs tests. With documents, it reads and drafts. The work continues after you leave your computer, and Anthropic says progress can be steered from a phone.

Anthropic's own examples are infrastructure chores rather than demos, which is a good sign — these are the jobs teams actually put off. One sets a project goal of reducing an app's checkout p75 latency, then asks Claude to profile each endpoint, test optimisations and open PRs in parallel threads. Another connects API, web and mobile repos with the goal of retiring a deprecated v1 endpoint: Claude creates a thread per repo to migrate callers, run tests, open PRs and report which need to merge first.

Two pieces of shared infrastructure hold it together. Projects carry a shared memory that every thread writes to and reads from, which Anthropic says reduces the need for complex prompt engineering. And there's a library collecting the files you added and the artifacts the threads generated, so the output of a long-running project doesn't scatter across a dozen chats.

You also get dials for how the project behaves: how often Claude checks in, how frequently it opens new threads, and how detailed its updates should be.

Who gets it — and who doesn't

The beta is narrow, and the narrowness is deliberate:

• At launch, today: select Claude Pro and Max subscribers who use cloud sessions in Claude Code and do not already have projects on the web or desktop.
• Over the following week: expansion to more Claude Code users on those plans. Pro and Max users without access can join a waitlist.
• After that: updated projects across the rest of Claude, plus Team and Enterprise plans.
• Existing projects keep working unchanged, and will be upgraded as the rollout reaches chat and Cowork. Nothing you already built gets broken by this launch — it just doesn't get the new behaviour yet.

If you are a Pro or Max subscriber with existing projects, the honest answer today is: not yet. Your projects work exactly as before.

The cost warning, stated plainly

This is the part of the announcement worth reading twice. Because a project can run several threads at once and each is a full Claude Code session, Anthropic says projects can reach usage limits faster. That's not a footnote — it's the main running cost of the feature. A project that spawns five threads is five Claude Code sessions burning through your plan at the same time.

Anthropic gives you two controls: you can check project-specific usage, and you can choose the model and effort level for both the coordinator chat and the worker threads. If you try this in beta, set those deliberately before you hand Claude a big goal — a coordinator on a heavy model with five worker threads on the same model is the most expensive way to find out what this does.

What it doesn't do yet

Threads run only in the cloud today. Running them on a local machine — alongside local tools and code, behind your own network — is, in Anthropic's words, coming very soon. For teams whose code can't leave their network, that is the version that matters, and it isn't here yet.

That's also the honest limit on the whole announcement: the local story, the Team and Enterprise story, and the chat-and-Cowork story are all still ahead. What launched today is a cloud-only beta for a slice of Pro and Max Claude Code users with no existing projects.

What this changes — and what it doesn't

What changes: the unit of work. A project stops being a place you store context for one conversation and becomes a thing that does work while you're away — scoped, delegated, reviewed, assembled. If the coordinator model works as described, the skill that matters shifts from writing the perfect prompt to writing a clear goal and knowing how to check the output. The merge-conflict detail is the tell: Anthropic isn't pretending parallel agents never collide. It's giving you the same conflict a human team would produce, and expecting you to resolve it the same way.

What doesn't change: the review step. A coordinator that assembles PRs from five threads is still assembling drafts. The PRs still need a human to read them before they merge, and the latency optimisation still needs someone who understands the system to say whether the trade-off is right. Parallel threads multiply output; they don't multiply judgement.

And the usage warning is the real constraint on how ambitious you should be in the beta. The feature is most useful exactly when you hand it a big, multi-threaded goal — which is also when it costs the most. Start small: one goal, two threads, and watch the project usage page before you scale up.

My take

Of Anthropic's launches this week — the office suite on Monday, Manufacturing on Wednesday, Meetings on Thursday — this one is the most ambitious, and the least proven. Meetings puts Claude in the room with you; Projects sends Claude off to do the work without you. That second idea is the one that either becomes how software teams work, or becomes an expensive way to generate PRs nobody merges.

The test is simple, and it's the same test I'd apply to any agent system: after one real project, are the PRs the ones your team actually merged — or did someone redo the work properly afterwards anyway? If it's the first, Claude just bought every team back the hours they spend on migration chores and latency hunts. If it's the second, it's a fancier way to burn usage limits.

If the beta has reached your account, try it on a bounded chore first — one endpoint migration, one latency target — not on a sprawling refactor. Set the model and effort levels before you start, check the project usage after the first run, and read every PR before it merges. Always read the PR.

Sources: Anthropic product post on rebuilt Claude Projects, published 14 November 2026 (via Pivot News summary, https://pivotnews.ai/build/anthropic-rebuilds-claude-projects-around-coordinated, read 14 November 2026). All capability, rollout and usage claims are Anthropic's, stated as such. No hands-on testing was performed for this article. This breaking article is not the daily buyer-intent post, and it contains no affiliate links. Plain link for readers: claude.com.