The promised future of coding agents is that they just do everything. Agents that plan, agents that execute, agents that review each other's work. You describe what you want, walk away, come back to a ralph-looped pull request. The pitch deck version of multi-agent AI is a world where the human is barely in the picture.
But in reality, I have five agents running in parallel across three worktrees and I am very much in the picture. I'm the one deciding what each of them works on, checking in on progress, course-correcting when something drifts. The agents are doing the coding. I'm doing the orchestration. And that orchestration is its own kind of full-time job, but it's more leverage than I've ever had. It's worth being honest about where we actually are versus where the narrative says we should be.
This gap between the pitch deck version of multi-agent and the lived experience of it is what makes the latest wave of product launches interesting. Cursor 3.0 launched last week, and it looks A LOT like the Codex app for Mac, a standalone application that focuses on triggering multiple agent workloads with an option to see the code but not really required. Both are betting more on parallel agent orchestration, giving the developer a workspace designed for running and steering multiple agents at once, with remote agent execution as a close second (both are scenarios with minimal code babysitting).
The Codex app and Cursor's new agent window keep you informed of progress across parallel sessions. Compared with competitors such as Claude Code's extension (for all its glory), I often forget what I was doing in the other sessions and have to make rounds checking each one. The funny part is multiple agents have been supported by these tools for more than a year now, and yet the space has evolved to fully harness it just now. For example, the progress indicator in a vertical taskbar is a minor UX decision, but it makes all the difference since now the companies and the ecosystem have together agreed that this is how we operate. I am the bottleneck and the tools that help me be less of one are the tools that win.
Claude code interface that doesn't give easy visibility into parallel agents
How we got here
A year ago, vibe coding was the novice's errand. The agentic coding companies (the IDE-native players) looked down on the vibe coding platforms as tools serving beginners who just want to build an app. They were the real deal because they were built on top of actual IDEs. Superior to Copilot (even to this day) for several reasons that deserve a post of its own. You could see the code. You could review the diffs. You were still a developer, just a faster one, even with an agent. Several hardcore developers I know prided themselves on being power users of autocomplete, the 'tab' feature that lets you complete your lines but still gives you full control of the coding process, rather than rely on agents. An almost extinct species today.
Then Claude Code launched in early 2025 and challenged that by saying you only need a terminal. It wasn't entirely without IDE interaction, you could still see diffs, but it was bare minimum. And that's what made it intriguing. Even the IDE crowd was curious, because Claude Code's ability to harness Sonnet was compelling in a way that no IDE-based product was matching. The lack of UI was still true, but the model capabilities more than made up for it. It suggested something interesting: that with better models and better agents, people might stop needing to constantly monitor the output. Even with that minimal interface, Claude Code captured significant mindshare.
Still, something else was shifting underneath. For a while, there was a strong "I'm not like other vibe coders" energy in the developer community. People wanted you to know they still reviewed every line. The occasional vibe coding was a guilty pleasure. They used AI for autocomplete, sure, but they knew better what code to write. The agent was a faster pair of hands, not a decision-maker.
What cracked that open wasn't a product launch (although the advent of Opus models had something to do with it). It was people the community actually respected flipping the script. Karpathy posted in late December 2025 that he'd "never felt this much behind as a programmer", that in a matter of weeks he'd gone from 80% manual coding to 80% agent. Boris Cherny, who created Claude Code, shared that he hadn't opened an IDE once in a month, every line written by Claude with Opus 4.5. Jaana Dogan, a principal engineer at Google, said she gave Claude Code a three-paragraph description of a distributed agent orchestrator her team had spent a year building, and it generated a working prototype in an hour. This wasn't the usual product launch hype (well, maybe except for the Boris one ;)). Practitioners who felt the magic were describing how their own work had changed, and it gave everyone else permission to let go.
It went from "I still review every line" to "I run multiple agents in parallel and my job is orchestration and review." Now Codex and Cursor are saying you might not even need to see the code at all. Each step felt like heresy to the previous one, and each step turned out to be roughly right.
What blind trust means
On a side note, if you're not reading every line, you're trusting something. Beyond the model, it's usually the integrations and the environments the agent is working in. This also means the surface area for things to go wrong quietly is a lot larger than it used to be. Security is the obvious one, an agent with access to your credentials and your production systems is an agent whose mistakes you might not catch for a while and could prove expensive. The less obvious one is that everything the agent touches now has to work 'for an agent'. When a human hits a broken integration, they show up in your Discord or file a GitHub issue, unlike an agent that might just move on to your competitor. And the worst part is you don't even know it happened. Coding agents can do a lot by themselves, but only as much as the world designed for humans lets them.
The human is still in the chair (so far)
Through all of this, the human is still in the chair. What they're doing in that chair looks nothing like it did a year ago. Until Opus, the developer identity was clear. You used AI to accelerate the typing, but you knew better what code to write. Now Claude Code creates a month-long product development plan just for kicks and executes through it in two hours. The silliest part is watching it happen and not knowing what to feel about it.
I still think the distinction matters though. In vibe coding you don't control the decisions the agent makes. You prompt and you pray. But if you're a developer, even one managing parallel sessions across multiple worktrees, even one who hasn't looked at the actual code in a while, you still want to know the system design. You still want to understand the architectural choices, even when they're made in conjunction with the agent. Who knows when that is going to fall out of trend too?