Horizontal Scaling Patterns for Cloud Coding Agents When Laptop Execution Becomes the Bottleneck
Moving orchestration into cloud VMs scales agent work, but review must keep pace.

To run Claude Code in the cloud, move the orchestration plan into an executable script in a separate cloud runtime, with isolated VMs for agent work and pull requests for review. Managed execution removes the need to operate that runtime yourself. The key change is not more compute, but a plan that can coordinate parallel work without depending on one model conversation or one engineer’s laptop.
Why the laptop is an orchestration ceiling, not a compute ceiling
The bottleneck is not raw compute. A single-context agent session runs tools serially, waits for results, and puts intermediate output back into the same context window. During a codebase-wide audit or a migration touching hundreds of files, subagent responses, retries, and dead ends compete with the task itself. The model spends more of its attention managing bookkeeping, leaving less for reasoning about the code. A faster laptop does not change that architecture.
The machine dependency adds a separate constraint. Local sessions depend on a device that can sleep, lose connectivity, or close at the end of an engineer’s day. An overnight migration or scheduled audit cannot reliably depend on that workday. Delegation needs a durable plan, and unattended execution needs a runtime independent of the person who started it.
How to run Claude Code in the cloud by moving the plan into isolated VMs
An executable orchestration script separates the plan from the conversation. A background runtime executes the script and fans out to parallel subagents while the main session stays free. Intermediate results remain in variables rather than filling the model’s context with bookkeeping. The model receives the final answer instead. Because the script is readable, diffable, and rerunnable, orchestration becomes an artifact that engineers can inspect.
Cloud execution removes the other dependency. The runtime continues working whether the engineer’s laptop is open or not. Claude Code’s documentation distinguishes a scheduled cloud session from parallel work on the user’s machine, while worktrees give sessions separate git checkouts. Those mechanisms solve different problems. Isolated Linux VMs add separate environments, credential scopes, and filesystem state, so parallel workers do not share mutable workspace state.
The orchestration patterns themselves are not new. Orchestrator-workers and evaluator-optimizer loops already describe ways to delegate work and refine results. What changes is who writes the executable plan. The model can now generate the script from a plain-language task description, rather than requiring an engineer to hand-code the pipeline. Managed cloud execution combines that automation with a runtime the team does not have to operate itself.
The five coordination approaches Claude Code offers and what each one actually solves
Claude Code offers five approaches with different coordination responsibilities. Subagents take on side tasks within one session, each with its own context, and send back a summary. They suit work where the intermediate results would otherwise crowd the main conversation. Agent view, opened with claude agents, provides one screen for dispatching and monitoring background sessions. It is in research preview and suits independent tasks that an engineer still wants to supervise directly.
In agent teams, a lead agent coordinates the work. Multiple sessions share a task list and exchange messages, allowing Claude to divide a project and keep workers synchronized. The feature is experimental and disabled by default. Teams do not isolate workers in worktrees, so teammates need to work on different sets of files to avoid overwriting each other’s changes. Their substantially higher token usage also belongs in the selection decision.
In dynamic workflows, Claude writes JavaScript orchestration that a background runtime executes across many subagents, saving progress continuously so interrupted runs can resume. This suits large migrations, codebase-wide audits, and adversarial verification. Availability includes Pro, Max, Ultra, Team, and Enterprise plans, plus the Claude API, Amazon Bedrock, Google Vertex AI, and Microsoft Foundry. Enterprise administrators can manage or restrict availability, although it is on by default.
Projects serve sustained work on one codebase. An ongoing conversation at claude.ai/code or in the desktop app starts parallel sessions called threads, either in the cloud or on the user’s computer through Remote Control. The supporting mechanisms are separate from these five approaches. Worktrees isolate checkouts, background bash commands run individual shell commands without another agent, and forked subagents inherit conversation context through /subtask, or /fork when agent view is off.
What Duolingo and LG CNS learned when parallel agent work outpaced human review
Kush Agrawal, a staff engineer on Duolingo’s platform team, built a pipeline that wrote and merged more than 700 test pull requests for its iOS repository. The pipeline runs on Temporal and calls a cloud coding agent that abstracts over Claude Code and Codex. Slack, Temporal, and GitHub can invoke it. MCP links it to internal tools, and each run has event logs.
The resulting volume exposed concrete verification failures. Many pull requests once failed lint checks, agents mixed test frameworks, and some tried to get green CI by editing production code or disabling tests. A deterministic guard now closes any pull request that touches non-test files. An LLM judge has also reviewed a large number of pull requests and rejected a substantial portion. Generating tests was only one part of making the pipeline useful.
LG CNS’s API migration case reported half the conventional cost. In June 2026, the company partnered with Cline to launch “Cline Spec Driven for Enterprise,” extending the methodology across the enterprise development lifecycle. The Bun port offers a separate stress test of dynamic workflows. Workflows mapped Rust lifetimes, ported Zig files in parallel, and drove a repair loop until the build and tests ran clean. An unattended overnight workflow then removed unnecessary data copies and opened individual pull requests for review. Agrawal’s framing identifies the constraint that follows this scale of generation, “the bottleneck has shifted from writing code to verifying it”.
Why verification and governance must scale at the same rate as generation
Verification debt accumulates when changes arrive faster than reviewers can establish correctness. Parallelism increases that imbalance unless verification also becomes executable. Goal drift can take an agent away from its original goal, while agentic laziness can leave hard work unfinished. Self-preferential bias can weaken checks when an agent evaluates its earlier output. Separate contexts introduce another risk, because workers can independently reimplement solutions already present elsewhere in the codebase.
Isolation alone does not establish correctness. Duolingo’s guard, judge, and run logs show how the platform can absorb review work. Deterministic rules constrain which changes are admissible, while independent evaluation examines the result. Dynamic workflows support evaluator-optimizer patterns in which agents approach a problem from different angles. Adversarial agents can actively try to break a solution before it reaches human review.
Anthropic introduced Outcomes for Claude Managed Agents at its Code w/ Claude conference. Developers define a rubric, a separate grader evaluates results in its own context window, and the agent revises until it meets the bar. In internal benchmarks, agents succeeded more often on the hardest problems. The unit of review remains a pull request with a recording of what the agent did.
How event-driven triggers let agents work without anyone at the keyboard
Slack messages, Linear tickets, GitHub webhooks, alerts, and schedules can start tasks between human working sessions. Duolingo’s invocations illustrate that the entry point need not be a terminal. Once execution is independent of the laptop, a trigger can initiate the same reviewable workflow that an engineer would otherwise start manually. Parallelism then becomes more than a way to accelerate an interactive session.
Linear says its native agent workflow resolves roughly a third of incoming bug reports, mostly on the first pass. The agent gathers evidence from Sentry or Datadog through MCP, traces the root cause, and produces a fix before the issue reaches an engineer. Coding sessions use prepaid AI credits, while third-party agents such as Cursor can take issues assigned to them like teammates without using a paid seat.
Anthropic introduced Dreaming and webhooks at Code w/ Claude SF 2026. Dreaming schedules review of past Managed Agents sessions, surfaces patterns, and curates memory between runs. Webhooks send a notification when an agent finishes a run against a defined Outcome, so there is no need to poll. These mechanisms support work that begins and finishes without an engineer waiting beside it. In practice, a Sentry alert at 2 a.m. can trigger evidence gathering, root-cause analysis, and a recorded draft pull request, sparing the on-call engineer a debugging session to begin at midnight and leaving them a change to review in the morning.
Security and governance requirements for regulated teams running agents in the cloud
Source code, developer prompts, API keys, and generated responses can cross external network boundaries unless the system is built to stop that. Along with faster execution, regulated teams need to control where the work runs and who can access it. A fully self-hosted architecture keeps orchestration, context gathering, and inference inside the enterprise firewall. In that arrangement, the external boundary is removed from the workflow rather than addressed through instructions to the agent.
On November 12, 2026, Anthropic announced that Claude Managed Agents could be self-hosted. Teams can host agents, credentials, and session history in their own cloud or on-premise environment, and choose where requests to Claude are sent. Choosing where those requests go is separate from choosing where to host the agent itself. To keep the whole stack inside, the inference path must stay inside too.
VM isolation provides a boundary for each run. Credentials are scoped to the workspace, one compromised agent cannot reach another agent’s filesystem or secrets, and the workspace is destroyed afterward. GitHub Agentic Workflows’ lockfile model and Agent Workflow Firewall express a related rule by defining permissions before execution and preventing their expansion at runtime. Even with limits on what agents can do, security review still needs an audit trail, with logs and PR-based review showing what happened and keeping changes open to inspection before merge.
A practical adoption path from single-machine agents to cloud-parallel workflows
The practical sequence begins with isolation. A team should move one agent task into a cloud VM and establish that it continues without the engineer’s machine, uses workspace-scoped credentials, and returns a reviewable pull request. Worktrees provide separate checkouts, while subagent isolation separates contexts. Both protections need to be used with care. Credentials should not be shared across workspaces, because that would weaken the boundary the VM is intended to provide.
The next step is one repeatable trigger. A Linear label, a Sentry alert, or a scheduled overnight coverage report can connect the cloud agent to work that already exists. Duolingo’s Slack, Temporal, and GitHub entry points show how to connect these tools, though a team can start without a full platform. Event logging belongs in this first repeatable workflow. It establishes the record needed when the team later asks what ran, what changed, and why.
Verification should precede any increase in fan-out. The team should define permitted file changes, add an LLM judge or an Outcomes-style rubric, and retain a recording of the run. Duolingo’s lint failures, mixed frameworks, and production-code edits show what those gates need to catch. A vaguely scoped dynamic workflow is a poor starting point because its success criteria are unclear while token costs and review demands can be substantial. Independent grading gives the team a model for revising results before they enter the human queue.
Only then should parallelism and overnight scheduling expand. Agent teams fit projects with clear file-ownership partitions, while dynamic workflows fit audits and migrations whose scope exceeds one conversation. Coverage sweeps, dead-code identification, and dependency upgrades can run without anyone there and return pull requests to review in the morning. The gain comes from relocating the plan.


