Cursor Cloud Agents Code, Test, and Ship PRs Without You. 35% of Their PRs Already Do.

On February 24, Cursor shipped Cloud Agents. The name undersells what actually changed.

These are not autocomplete suggestions or tab completions. A Cloud Agent is a fully autonomous AI running in its own isolated virtual machine. It receives a task, writes code to complete it, runs the code, tests whether it works, fixes what breaks, records a video of the whole process, and opens a pull request with the evidence attached. No human in the loop until the PR review.

35% of Cursor's internal merged pull requests are now created by these agents. That number is from Cursor's own engineering team, published this week.

What Cloud Agents Actually Are

A Cloud Agent is a software development environment running entirely in the cloud, assigned to a single AI agent. The agent gets its own computer: a virtual machine with a full operating system, a browser, a terminal, a code editor, and network access. It does not share resources with your laptop or compete with other agents for CPU.

The agent receives a task description (could be a GitHub issue, a Slack message, a Linear ticket) and begins working autonomously. It writes code, runs it in the VM, opens a browser to check the result visually, clicks through the UI to verify behaviour, identifies what is wrong, fixes it, and repeats. When it thinks the task is complete, it records the session as a video with screenshots and logs, then opens a PR against your repository.

You review the PR. If the agent is wrong, you tell it what to fix. It goes back to the VM and tries again.

Automations: Agents That Trigger Themselves

On March 5, Cursor launched Automations alongside Cloud Agents. Automations let you configure agents to start themselves based on external triggers.

Supported triggers at launch:

• A new Linear issue is created
• A Slack message matching a pattern arrives
• A GitHub pull request is merged
• A PagerDuty incident fires
• A scheduled time is reached

This means you can configure: when a PagerDuty alert fires for a specific error pattern, an agent spins up, investigates the logs, writes a fix, and opens a PR for review. The on-call engineer reviews a proposed fix instead of debugging from scratch at 3 AM.

Or: when a Linear issue is tagged "agent-ready", an agent picks it up, implements it, and posts the PR link back to the issue. Product managers who understand what the tag means can effectively route certain classes of work to agents rather than engineers.

The 35% Number and What It Means

Cursor disclosed that 35% of its own internal merged PRs now come from Cloud Agents. This is significant for two reasons.

First, it is a real production number, not a demo. Cursor is using its own product at scale to build its own product. The tasks agents are handling are not toy examples; they are actual engineering work on a production codebase used by millions of developers.

Second, 35% of merged PRs is a high bar. Merged means the code passed review and is running in production. Not just opened, not just drafted. The agent's output was good enough that a human engineer approved it.

Cursor's co-head of async engineering described the experience as moving from "one to three things running at once" to "10 or 20 things running in parallel." Agents handle the implementation while engineers focus on review, architecture, and the tasks that genuinely require human judgment.

What This Means for Your Workflow

The honest assessment: Cloud Agents are not replacing software engineers yet. The tasks they handle well are bounded and specific: fix this bug, add this endpoint, write tests for this module, update this dependency. Open-ended architectural work and anything requiring deep context about business logic still needs humans.

But "bounded and specific" covers a large fraction of the average engineer's week. The routine implementation work, the small bug fixes, the test coverage gaps, the dependency updates. Routing that class of work to agents changes the math on what a small team can ship.

The practical implications for developers:

If you use Cursor already: Cloud Agents are rolling out to Pro and Business accounts. The interface is in the agent panel. Set up your first Automation pointing at a low-risk Linear label and watch what happens.

If you build on GitHub: Agents open PRs just like humans do. Your existing review process, CI/CD pipelines, branch protection rules, and merge requirements all apply. You do not need to change your infrastructure.

If you manage a team: The 35% internal PR number is the benchmark to track. If agents handle 10-20% of your team's PR volume within six months, that is a meaningful productivity shift.

The Competitive Landscape

GitHub Copilot launched Copilot Workspace last year, a similar system where Copilot can take an issue and produce code changes. Devin, from Cognition, was the first widely publicised fully autonomous coding agent. Google's Jules runs inside Gemini Code Assist.

Cursor's differentiation is the combination of computer use (the agent can actually open a browser and verify visual output) and the Automations trigger system (agents start themselves from external events, not just from a human opening Cursor).

The coding agent category is moving fast. What Cloud Agents shipped this week will be the baseline expectation for every developer tool by the end of 2026.

Key Takeaways

• February 24, 2026 — Cursor launches Cloud Agents: autonomous AI running in isolated VMs that code, test, and ship merge-ready PRs
• 35% — share of Cursor's own internal merged PRs now created by Cloud Agents
• 10-20 parallel agents — what Cursor's engineering team runs simultaneously vs the previous "1-3 things at once"
• March 5, 2026 — Cursor Automations launch: agents trigger themselves from Slack, Linear, GitHub, PagerDuty, or schedules
• Video + screenshots + logs — attached to every PR the agent opens, replacing the need for a human to explain what was done
• For developers: Cloud Agents handle bounded, specific tasks well — bug fixes, endpoint additions, test coverage, dependency updates; architectural decisions still need humans
• What to watch: GitHub Copilot Workspace and Google Jules both competing in the same space — the agent PR percentage will become a standard team productivity metric by end of 2026