Cursor 3: Agents Window, Cloud Agents, and What Changed
Cursor 3 launches with the Agents Window for parallel agent orchestration, Composer 2, seamless cloud handoff, an integrated browser, and Marketplace plugins.
Parallel agents
Composer 2 model
Marketplace plugins
Cloud / local handoff
Key Takeaways
Cursor 3 shipped on April 2, 2026, and it is the biggest architectural change since the editor launched. The release introduces the Agents Window -- a standalone, agent-first interface for running many agents in parallel across repos and environments -- along with Composer 2 (Cursor's own frontier coding model), the Cursor Marketplace, an integrated browser, and a redesigned diffs view. Together, these features mark what the Cursor team calls the third era of software development.
Where Cursor 2.0 introduced agent-first architecture with the Composer model and parallel agents inside the existing IDE, Cursor 3 rebuilt the interface from scratch around agents. The Agents Window is now the primary surface for agent interaction, with the classic editor available as a complement. This guide covers every major change, what it means for daily development, and how to adopt the new workflow. The April 24 and May 7 changelog updates are folded in as well, since they round out the picture of what shipped during the first six weeks of Cursor 3.
Cursor 3 is a free update for all existing subscribers. The Agents Window, Composer 2, the Marketplace, and worktree features are available on Pro, Pro+, Ultra, and Teams plans. Source: Cursor 3 announcement.
The Agents Window: A New Workspace for Multi-Agent Development
The Agents Window is the centrepiece of Cursor 3. It is a new full-screen workspace, built from scratch and centred on agents, that replaces the agent-first interactions that previously lived inside the Cursor 2.0 IDE. Per Cursor's official docs, the Agents Window is "Cursor's agent-first interface" -- a unified workspace to build with agents across repos and environments, including local, cloud, remote SSH, and more.
In practice, all your agents appear in one sidebar -- local agents, cloud agents, and the ones you kicked off from mobile, web, the desktop app, Slack, GitHub, and Linear. The interface is multi-workspace by default, which lets a single agent session target several repositories at once. You can move between the Agents Window and the classic editor with Cmd+Shift+P then Open Editor Window (or open both side by side).
Building with AI agents? Tools like Cursor 3 are reshaping how teams ship software. Explore our AI and Digital Transformation Services to integrate agentic workflows into your development process.
When to use which
Cursor's guidance is clear: the Agents Window works best when you want to run and manage many agents in parallel, while the classic editor remains the better choice for flexible screen splitting, VS Code extensions, and viewing many files at once. The two interfaces are complementary -- most workflows in 2026 will move between them rather than picking one exclusively.
Composer 2 and the Integrated Browser
Cursor 3 ships with two surfaces that change what an agent can actually do inside the new interface: Composer 2, Cursor's own frontier coding model, and the integrated browser for navigating and prompting against local websites.
Composer 2 is Cursor's in-house coding model, available to paid subscribers with high usage limits. The Cursor team positions it as the model for fast iteration during local-cloud handoff workflows. Third-party models from Anthropic, OpenAI, and Google remain available alongside.
Cursor 3 ships a built-in browser the agent can drive -- opening pages, navigating, and prompting against local websites. This shortens the feedback loop on frontend work: the agent can see what it built, navigate it, and iterate without your manual screenshot.
The Cursor Marketplace
Cursor 3 also introduces the Cursor Marketplace: hundreds of plugins that extend agents with MCPs, skills, and subagents. Install with one click, or set up a private team marketplace of internal plugins. This consolidates what was previously a fragmented ecosystem of Cursor extensions, MCP servers, and skill files into a single discoverable surface inside the Agents Window.
- MCP servers -- extend agents with external tools and data sources through the Model Context Protocol
- Skills -- packaged prompt patterns and instructions activated by trigger descriptions
- Subagents -- specialised agent profiles you can delegate to
- Private team marketplaces -- internal plugins scoped to your organisation
Multitask, Worktrees, and Multi-Root Workspaces
Three weeks after Cursor 3 launched, the April 24, 2026 changelog extended the Agents Window with three features that lift the parallelism story from "many agents in one place" to "many subagents inside one agent run." This is the part of Cursor 3 most worth adopting on day one.
/multitaskCursor runs async subagents to parallelise your requests instead of adding them to the queue. It also breaks down larger tasks into smaller chunks for a fleet of async subagents to tackle simultaneously. If you already have messages queued, you can ask Cursor to multitask on them instead of waiting for the current run to finish.
Run isolated tasks in the background across different branches. Each agent operates in its own Git worktree -- separate working directory linked to the same repository -- so agents cannot overwrite each other's files. When you are ready to test changes, move any branch into your local foreground with one click. Worktrees use less disk space than full clones since they share the Git object store. See the worktrees docs for setup details.
A single agent session can target a reusable workspace made of multiple folders. Cursor can then make cross-repo changes spanning frontend, backend, and shared libraries without retargeting the agent every time it moves between repos. The May 13, 2026 update extended this with cloud-agent environments -- multi-repo support, Dockerfile-based config with build secrets, and admin-level governance.
Workflow tip: Combine /multitask with worktrees to run a fleet of subagents across isolated branches simultaneously -- the cleanest pattern for non-trivial refactors or migrations that span many independent files.
Cloud Agents: Seamless Local-to-Cloud Handoff
Cursor 3 evolves the Background Agents concept from Cursor 2.0 into full Cloud Agents with seamless handoff. You can start a task with a local agent, push it to a cloud environment when you need it to keep running without tying up your machine, and pull it back to local for iteration. Per the Cursor 3 announcement, cloud agents produce demos and screenshots of their work for you to verify -- the same experience as cursor.com/agents, now integrated into the desktop app.
Cloud agents run in isolated environments, which means they cannot interfere with your local development state. The May 13, 2026 changelog extended cloud-agent environments with Dockerfile-based configuration, build secrets, environment version history, rollback controls, and audit logs -- making cloud agents practical for enterprise teams that need security and governance on the infrastructure they run in. For deeper context on how Cursor implemented cloud isolation, see our earlier coverage of Cursor Cloud Agents and isolated VMs.
- Long-running tasks (large refactors, migrations)
- Resource-intensive builds that would slow your laptop
- Many parallel agents beyond local resource limits
- Quick iterations where latency matters
- Working with local hardware (GPUs, databases)
- Code you prefer not to send to a managed environment
The Third Era of Cursor: From Editor to Agent Orchestrator
Cursor's team frames the product's evolution in three eras, laid out in their third-era essay. The first era was about manually editing files with AI suggestions -- tab completion, inline chat, and code generation inside the editor. The second era (Cursor 2.0) shifted to working with agents that write most of the code while the developer reviews and steers. The third era, which Cursor 3 initiates, envisions fleets of agents working autonomously to ship improvements with the developer acting as reviewer and orchestrator.
This framing matters because it explains the design decisions behind Cursor 3. The Agents Window exists because an agent orchestrator needs a workspace optimised for managing multiple autonomous processes, not a text editor. Composer 2 exists because fast iteration loops need a model that runs at high limits without counting every token. Cloud agents exist because fleets of agents need compute that scales beyond a single laptop, and the Marketplace exists because the third era is plugin-and-protocol shaped, not file shaped.
Era 1: AI-Assisted Editing
Tab completion, inline suggestions, chat-based code generation. The developer writes code; AI accelerates the typing. Most AI coding assistants in 2026 still operate primarily in this mode.
Era 2: Agent-First Development
Autonomous agents that plan, execute, and verify code across entire repositories. The developer describes intent; the agent implements. Cursor 2.0 and Cursor Automations defined this era.
Era 3: Fleet Orchestration (Cursor 3)
Many agents working in parallel across environments. The developer orchestrates, reviews, and merges. The Agents Window is the control surface; Composer 2, multitask, worktrees, and cloud agents are the levers; the Marketplace is how the ecosystem reaches in.
The shift to fleet orchestration does not mean developers become passive. Review, architectural judgment, and quality control become more important, not less, when agents produce code at scale. Think of it as moving from writing every line to managing a team of fast, capable junior developers.
What This Means for Your Workflow
If you are already using Cursor 2.0, the transition to Cursor 3 is incremental rather than disruptive. Your existing rules, models, and project configuration carry over. The main change is that the Agents Window becomes the primary interface for agent interaction, with the editor available alongside.
Immediate workflow changes
Press Cmd+Shift+P then Open Agents Window. Pin it as your primary view for agent work; switch back to the editor for flexible file viewing.
Switch the model dropdown to Composer 2 for a multi-file refactor. The high usage limits make it a sensible default for iteration-heavy work.
/multitask for parallel workFor requests with independent parts, call /multitask instead of queuing serially. Combine with worktrees so each subagent edits its own branch.
Push migrations and large refactors to cloud agents. They produce demos and screenshots, and you can pull them back to local for the last 10% of polish.
The Composer 2 model is available alongside third-party models from Anthropic, OpenAI, and Google -- switch in the model dropdown when a particular task calls for a different reasoning profile. The Cursor team continues to ship into both surfaces (Agents Window and editor), so your workflow can move incrementally.
Conclusion
Cursor 3 is a meaningful step forward in the AI coding editor space. The Agents Window gives developers a purpose-built workspace for managing multiple agents, Composer 2 lifts the iteration ceiling on Cursor's own model, the Marketplace makes the extension story first-class, and seamless cloud-local handoff means you are no longer constrained by local compute. The April 24 update on multitask, worktrees, and multi-root workspaces is what turns the launch into a daily-useful product.
The "third era" framing is ambitious, but the features back it up. For teams already using agentic coding tools, Cursor 3 provides the infrastructure to scale from one agent to many without changing their development process. For teams evaluating AI coding tools for the first time, the Agents Window is the most complete agent-orchestration experience shipping in a commercial IDE today.
Ready to Build with AI-Powered Development?
Our team helps businesses integrate agentic AI tools into development workflows for faster shipping and higher code quality.
Frequently Asked Questions
Related Guides
Continue exploring AI coding tools and agentic development workflows