Cursor 3 Cloud Agents: /in-cloud, Bugbot 3×, and the PR Babysitting Pipeline

Local agents are fast. They respond in seconds, see your filesystem instantly, and cost nothing to start. They also die the moment your laptop lid closes, hit your machine's RAM ceiling on large repos, and serialize every task through a single working directory. For anything that runs longer than a Pomodoro or touches a codebase you can't fit in memory, Cursor 3's cloud agents are the answer the local model can't be.

June 2026 brought three concrete upgrades: /in-cloud for spinning up isolated cloud subagents mid-session (3.7, June 17), reusable environment snapshots that drop cold-start below 10 minutes, and a Bugbot that reviews PRs in 90 seconds instead of five minutes with 10% better detection (June 10). This post covers all three and shows how to compose them into a pipeline that ships while you sleep.

Why cloud agents change the dev loop

The fundamental constraint of local agentic coding is co-tenancy: the agent shares your filesystem, your CPU, and your network connection. When a local agent spins up a test suite that takes eight minutes, you are blocked for eight minutes. When it tries to analyze 400 files simultaneously, it contends with your editor's language server. And when you close your laptop and go to lunch, the session dies.

Cloud agents run on Cursor's VM infrastructure. Each one gets a dedicated environment, clones the repo fresh, and keeps running whether your machine is on or not. The tradeoff is cold-start latency — historically 20-30 minutes for a large Node.js monorepo. The June 17 snapshot feature cuts that to under 10 minutes for most repos, which is what makes cloud agents practical for short-horizon tasks like PR review or a focused bug fix.

The Agents Window fleet dashboard

Cursor 3 (April 2, 2026) reorganized the interface around the Agents Window — a persistent sidebar that shows every active agent session across all your repos, local and cloud, in one place. Before 3.0, checking on a long-running agent meant finding the right terminal tab. Now it's a live dashboard with status, elapsed time, and the last output line for every session.

The Agents Window introduced three session types that are now fully mature in 3.7:

• Local sessions — run in your open workspace using the filesystem and LSP. Start in 2-3 seconds, ideal for fast-iteration tasks.
• Cloud sessions — run on Cursor VMs, persist across laptop sleeps, support long-running jobs. Start via the cloud icon in the Agents Window or the /in-cloud command.
• Cloud subagents — isolated child sessions spawned from a parent cloud session. This is what /in-cloud creates when called from inside a running agent.

/in-cloud: isolated cloud subagents on demand

The /in-cloud command, shipping in Cursor 3.7 (June 17), lets a running agent — local or cloud — spawn an isolated cloud subagent for a specific subtask. The parent delegates, the child runs on its own VM branch, and when the child completes, its output is handed back to the parent.

# From within any Cursor session, delegate to a cloud subagent:
/in-cloud "run the full test suite against the auth-refactor branch and
report which tests fail and why. Do not make any code changes."

# The cloud subagent:
# 1. Provisions a VM with the repo
# 2. Checks out auth-refactor
# 3. Runs the test suite (takes as long as it takes, you can close your laptop)
# 4. Returns a structured failure report to your local session

The isolation guarantee is the key property. A cloud subagent can't accidentally modify files in your local working directory. It operates on its own clone, on its own branch, in its own VM. If it crashes or produces garbage, you close it from the Agents Window and nothing local is touched.

The June 4 SDK update added local.customTools support and nested subagent capability — cloud subagents can now spawn their own cloud subagents, capped at three levels deep in cloud context. This enables fan-out patterns: a parent analysis agent that spawns one subagent per directory, runs them all in parallel, and merges findings.

# Parent cloud session:
"Analyze the security posture of each top-level package in this monorepo.
For each package, spawn a cloud subagent via /in-cloud scoped to that
directory only. Each subagent should run the security-audit skill and
return a JSON report. Merge the reports and highlight the top 5 findings
across the whole repo."

# This spawns: /in-cloud for packages/api, /in-cloud for packages/web,
# /in-cloud for packages/shared, etc. — all running in parallel VMs.

Bugbot 3.0: speed, cost, detection

Bugbot — Cursor's automated PR review agent — got a major efficiency upgrade on June 10. The numbers from Cursor's release notes are concrete enough to plan around:

The speed improvement comes from parallelizing the file-level analysis passes that previously ran sequentially. Bugbot now spawns parallel subagents per changed file group, aggregates findings, and deduplicates before posting comments. The 22% cost reduction is a byproduct of the same architectural change — parallel smaller passes are cheaper than one large sequential context.

