Cursor 3 puts autonomous agents in the driver’s seat

Cursor just pushed its editor deeper into agent territory. With Cursor 3, Anysphere is turning the workspace into a place where AI systems can write code, test it, and keep going while developers stay in the loop.

The timing matters. Anysphere has reportedly raised more than $3 billion from investors including Nvidia and Google, which gives the company enough muscle to keep iterating fast. Cursor 3 is the clearest sign yet that the product is moving from “AI pair programmer” to “multi-agent coding workspace.”

Cursor 3 is built around agents, not tabs

The big idea in Cursor 3 is simple: developers should spend less time jumping between tools, and more time describing what they want. Cursor’s new interface centers on agents that can work on code independently, while the editor keeps the human in control of review, direction, and final approval.

That shift shows up in the layout. Multiple repositories and workspaces now live in a single view, which matters if you are juggling services, libraries, and deployment code at once. Instead of bouncing between windows, the developer can keep the whole task visible while the system runs pieces of it in parallel.

Cursor also says its own Composer model is tuned for these workflows. That is a notable claim because the company is not betting on one model alone. It still lets users bring in external models such as Claude, which means the editor is trying to be model-agnostic where it counts.

• Cursor 3 introduces a workspace built around autonomous agents
• Multiple repositories and workspaces can be viewed together
• Users can choose which model handles a task
• Cloud agents and local agents can both be used in the same workflow
• Code can keep running in the cloud even when the user goes offline

Natural language is becoming the control plane

One of the most interesting changes is the chatbot-style interface. Instead of opening a file, editing code, and then testing it manually, developers can describe the feature in plain English and let the agent generate the first pass. Cursor then shows the output, including screenshots and demonstrations, so the user can check whether the result matches the request.

This is where Cursor starts to feel less like an IDE plugin and more like a command center for software work. The company says the new flow reduces the time spent verifying whether code behaves as expected. That claim is believable because the system is doing more of the setup work before a human ever opens the debugger.

Cursor 3 also adds Design Mode, where a developer selects UI elements and describes changes in natural language. The agent then applies those changes automatically. For front-end work, that can save a lot of repetitive editing, especially when the request is something like “move this button,” “change the spacing,” or “make this form clearer.”

“The future of software development is going to be about supervising AI systems that do the work,” Cursor co-founder Michael Truell said in a 2024 interview with The Information.

That quote fits the direction Cursor is taking. The new version is not asking developers to stop coding. It is asking them to spend more time reviewing, steering, and combining outputs from multiple systems.

There is also a practical upside here: natural language lowers the friction for repetitive UI changes and boilerplate code. A senior engineer may still prefer direct edits for sensitive logic, but for routine work, the agent workflow can move much faster than hand-editing every file.

Cloud agents and local agents solve different problems

Cursor 3 splits work between cloud and local execution, and that split is one of the smartest parts of the release. Cloud agents can process tasks in parallel with more compute, while local agents let developers inspect, modify, and test code immediately on their own machine.

That matters because agentic coding is not one problem. Sometimes you want speed and scale. Other times you want low latency and direct access to the repo. Cursor 3 lets a task start in the cloud, move locally for inspection, and continue in the cloud if the user steps away or closes the laptop.

Compared with older AI coding setups, the workflow is much less fragmented. A lot of current tools still feel like add-ons: one place for chat, another for code, another for review, and another for testing. Cursor is trying to collapse that into a single surface.

• GitHub Copilot focuses heavily on inline assistance and chat inside Visual Studio Code
• Cursor 3 pushes harder into multi-agent task execution and workspace coordination
• Cloud execution gives Cursor more parallelism than a laptop-only workflow
• Local execution keeps the developer close to the code when precision matters
• Cursor’s view of changes and diffs is redesigned for faster review

The company also says users can send commands to multiple AI models at once and pick the best output. That is a sensible move. Model quality varies by task, and code generation for a UI tweak is not the same as debugging a flaky test or refactoring a service boundary.

In other words, Cursor is betting that the winning editor is the one that makes model choice feel invisible. The developer should care about the result, not the plumbing behind it.

What this says about where coding tools are headed

Cursor 3 is a strong signal that AI coding tools are moving from autocomplete toward orchestration. The editor is no longer just predicting the next line. It is coordinating tasks, showing progress, and keeping multiple workstreams alive at once.

That also raises the bar for every other coding product. If your tool cannot handle multi-step tasks, cross-repo work, model selection, and review in one place, it will start to feel dated fast. The bar is rising because developers are already getting used to agent-driven workflows.

For teams, the real question is not whether agents can write code. They already can, at least for a growing slice of work. The question is whether the surrounding process is good enough to trust them on real projects without turning code review into cleanup duty.

If Cursor keeps improving the handoff between cloud and local work, plus the review flow around diffs and test output, it could become the default editor for teams that want AI to do more than autocomplete. The next test is simple: can it make a feature branch feel shorter without making the review process messier?

That is the metric worth watching over the next few releases. If Cursor can keep the speed gains while preserving code quality, the editor will pull more developers into agent-first workflows. If it cannot, the market will have a very clear answer about where the limits still are.