Claude Code Projects Explained: Threads, Costs, Limits

On September 17, 2026, Anthropic relaunched Claude Code Projects as a cloud-based multi-agent orchestrator — three days after quietly cutting every subscriber’s effective weekly usage limit by 17%. That pairing isn’t a coincidence, and it’s the thing most coverage of the launch glosses over. Claude Code Projects is genuinely interesting engineering: a coordinator conversation that splits your engineering goals into parallel threads, each running as its own cloud session. But it’s also a usage multiplier landing exactly when the subscription ceiling got lower. If you’re evaluating whether to adopt it, you need to understand both halves of that story.

What exactly is Claude Code Projects?

Claude Code Projects is a rebuilt feature that replaces the old folder-based Projects with a single conversation-based coordinator that splits engineering work into parallel threads, announced on September 17, 2026. If you used the old Projects, forget the mental model — the name survived, nothing else did.

The architecture has two layers. The project conversation is one long-running session where Claude plays coordinator: you describe a goal (“retire the v1 API endpoint across all three repos”), and it scopes the work, decides how to divide it, and delegates. The threads are where execution happens. Each thread is a full cloud-hosted Claude Code session with its own branch and its own copy of the repository, per The Verge’s coverage. When two threads touch the same code, the overlap surfaces as an ordinary merge conflict — it’s git, with an AI on both ends of the disagreement.

The cloud execution piece matters more than it sounds. Threads keep running after you close your laptop, and you can steer them from your phone. That’s a real workflow shift from the local, single-session tool Claude Code has been. Local execution alongside your own tools and private-network resources is promised but not here yet, which means your code runs on Anthropic’s infrastructure for now. We’ve covered what that exposure looks like in our breakdown of Claude Code Projects security — the short version is that the tier you’re on determines what scanning and policy enforcement you get.

How do parallel threads and shared memory work?

Threads share project memory and files, so decisions and context persist across days and multiple sessions, according to tbreak’s report on the launch. A release date that moved in one thread stays visible to every other thread. A library collects files and artifacts so later threads can reuse earlier work without you re-pasting anything.

That’s the part that used to be entirely manual. Developers running parallel Claude sessions before this had to divide work themselves and stitch results together by hand. Shared memory is the actual product here — the parallelism is just plumbing. Though it’s worth noting the gap between Anthropic’s internal memory sophistication and what users can actually configure, something we dug into in our piece on Claude Code’s memory file system.

Two hard constraints shape what you can do with this:

• GitHub is required. Not git generally — GitHub specifically, per this Projects guide. If your repos live on GitLab or Bitbucket, you’re waiting.
• There’s a system cap of 200 new threads per day per project, per GenAI Daily. Generous for most teams, but it tells you Anthropic expects people to spawn threads aggressively.

Here’s the catch that should be printed on the landing page: each parallel thread consumes a full Claude Code session’s worth of usage limits, so usage scales linearly with the number of active threads, as tbreak confirms. Six threads means six times the consumption of your plan’s allowance. The marketing framing is “a team of agents that keeps working after you close your laptop.” The billing reality is several developers sharing one meter — your meter.

Who gets access, and what does Claude Code Projects cost?

The beta launched September 17 for select Pro and Max subscribers using cloud sessions, with Team and Enterprise access planned later, per The Verge. There’s no standalone Projects price — it’s bundled into the existing subscription tiers, which is where the math gets interesting.

Current subscription pricing, per Coworker AI’s pricing breakdown: Pro at $20/month, Max 5x at $100/month, Max 20x at $200/month, Team Standard at $20/seat/month on annual billing, and Team Premium at $100/seat/month annually. Enterprise works differently — it’s $20/seat/month billed annually plus usage at API rates with no included allowance, which means Enterprise was already metered before Projects existed.

