Parallel agents are getting real addresses

Everybody loves the fantasy version of multi-agent software. Spin up more workers. Fan out the task. Let the swarm cook.

Then reality walks in wearing steel-toed boots.

Parallel agents are only useful if they stop stepping on each other. If one helper rewrites files another helper is reading, or if your runtime can’t cleanly refer to which subagent did what, “more agents” starts feeling less like leverage and more like a group project gone bad.

The interesting shift this week is that terminal agents are starting to look less like invisible background threads and more like coworkers with named desks and separate rooms.

Gemini CLI: give each session its own room

In google-gemini/gemini-cli, PR #22973 adds experimental Git worktree support for isolated parallel sessions. That sounds modest until you read the problem statement in issue #22945: shared working directories were causing state contention, manual worktree setup was too painful for most people, and spec-driven parallel tracks were colliding because project-level files lived in one place.

The code backs up the pitch. In WorktreeService.setup(), Gemini captures the repo’s base SHA before creating a fresh worktree. It places that worktree under .gemini/worktrees/<name> and creates a dedicated branch for it. That is not hand-wavy “session isolation.” That is filesystem-level separation with Git doing the heavy lifting.

The safety logic is the part I like most. maybeCleanup() checks two things before deleting anything: whether git status --porcelain shows working-tree changes, and whether HEAD has moved from the base SHA. If either is true, Gemini preserves the worktree instead of treating it like disposable scratch space.

That design choice matters. It says the product is being built for real interrupted workflows, not just clean demos. The docs even spell out the resume path: cd .gemini/worktrees/<name>, then gemini --resume <session_id>.

Codex: give each subagent a mailing address

OpenAI’s codex repo is attacking the same coordination problem from another side. PR #15313 replaces UUID-style multi-agent references with a path-like identity system rooted at /root.

The new AgentPath type in Rust is stricter than it sounds. Absolute paths must begin with /root. Child names can only use lowercase letters, digits, and underscores. Reserved segments like ., .., and root are blocked. The helper methods make the model’s world more navigable too: join("researcher") yields /root/researcher, while resolve() supports both relative and absolute references.

That may sound like a boring schema cleanup. It isn’t. Naming is interface design.

In the spawn handler, Codex now tries to surface task_name from the new agent path and only falls back to an opaque thread ID when no path is available. That means the system can increasingly talk about a subagent as a place in a tree instead of a random token you have to look up somewhere else.

Why these two changes rhyme

Gemini and Codex are not shipping the exact same thing.

• Gemini’s evidence is concrete workspace isolation: separate directories, separate branches, safe cleanup rules, and a documented resume flow.
• Codex’s evidence is stronger on identity and orchestration: subagents get structured addresses, path validation, and cleaner references at spawn time.

But both changes point in the same direction: multi-agent tooling is leaving the era of ghost processes.

That’s bigger than it sounds. Humans don’t just need more workers. They need to know which worker is responsible, where that work lives, and how to come back to it later without turning the repo into soup.

The next bottleneck is not intelligence. It’s logistics.

For the last year, agent discourse has mostly focused on cognition: planning, reasoning, tool use, autonomy, memory. Those things matter. But once agents start running in parallel, the limiting factor gets weirdly physical.

Where is this agent working?

What files can it touch without collisions?

How do I refer to it without a debugger and a prayer?

What survives when I pause and come back later?

Those are workplace questions, not benchmark questions. And that’s exactly why this week’s commits feel important. They move agent UX a step away from spectacle and a step toward something teams can actually manage.

The bigger pattern

If you zoom out, the pattern is hard to miss.

• Parallelism is becoming a product surface, not just an internal runtime trick.
• Agent identity is getting more legible.
• Isolation is becoming more concrete and less aspirational.
• The best agent systems are starting to borrow from office design as much as model design.

That may be the next real maturity curve for terminal agents. Not “can it spawn helpers?” but “can those helpers coexist without chaos?”

So here’s the open question: if agent tools get much better at giving parallel workers clear boundaries and clear identities, does that change how much responsibility developers are willing to hand them?

If you’re building in this space, watch the boring infrastructure closely. The next leap may come not from smarter agents, but from better rooms, better labels, and less accidental elbowing.