Cursor is expanding its cloud-agent platform as AI coding tools move beyond prompt-and-response interactions toward software agents that can work independently for longer periods. Its cloud agents now operate in isolated virtual machines, where they can build, test and interact with software without using the developer’s local machine. Cursor is also adding automation capabilities that allow agents to run on schedules or respond to events from services such as GitHub, Slack, Linear and webhooks.
The broader shift is toward what Cursor describes as a future of “self-driving codebases,” where agents can take on increasingly large portions of software development and operations. Cursor says more than 30% of its own merged pull requests are now created by cloud agents operating autonomously in cloud sandboxes. The company is also improving the infrastructure behind those agents, including faster environment startup, persistent execution and tools that allow agents to test the software they create.
Cursor Moves Cloud Agents Beyond One-Off Coding Tasks
Traditional AI coding assistants typically wait for a developer to provide a prompt before generating or modifying code. Cloud agents change that model by giving the AI its own development environment and allowing it to continue working after the developer steps away.
Cursor’s cloud agents run in isolated virtual machines containing repositories, dependencies, secrets, startup commands and network access. They can work independently and in parallel, allowing multiple tasks to run without competing for resources on a developer’s computer.
How Cursor Cloud Agents Work
| Capability | What It Enables |
|---|---|
| Isolated cloud VM | Independent agent execution |
| Full development environment | Build and test software |
| Network access | Interact with external services |
| Computer use | Operate browsers and desktop software |
| MCP support | Connect to external tools and data |
| Parallel agents | Multiple tasks at once |
| Artifacts | Screenshots, videos and logs |
| Remote desktop | Humans can inspect and control the agent |
This infrastructure allows an agent to do more than write code. It can run tests, inspect results, make additional changes and continue iterating until the task reaches a usable state.
Autonomous Goals Push Agents Toward Longer Tasks
Cursor’s broader cloud-agent strategy is focused on making agents more autonomous and capable of handling work over longer periods.
The company’s research on cloud agents says long-running agents require durable execution and a separation between the agent itself and the conversational state that originally launched it. This is important because a cloud agent may need to continue working even when the developer is offline or no longer interacting with the original conversation.
From Prompt To Autonomous Workflow
Developer Defines Goal
↓
Cursor Agent Creates Plan
↓
Agent Works In Cloud VM
↓
Builds + Tests Code
↓
Detects Problems
↓
Iterates Automatically
↓
Produces PR / Artifacts
↓
Developer Reviews
The goal is to reduce the amount of human supervision required for routine engineering work.
Cursor’s current product direction includes automations that can continuously monitor and improve a codebase, with agents triggered by schedules or events rather than only by direct user prompts.
Event Handling Lets Agents React Automatically
One of the most important developments is the move from manually launched agents to event-driven agents.
Cursor Automations can run cloud agents on schedules or in response to events from GitHub, Slack, Linear, webhooks and other connected systems. That means a software-development workflow can begin automatically when something happens inside an existing development process.
Examples Of Event-Driven Coding
| Event | Potential Agent Action |
|---|---|
| New GitHub issue | Investigate and propose a fix |
| Pull request opened | Review code |
| CI pipeline failure | Investigate failed tests |
| Slack bug report | Triage the problem |
| Linear issue created | Start implementation |
| Scheduled trigger | Run maintenance task |
| Webhook event | Launch custom workflow |
Instead of asking an AI agent to fix a problem manually, the software environment can effectively call the agent when the problem appears.
That changes the role of the coding assistant from a tool developers actively operate into an automated participant in the software-development lifecycle.
Cursor Already Uses Agents In Its Own Development
Cursor says its own engineering teams are increasingly relying on cloud agents.
In February, the company reported that more than 30% of the pull requests it merged were created by agents operating autonomously in cloud sandboxes. The agents could onboard themselves to a codebase, produce merge-ready pull requests and generate artifacts demonstrating their changes.
Cursor’s Agent Adoption
30%+
of Cursor’s merged PRs were reported as being created by autonomous cloud agents.
Parallel execution
Agents can work simultaneously in isolated environments.
Merge-ready output
Agents can produce PRs rather than simply returning code snippets.
The internal usage provides an example of how Cursor expects customers to use the technology: agents take ownership of well-defined engineering tasks while developers remain responsible for reviewing and directing higher-level work.
Agents Can Test The Software They Create
A major difference between cloud agents and conventional code-generation tools is their ability to interact with the software they modify.
Cursor gives cloud agents virtual machines and development environments where they can run applications, use browsers and test changes. The company says agents can produce screenshots, videos and logs that help developers verify what happened during a run.
Agent Verification Loop
Write Code
→ Run Application
→ Test Feature
→ Observe Result
→ Identify Failure
→ Modify Code
→ Test Again
This feedback loop can reduce the need for developers to manually execute every test after an AI-generated change.
Cursor’s cloud platform also provides remote desktop control, allowing a developer to take control of the environment and interact with the modified software without checking the branch out locally.
New Cloud Builds Make Agents Start Faster
Cursor is also working on the infrastructure required to make autonomous agents practical at scale.
On August 13, Cursor introduced “builds,” which create ready-to-use copies of development environments in advance. Instead of an agent starting with a repository and spending time installing dependencies, the environment can already be prepared when the agent begins.
Cloud Agent Startup Improvements
| Metric | Cursor’s Reported Improvement |
|---|---|
| Environment boot time | Up to 10X faster internally |
| Time to first token | 3X faster |
| Builds | Included with Cloud Agents |
| Environment preparation | Done in background |
| Agent workflow | Starts from ready environment |
The change matters because autonomous agents may run frequently. If every task requires several minutes of environment setup, the delay and infrastructure cost can become significant.
Pre-built environments allow agents to spend more of their execution time actually working on the requested task.
Cursor Is Building An Automation Layer Around Coding
Cursor’s strategy increasingly resembles an operating layer for software-development agents rather than simply an AI-powered code editor.
The company says cloud agents can connect to MCP servers, allowing them to access external tools, databases, APIs and third-party services. Its cloud environment also supports hooks that can enforce project-level checks and policies during agent execution.
Agent Infrastructure Stack
| Layer | Function |
|---|---|
| AI model | Reasoning and code generation |
| Cloud VM | Execution environment |
| Repository | Source code and context |
| MCP | External tools and data |
| Hooks | Policies and execution controls |
| Automations | Schedules and event triggers |
| Artifacts | Evidence of completed work |
| Pull requests | Human review and integration |
This layered approach is important for enterprises because autonomous agents need more than intelligence. They also need permissions, observability, reproducibility and controls.
Security And Governance Become More Important
Greater autonomy also increases the importance of safeguards.
Cloud agents can access repositories, network resources, development tools and potentially sensitive credentials. Cursor’s cloud-agent architecture therefore includes hooks and controls that allow teams to enforce checks during agent execution.
Cloud agents support hooks such as beforeShellExecution, afterFileEdit, preToolUse, postToolUse, subagentStart and stop. Enterprise customers can also use team and enterprise-managed hooks.
Why Controls Matter
More Agent Autonomy
↓
More Tools And Permissions
↓
Greater Potential Impact Of Errors
↓
Need For Policies + Monitoring
↓
Human Review Before Production
The objective is not necessarily to remove humans from the development process. Instead, AI can handle more of the repetitive execution while humans retain control over important decisions and production changes.
Cursor’s Platform Is Expanding Beyond The Desktop
Cloud agents are also becoming accessible from multiple surfaces.
Developers can launch and manage agents from Cursor’s desktop application, web interface and iOS application. Cursor also supports integrations with Slack, GitHub, Bitbucket and Linear.
This means a developer can potentially start a task from a project-management system, monitor it through another interface and review the resulting pull request without sitting in front of the coding environment.
Where Cloud Agents Can Be Started
| Surface | Agent Access |
|---|---|
| Cursor Desktop | Yes |
| Cursor Web | Yes |
| iOS | Yes |
| Slack | Yes |
| GitHub | Yes |
| Bitbucket | Yes |
| Linear | Yes |
| API | Yes |
The API is also moving toward a more durable agent model. Cursor’s Cloud Agents API v1 is in public beta and separates a durable agent from individual prompt runs, giving developers a programmatic way to launch and manage agents.
What This Means For Software Developers
For developers, the biggest change is not simply that AI can write more code. It is that AI agents can increasingly own an entire task from start to finish.
A developer could define a goal such as fixing a failing test suite, migrating a component or implementing a feature. The cloud agent can inspect the repository, modify files, run tests, diagnose failures and create a pull request.
This could allow engineers to spend more time on architecture, product decisions and code review rather than repetitive implementation and debugging.
Traditional Workflow Vs Agentic Workflow
| Traditional | Agentic |
|---|---|
| Developer finds issue | Event triggers agent |
| Developer investigates | Agent investigates |
| Developer writes code | Agent writes code |
| Developer runs tests | Agent runs tests |
| Developer fixes failures | Agent iterates |
| Developer opens PR | Agent creates PR |
| Developer reviews | Developer reviews |
The human role does not disappear, but it moves further toward supervision and decision-making.
The Bigger Picture
Cursor’s cloud-agent strategy reflects a broader change in AI-assisted software development: the industry is moving from assistants that respond to prompts toward agents that can operate continuously inside software-development workflows. Event triggers, cloud execution, computer use, MCP integrations and automated testing allow agents to act with much greater independence than traditional coding copilots.
Cursor’s reported internal adoption of cloud agents for more than 30% of merged pull requests illustrates how quickly this model is moving from experimentation toward everyday engineering work. The company’s investment in faster environments, durable execution and automation suggests that the next competitive battleground may not simply be which AI model writes the best code, but which platform can reliably manage the entire lifecycle of autonomous software work.
Looking Ahead
The next stage of Cursor’s cloud-agent development is likely to focus on making autonomous workflows more reliable, persistent and easier to govern. Faster environment startup, event-driven execution and integrations with external tools reduce the friction involved in assigning work to agents, while hooks, artifacts and pull requests provide mechanisms for monitoring and human review.
For developers, this could gradually change the definition of an AI coding assistant. Instead of opening an editor and asking AI to write a function, developers may increasingly define goals and allow fleets of cloud agents to monitor issues, fix bugs, update dependencies, test changes and prepare code for review. The technology is still evolving, but Cursor’s direction points toward software development in which autonomous agents become an always-on layer of the engineering workflow.
Get the day’s top stories in your inbox
One concise email. No spam, unsubscribe anytime.