Plan	Price	Projects access	Best fit
Pro	$20/month	Beta (select users)	Solo devs testing the waters
Max 5x	$100/month	Beta (select users)	Heavy individual users
Max 20x	$200/month	Beta (select users)	Power users running many threads
Team Standard	$20/seat/month annual	Coming later	Teams with light agent usage
Team Premium	$100/seat/month annual	Coming later	Teams standardizing on Claude Code
Enterprise	$20/seat/month + API usage	Coming later	Orgs needing admin controls, already metered

For a concrete scenario: based on these per-seat figures, a 50-developer team on Team Standard runs $12,000/year in subscriptions (50 × $20 × 12), while Team Premium hits $60,000/year (50 × $100 × 12), and Enterprise adds $12,000/year in seat fees before any API usage charges, per AgentCode’s team pricing analysis. Those are subscription-only numbers. Once Projects lets each developer run multiple parallel threads, the question stops being “what’s the seat price” and becomes “how fast do we blow through the weekly ceiling.”

Why does the 17% limit cut matter more than the launch?

Three days before the Projects announcement, Anthropic replaced a temporary 50% weekly limit boost with a permanent 25% increase — which, measured against what users actually had all summer, is a 17% reduction, as Using Claude’s FAQ documents. The arithmetic: if the base limit was 100 units, the summer promo gave you 150, and the permanent state gives you 125. Anthropic’s own clarification acknowledged the 17% figure after deleting the original announcement thread.

I keep coming back to a pattern I’ve started calling orchestration lag: the product’s orchestration capabilities are scaling up faster than the billing model that funds them. Anthropic shipped a feature whose entire purpose is spawning parallel sessions — each consuming a full session’s worth of allowance — in the same week it lowered the allowance. The limit cut affects every Pro, Max, Team, and seat-based Enterprise subscriber immediately. Projects affects a beta slice. Strategically, the cut is the bigger story.

Then there’s the tell. Starting September 19, Claude Code version 2.1.278 stopped billing auto mode’s safety classifier requests for Claude API, Enterprise, Bedrock, Vertex, Foundry, and gateway users, per Ikki’s changelog analysis. Auto mode is the permission setting that lets Claude Code run commands unattended, and its safety checks used to land on your bill as token usage. Making those checks free is a genuine cost reduction — but only for metered accounts. Subscription users got a tighter ceiling; API users got cheaper operations. Read those two changes as one week, and the direction is unmistakable: the economics are being nudged toward metered billing.

How do usage credits complete the picture?

Usage credits let paid subscribers keep working after hitting plan limits by switching to pay-as-you-go pricing at standard API rates, with a daily redemption limit of $2,000, per Anthropic’s support documentation. You prepay, set a monthly spend cap if you want one, and overflow bills separately from your subscription.

This is the mechanism that makes the whole structure click. Projects accelerates consumption. The 17% cut lowers the ceiling. Usage credits catch you on the way past it — at API rates. None of this is hidden; it’s all documented. But the combined effect is a migration path from flat-rate predictability to metered spend, with the subscription becoming an entry fee rather than a budget.

If you’ve read our analysis of Claude Code’s session costs and the Context Loop Tax, you’ll recognize the shape: costs that scale with context and parallelism, not with seats. Projects multiplies that dynamic by however many threads you spawn.

Should your team adopt Claude Code Projects now?

Adopt it if you’re on Max, already hitting weekly limits with single sessions, and have work that genuinely parallelizes — multi-repo migrations, endpoint deprecations, test backfills. The shared memory alone justifies it for work spanning days. Just go in with a spend cap configured and a realistic model of thread multiplication.

Hold off if you’re on Pro with modest limits, if your repos aren’t on GitHub, or if your code can’t leave your network — local execution isn’t here yet. And if you’re on Team or Enterprise, you’re waiting for access anyway, which gives you time to instrument usage tracking before the rollout reaches you.

The open question I’d watch: does Anthropic adjust subscription allowances upward once Projects hits general availability, or does the 200-thread daily cap combined with linear usage scaling become the permanent funnel into credits? The answer tells you whether the subscription is a product or a landing page.