Cursor 3, released in April 2026, ships with a second window that has nothing to do with editing files. It's called the Agents Window, and the whole point of it is that agents — not you — are the ones doing most of the typing. You review their work. You decide what runs next. You merge what looks good. The editor is still there when you need it. But the Agents Window is built for a different mode of working, one where you're less the person writing code and more the person managing the people who do.
If you've been running Cursor Agent from inside the editor and wondering why Cursor shipped a whole separate interface for it, this is the answer. It's not a new feature bolted on. It's a different philosophy about who does the work.
The old model and what it assumed
The classic code editor — any of them, including Cursor — was built around a simple assumption: you are the one typing. AI assistance made you faster, smarter, less likely to forget a semicolon. But you were still the primary worker. The editor organised itself around that. Files on the left, code in the middle, terminal at the bottom. Everything optimised for a human reading and writing one file at a time.
When agents started writing whole features in one shot, that setup started showing its age. The agent was doing the work of a developer, but it was running inside a UI designed for a craftsman's workbench. You could only really run one agent at a time. You had no unified view across multiple projects. When one agent finished, you had to process what it did before kicking off the next thing. The workflow was sequential by design, because human typing is sequential. Agents don't have to be.
What the Agents Window actually is
Open it with Cmd+Shift+P and search for Open Agents Window. It opens as a separate window you can keep alongside your editor — they're not competing, they're complementary. The editor stays useful when you want to read files, use VS Code extensions, or work the traditional way. The Agents Window is for when agents are writing most of the code.
The window is built around three ideas that the editor never had.
Parallel agents. You can run many agents at the same time, in the cloud, without any of them blocking the others. One agent is refactoring your auth module while another writes tests for a different part of the codebase while a third is cleaning up your API client. None of them wait for the others. You're not waiting for any of them. That's a different kind of leverage.
Worktrees. This one needs a quick definition because most vibe coders haven't run into it before. A Git worktree is a separate checkout of the same repository — same codebase, but in its own folder, on its own branch, isolated from everything else. When you run parallel agents without worktrees, they can step on each other: two agents editing the same file at the same time makes a mess. Worktrees solve that. Each agent task gets its own isolated Git checkout, so the agents genuinely can't conflict. They're working in parallel but not in each other's way.
The diffs view. When an agent finishes a task, you need to see what it did. The Agents Window has a built-in diffs view — a diff is just a side-by-side comparison of what changed — plus tools to review, commit, and manage pull requests without leaving Cursor. A pull request (PR) is how you formally propose merging one branch of code into another. Having all of that inside the same window means you can go from agent finished to changes merged without bouncing between apps.
Cloud agents and the offline handoff
One thing that trips people up: the distinction between local and cloud agents isn't permanent. You can start an agent locally — useful when you're actively iterating and want to see results fast — then move it to the cloud so it keeps running after you close your laptop. Come back later, pick up where it left off. The Agents Window handles that handoff, and it gives you a unified view across all your projects so you can see what's running where without hunting through tabs.
You might be thinking: this sounds like a lot of infrastructure for something that used to just be a chat box. That's fair. But the chat box was fine when agents were doing small tasks. When an agent can write a feature end to end — tests, logic, documentation — the bottleneck moves. It's no longer how fast the agent writes code. It's how fast you can review and decide what ships. The Agents Window is built around that bottleneck.
Three layers underneath
The way to think about the Agents Window is as a system with three distinct concerns layered on top of each other.
The first is execution: where does the agent actually run? Local means it runs on your machine, in front of you, using your CPU. Cloud means it runs on Cursor's infrastructure, in the background, without needing you to be at your desk. Remote SSH is also an option if you're running agents on a remote server.
The second is isolation: how do you stop agents from conflicting? That's the worktrees layer. Each task gets its own branch, its own folder, its own clean slate. No agent ever touches another agent's work.
The third is orchestration: how do you manage all of it? That's the window itself — the dashboard where you see what's running, review what's done, approve what ships, and kick off what's next. Execution, isolation, orchestration. None of those existed as first-class concepts in the classic editor.
When to use which
The editor isn't going away. You still want it when you're reading a lot of files side by side, when you need VS Code extensions, or when you're doing close work where you're making small precise edits and want immediate feedback. The two windows can stay open at the same time and you move between them naturally.
The Agents Window earns its place when agents are doing the bulk of the writing. Multiple projects on the go, tasks you want running in the background while you think about something else, work you'll review in batches rather than line by line. Not more capable. Just aimed at a different moment in the workflow.
The shift in how you work is quieter than it sounds. You stop opening a file and writing in it. You start describing a task, dispatching it, and coming back to review what happened. The workspace stops being the place where code gets written and becomes the place where code gets approved. That's what the Agents Window was built for.