Cursor's Third Era: Cloud Agents — ft. Sam Whitmore, Jonas Nelle, Cursor

The evolution of AI-powered software development is rapidly shifting from inline autocompletions to a new, more powerful paradigm of agentic workflows. Cursor’s Cloud Agents represent a significant step in this direction, moving beyond “site-reading” code to providing AI agents with their own fully-provisioned cloud virtual machines. This gives the agent the tools a human developer would have: the ability to onboard itself to a repository, run development servers, execute code, and perform end-to-end tests.

“If you put yourself in the model’s shoes and you were seeing tokens stream by and all you could do was site-read code and spit out tokens and hope that you had done the right thing… you obviously you need to run the code.”

A New Workflow: Test, Video, and Remote Control

The core of the new cloud agent experience is built on three pillars designed to increase confidence and reduce review friction:

1. Tested Pull Requests: By default, agents don’t just write code; they test it. They will spin up dev servers and validate their changes, working for longer (e.g., 30 minutes) to deliver a PR that is confirmed to work, not just a “best guess.” This mimics the expectation for a human developer, who would never ask for a review on untested code. Users can bypass this with a /no-test command for simple changes.

2. Demo Videos: A major bottleneck in an agent-driven world is the cognitive load of reviewing large, AI-generated diffs. To address this, agents now return a short video demonstrating the feature or fix they implemented. This provides a quick, intuitive entry point for the reviewer to understand the change before diving into the code. The videos can even show the agent using developer tools to test its own work, such as pasting a long string into an input field to trigger an error message.

3. Full Remote Access: Users have complete remote control over the agent’s VM via a VNC-based remote desktop and a fully functional terminal. This allows for interactive testing, exploration, and iteration, providing a live preview that a video cannot always capture.

Advanced Agentic Patterns

Beyond the basic workflow, more sophisticated patterns are emerging that leverage the full computer environment.

• Bug Reproduction (/repro): This has become a standout feature for bug fixes. When tasked with a bug, the agent can be instructed to first create a video that successfully reproduces the bug, then apply the fix, and finally create a second video showing that the bug is no longer reproducible. This TDD-like “red-green” workflow provides extremely high confidence for merging the fix. One example shared was a bug where removed image attachments were still being sent; the agent clearly demonstrated the “before” and “after” states.

• Diagnostics and Subagents: For internal debugging, a /cloud-agent-diagnosis command uses the Datadog MCP (Model-Controller-Plugin) to spin up subagents that explore logs and diagnose issues with other cloud agents. This highlights a powerful meta-capability where agents can debug each other. Subagents are also used for other tasks like exploring a codebase or handling long-running computer-use trajectories, allowing for better context management and the use of specialized, faster models for specific tasks.

Scaling Throughput: Parallelism and Swarms

The next frontier is not about making a single agent faster (latency), but about dramatically increasing the amount of work that can be done in parallel (throughput).

“We think that over the coming months the big unlock is not going to be one person with a model getting more done like the water flowing faster… we’ll be making the pipe much wider.”

• Best-of-N Models: With cloud agents, running multiple models (e.g., Opus 4.5, Codeex 5.3) head-to-head on the same prompt becomes practical. Instead of comparing four massive, complex diffs, a developer can watch four 20-second videos and quickly decide which approach is most promising to iterate on.

• Model “Councils”: Experiments have shown that using a “synthesizer” agent to take the outputs from different base models can produce a synergistic result that is better than any single model’s attempt. This points to a future where a “council” of models from different providers collaborates on a single task.

• Long-Running “Grind Mode”: An experimental feature allows an agent to work on a task for an extended period—potentially days—until a completion criteria is met. This requires an upfront planning and alignment phase to ensure the agent is working towards the correct, well-specified goal.

The Future of Development and Emerging Challenges

This increase in agent-driven throughput is forcing a re-evaluation of the entire development lifecycle.

• Shifting Bottlenecks: As code generation becomes trivial, the new bottlenecks appear in code review, CI/CD pipelines, and production deployments. A 10-person startup now needs the robust DevX and automation pipelines that were once exclusive to 10,000-person companies, including merge queues and sophisticated release staging. GitHub Actions can get overloaded simply from the volume of agent-pushed code.

• Onboarding and Self-Awareness: A key challenge is making agents fully aware of their environment and the specific conventions of a given codebase. This “memory” problem is being approached through dynamic file context and the idea of agent self-auditability, where an agent can identify gaps in its own knowledge or even suggest edits to its own system prompt to better align with its environment.

• Cloud vs. Local: A strong prediction was made that by the end of the year, the volume of work done by cloud agents will be more than double that of local agents, marking a fundamental shift in where and how agentic development happens.

• Tags:
• AI Agents
• Code Generation
• Developer Tools
• Feature
• Cursor
• Agentic Coding
• Cloud Agents
• Model Swarms