Running an agent locally uses your machine's CPU and RAM. Long tasks can slow down your editor, and running multiple agents in parallel requires managing several terminal windows and branches.
Local agents stop when your laptop sleeps or you close the lid. The work is tied to the uptime of your machine, so you need to be at your desk with the editor open to start or continue a task.
With local agents, you typically keep the editor open while they run. Cloud agents let you queue a task and check back later — the execution continues independently of your machine.
You can dispatch a cloud agent from Slack or the editor to work on a bug without switching context. Cursor's team says they sometimes run multiple models against the same bug in parallel and pick the best result.
Smaller tasks can be queued from cursor.com/agents without opening the editor. The idea is that routine backlog items get dispatched and produce pull requests you review later.
You iterate on a plan locally in Cursor's plan mode, then send it to a cloud agent for implementation. This separates the planning step from the execution step.
Cursor's plan mode lets you iterate with a model to build a detailed implementation plan — which files change, which functions to write, how the pieces connect. Once the plan is solid, you can send it directly to a cloud agent for execution. You stay in creative-mode. The agent handles production-mode.
Some bugs require changes across multiple files, and a single model doesn't always get it right. Cursor's team reports running two or three models against the same bug in parallel and comparing the results. Cloud execution means these runs don't compete for local resources.
Cursor has built a GPT-5 Codex agent harness for long-running cloud tasks. The cloud environment avoids the session timeouts and memory limits that can affect extended local runs.
| Surface | Use case | Notes |
|---|---|---|
| Cursor Editor | Launch from your current codebase context | Full plan mode → cloud handoff available |
| cursor.com/agents | Monitor and manage all running agents | Significantly redesigned; works on any device |
| Slack | Dispatch bug fixes directly from a conversation | No context switch to the editor required |
| Linear | Kick off an agent directly from an issue | Closes the loop between tracking and implementation |
| GitHub | Respond to PRs and issues with agent work | Review output as pull requests in the same repo |
You can queue up backlog items — small migrations, test coverage gaps, config cleanup — from cursor.com/agents and review the resulting pull requests when you're ready.
When a bug comes up in Slack, you can dispatch a cloud agent from the thread instead of opening the editor. The agent works on it, and you review the result when convenient.
Teams using cloud agents can make smaller, more frequent commits and reduce context-switching. The gap between noticing a problem and dispatching a fix gets shorter. Whether this is practical depends on the quality of the agent output and the nature of the tasks.
The core idea is straightforward: run agents on remote infrastructure instead of locally, and access them from multiple surfaces. How well this works in practice will depend on task complexity and model quality.