This morning, like every morning, I have three Claude Code windows open side by side. One is fixing a bug in one corner, one is writing tests somewhere else, a third is doing documentation, and I am in the middle copying files from one folder to another because all three are working on the same repository. It works, but I spend my time standing guard.

This week, Anthropic presented something to get rid of the guard duty. The information came out through the press and not through the company's blog, so I take it for what it is, an announcement still being rolled out. But what it describes is exactly the problem I deal with every day.

What Projects is becoming

Projects, until now, was the place where you put a project and its context files. Becomes, conditionally as long as it is not in my hands: the place where you give an objective, and where a machine breaks it down on its own into pieces entrusted to several agents.

You write what you want to achieve, for example redo the login page and its tests. A coordinating agent looks at the work, breaks it down, and sends each piece into a separate thread. Each thread is a complete Claude Code session, somewhere in the cloud, with its own copy of the repository and its own branch. The threads do not step on each other's toes because they are not working on the same files, and when they do step on each other's toes, the machine notices.

Three windows, one repository, and a human shuttling back and forth. This is what I have been doing every morning for a year

The detail that really matters: conflicts

Here is the point that most articles skimmed over, and yet it is the whole point of the thing. When two people modify the same line of the same file at the same time, Git refuses to choose and asks you to settle it by hand. This is called a merge conflict, it happens in every project, and it is the reason most people do not dare launch three agents on the same repository. The risk is not that it crashes, it is having to untangle a complete mess at the end.

In Projects, it is no longer up to you to do it. Two threads that touch the same place produce a conflict that the machine exposes and handles like a standard change proposal, the kind you review before accepting. The mechanism is ordinary, it has existed for fifteen years in every development tool. What is new is seeing it applied to agents that write everything by themselves.

A railway switch does only one thing: send each train onto the right track. The coordinator does the same with tasks

Second thing I did not expect: the threads share memory and intermediate files. A thread that has understood how authentication works does not need to explain it to its neighbor. And each thread can in turn launch its own sub-agents, loops, chains of tasks. Three levels of nesting, which is to say you should not watch this from the back of the corridor.

Why this speaks to me more than one more new feature

Because what I do by hand today, I do badly. I split the work into three, explain the context three times because the sessions do not talk to each other, copy pieces of code from one folder to another, and end up reviewing twice as much as necessary to make sure nobody has overwritten someone else's work.

The real gain is not writing speed, it is no longer having to keep track of who is touching what. A coordinator that breaks things down and monitors collisions is exactly the role I have been playing for a year, only worse. And if you have ever tried running two Claude Code accounts in parallel, you know the plumbing gets expensive fast.

What it still does not do

We need to come back down. At launch, everything happens in the cloud: your repository goes to Anthropic, your agents run on their machines, and local support is announced for later, with no date. If you work on a company repository that isn't allowed to leave your premises, this version isn't for you yet.

Then, it's a beta, reserved for some Pro and Max subscribers. Not a finished product that you install tonight. Opening it up to team plans and the company's other applications is planned, "planned" being the most elastic word in software publishers' vocabulary.

Open soon, subject to conditions, for certain customers. The sign that all software publishers hang in their shop window

And there's one question that nobody has answered yet, the one that concerns me the most: the quota. A Claude Code session that works for an hour costs money, and when you launch five in parallel, you pay five times as fast. I was talking about it just last week regarding the quota that melts away without us understanding why. Multiplying agents on a capped-usage subscription mostly means multiplying the speed at which you watch the counter.

The real issue

Over the past two years, we've learned to talk to an agent, then give it tools, then write loops that run all by themselves without us prompting. The next step is to put several of them on the same project, and that forces us to solve problems we already knew from development, task distribution, collisions, code review. Nothing magical: the same problems as in a team, transposed to colleagues who never sleep.

That doesn't scare me, it even reassures me a little. A tool that tells you it can't handle two modifications in parallel can't handle a real project. This one promises to do it, and that's where we'll see whether it's serious: at the first conflict it resolves itself, and at my face when I reread its decision.