Cursor Upgrades Cloud Agents to Work Autonomously Without Human Prompting

Cursor just pushed a significant upgrade to its cloud agents, turning them from one-shot task runners into always-on workers that respond to events, hold goals across long sessions, and delegate to isolated subagents. The framing from the team is that the agent harness should let agents build and ship software without a human in the loop at every step.

With this release, cloud agents can automatically pick up work in response to events, hold a goal until it's met, and stay on course through long-running sessions. Five concrete changes make that possible.

Agents that wake up on their own

The headline change is subscriptions. Cursor can now monitor your PRs, watch a Slack thread, or run scheduled tasks. Cursor Agent subscribes to an event source (a thread or conversation) and wakes when something happens. Subscriptions are available for cloud agents only, for now.

The most useful default: cloud agents automatically subscribe to PRs they create and drive them to completion, fixing CI and addressing bot comments. In practice that means the agent watches its own pull request, sees a failing test or a review comment from a linter bot, and pushes a fix without you re-prompting it. From Slack you can tell it something like @cursor check back in an hour and keep going until that feedback is in.

This extends the same trigger-action framework Cursor introduced earlier in the year for Automations, but subscriptions add the "keep re-engaging on this thread" behavior on top. The agent is now stateful across events instead of firing once and forgetting.

Parallel work without collisions

Subagents used to share the parent's workspace, which caused predictable problems the moment two of them touched the same files. Now subagents can run on their own virtual machines. Each gets an isolated copy of the project with clean context in its own cloud environment.

That opens two patterns:

• Verification: spin up a subagent in a fresh VM to test the parent agent's changes end-to-end.
• Swarms: fan out independent fixes in parallel, for example run a swarm of subagents to test my app for bugs, each in its own environment.

One thing to budget for: each subagent on its own VM consumes cloud agent compute the same way a solo cloud agent run does, running five subagents in parallel is roughly five times the usage of one. Cursor hasn't published a swarm-specific price; it bills against your plan's existing cloud agent allotment.

Long-lived goals and pinned skills

The new /goal slash command gives the agent a long-lived objective to work towards until it's fully complete. The example prompt from Cursor is /goal fix all flaky tests and make CI green, and it pairs with /loop for recurring check-ins or a custom mode to enforce a playbook.

Custom Modes are the other half of that pairing. Use any skill as a Custom Mode: a skill that stays pinned in the chat. Custom modes keep agents focused on a skill, you can think about it like "always on" skills. From the / menu you pick a skill and press Alt+Enter to promote it into a pinned mode instead of a one-off invocation.

Steering without interrupting

A small but overdue fix to how you correct an agent mid-run: you can now send a message to steer the agent while it's working without interruption. Follow-ups wait for the next tool call instead of cutting the agent off mid-action. Previously, typing a follow-up would kill whatever tool call was in flight. Now it queues cleanly.

Who should care

If you already lean on cloud agents, the practical unlock is fire-and-forget PR loops: open a task, walk away, and let the agent chase CI failures and reviewer comments to the merge line. If you have not touched cloud agents yet, they are included in the Pro tier at $20/month with a $20 pool of usage credits, with heavier usage metered on top.

Two caveats worth flagging. First, the swarm pattern is powerful but expensive by design, so it is best reserved for genuinely parallelizable work like bug hunts across independent modules. Second, reviewers have noted that parallel workers occasionally use placeholders like existing code comments, so you must review the diffs carefully to avoid accidental code deletion. Always-on agents do not remove the need for a human at the merge button.