The 10% detection improvement is more interesting. Cursor's team hasn't published the full methodology, but the June 10 notes describe better handling of multi-file bugs — issues where the root cause is in one file but the symptom appears in another. The previous Bugbot analyzed files in isolation; the new one correlates cross-file call graphs before flagging.

You can trigger Bugbot on any PR, or add it to pre-push via the June 10 update's /review pre-push support:

{
  "bugbot": {
    "enabled": true,
    "triggerOn": ["pull_request", "pre_push"],
    "autoComment": true,
    "blockMergeOnSeverity": "high"
  }
}

/babysit: PR prep while you sleep

/babysit, landing in 3.7, is the highest-leverage feature in this wave for teams shipping regularly. Point it at a branch and it does the full PR preparation loop as a cloud session: runs tests, applies Bugbot, fixes lint, rebases against main, and leaves the branch in a mergeable state.

# Hand a branch off to the cloud and go to sleep:
/babysit "auth-refactor"

# Cursor 3.7 will:
# 1. Provision a cloud VM with the repo
# 2. Checkout auth-refactor
# 3. Rebase against main (handles conflicts, doesn't merge if unresolvable)
# 4. Run the test suite — fix any failures it can (lint, type errors, simple breaks)
# 5. Run Bugbot — fix issues it can, leave a comment for issues it can't
# 6. Push the updated branch
# 7. Notify you via the Agents Window when done (or when it gets stuck)

The critical behavior to understand: /babysit stops and surfaces problems rather than silently plowing through them. If a merge conflict requires human judgement, the session pauses and flags it. If a test failure isn't fixable with local edits (e.g., a broken external API dependency), the session reports it without making the situation worse. This is the correct default — you want to wake up to a clean branch, not to 30 commits of increasingly desperate auto-fixes.

A complete cloud-first pipeline

Here's how to combine all three features into a pipeline that lets you write code locally, delegate the verification and prep to the cloud, and merge in the morning.

# Step 1: Implement locally (fast, LSP-aided, instant feedback)
# Work in Cursor as normal. Commit your implementation on a feature branch.

# Step 2: Delegate full test analysis to a cloud subagent
/in-cloud "run the full test suite on branch feature/auth-refactor.
Report all failures with stack traces. Do not modify any files."

# Step 3: Fix failures locally using the report
# The cloud subagent returns a structured failure report.
# You fix the 2-3 issues locally (fast, you understand the code).
# Commit the fixes.

# Step 4: Hand off PR prep to /babysit overnight
/babysit "feature/auth-refactor"
# Close your laptop. /babysit runs on Cursor's cloud:
# - Rebases, runs Bugbot, cleans lint, pushes.
# - Notifies you via Agents Window when ready or stuck.

# Step 5: Wake up, review the Agents Window
# If green: open the PR, request review.
# If stuck: read the blocker report, spend 5 minutes fixing, re-run.

The loop works because each phase plays to different strengths. Writing code is a local task — you want the full IDE, the LSP, the instant feedback. Understanding failures is a local task too — you need to think, not just run. But mechanical work (running long test suites, rebasing, lint) maps perfectly onto cloud agents: deterministic, slow, and something you'd rather not be watching.

Skills for cloud agent work from skills-hub.ai

Cloud agents load the same SKILL.md files as local agents — the skills travel with the session. A few skills on skills-hub.ai are specifically useful for cloud agent workflows:

• cursor-cloud-agent-workflow — our new skill (just published to the registry) for setting up and managing Cursor cloud agent pipelines: snapshot configuration, /in-cloud fan-out patterns, Bugbot tuning, and /babysit setup.
• cursor-parallel — parallel local task decomposition for Cursor Composer 2.5, good for the local implementation phase.
• code-review — complements Bugbot when you want a skill-guided review in addition to Bugbot's automated pass.

# Install the new cloud agent workflow skill
npx @skills-hub-ai/cli install cursor-cloud-agent-workflow

# The skill wires into any Cursor cloud session automatically
# when loaded into .cursor/rules/ or a SKILL.md in your repo root

Browse all Cursor-compatible skills at /cursor-rules or filter by the productivity category at /browse?category=productivity.

If you're evaluating whether Cursor 3's cloud agents fit your workflow, the honest answer is: they're worth it if your test suite runs longer than three minutes or if you ship more than one PR per day. Below that threshold, the cold-start overhead still eats the savings. Above it, the pipeline above gives you back meaningful hours per week — and that math only improves as Cursor optimizes snapshot startup further.