How Engineering Teams Delegate AI Coding Tasks at Scale Without Assigning VMs to Individual Developers
Shared agent pools beat per-developer VMs, but review becomes the limit.

A multi-harness cloud coding agent platform lets a team send tasks to a shared pool of isolated environments that run different agent harnesses, with VM capacity shared across developers. The practical model combines existing workflow triggers, parallel execution, and central governance, with pull requests as the reviewable output. Scaling succeeds when the team can evaluate and merge the output of additional agents.
Why giving every developer their own agent VM is the wrong model for team-scale AI coding
Agent demand is bursty. A developer may need five agents running in parallel for two hours, then none for the rest of the day. A reserved VM fits neither period particularly well, while multiplying idle machines across a team adds cost without adding throughput. The allocation looks fair, but it ties capacity to headcount independently of workload.
Individual provisioning also scatters credentials, code, and agent actions across machines without a central audit trail. That creates an enterprise compliance problem before it becomes a workflow problem. The better analogy is a CI/CD runner pool. Teams no longer needed a build server for each engineer once shared, on-demand runners better matched the work they had. Cloud agent pools work the same way for coding tasks and also need central control over how tasks run.
What a shared cloud agent pool actually looks like in practice
A cloud agent pool is a fleet of on-demand, isolated execution environments, each a Linux VM or container, available to team members and automated triggers. A task enters an environment with the repository, the agent performs the work, and a pull request returns for review. The environment is shared execution capacity. This distinction lets the team delegate work without assigning permanent machines to the people requesting it.
Providers implement that boundary in different ways. Claude Code on the web runs on provider-managed VMs, while Team and Enterprise organizations can route sessions to self-hosted environments on their own servers. Codex cloud gives each task an isolated, OpenAI-managed container preloaded with the repository, with internet access disabled during the agent phase by default. Cursor cloud agents clone the repository into an isolated cloud environment and open a pull request. Its self-hosted workers became generally available March 25, 2026, and expanded September 2, 2026, keeping code-touching processes on team infrastructure while orchestration and model inference remain in Cursor’s cloud.
Other harnesses differ in how they organize execution. Jules clones the repository into a cloud VM and writes an editable plan before changing code, then implements the task and opens a pull request. Devin gives each session a cloud environment with a shell, browser, and code editor, and as of August 2026 can split large tasks across parallel agents in isolated VMs. The common review boundary is the pull request. It is the unit of work rather than the session, because a human can inspect the diff, request changes, approve it, or reject it before it reaches the main branch.
How can engineers trigger cloud agents from the tools they already use?
Adoption depends on where delegation begins. Cursor cloud agents accept an @cursor mention in Slack, Devin accepts an @-mention, and Jules exposes a public API that connects to Slack. A developer can therefore delegate from the channel where a bug was reported. These are distinct entry points, however, rather than evidence that every harness offers the same Slack integration.
GitHub provides another route into the pool. Codex takes tasks from @codex mentions on issues, while @codex review on a pull request asks it to run a review pass. A non-review mention on a pull request instead starts a legacy cloud chat using that PR as context. GitHub Copilot’s coding agent starts when an issue is assigned to Copilot through github.com, GitHub Mobile, or the GitHub CLI. The distinction between a task trigger and a review trigger affects what the team is actually delegating.
Delegation also extends beyond the desktop. Claude Code tasks can start at claude.ai/code or through the --cloud flag, sessions can be monitored from mobile, and any session can be pulled into a local terminal. Cursor agents are manageable through its web interface, native iOS app, desktop application, Slack, GitHub, Linear, or API, while schedules and webhooks support unattended work. Jules’s API connects Linear to its execution workflow, providing a route from an issue to an implementation and pull request. Linear Agent adds investigation before implementation, following team guidance and gathering evidence through MCP from tools such as Sentry or Datadog.
Running agents in parallel and why the bottleneck shifts to review, not throughput
A shared pool enables genuine parallel execution. Multiple agents can work simultaneously on different tasks, each in an isolated environment and each producing a pull request, without the team provisioning machines. That changes how much work can be attempted at once. It does not, by itself, change how much completed work the team can safely accept.
The operating model becomes more demanding as delegation deepens. Interactive pair programming involves one to three agents with a developer watching in real time. Parallel orchestration spreads attention across concurrent threads, with selective intervention. With fully autonomous cloud execution, developers leave the agents to run and then look at the pull requests they produce. Teams are also experimenting with specialized Planner, Architect, Implementer, Tester, and Reviewer agents that hand work to one another instead of assigning the entire task to a single agent.
Merge and integration concentrate the actual time cost once agents can produce diffs in parallel. Without stronger review discipline, a larger pool produces a larger queue of unreviewed pull requests, which is worse than an unstarted task queue because it creates the illusion of progress.
Automated triage and review workflows that keep the PR queue from becoming the new backlog
Automated first-pass review addresses that constraint without requiring a proportional increase in human reviewers. Its role is to handle triage and routine scrutiny so that humans receive the decisions that need their judgment. Review begins before the final handoff. GitHub Copilot’s coding agent pushes commits to a draft pull request as it works, retains inspectable session logs, and tags the team when it is ready for review. It also picks up review comments as follow-up work.
That workflow preserves an explicit approval boundary. A human must approve Copilot’s pull requests before CI/CD workflows run, so branch protections stay in place. Codex cloud has an automated review pass through @codex review that a developer can ask for on an open pull request before a human starts reviewing it. Instead, each reduces the work required to assess a proposed change.
Triage can reduce the burden even earlier. Linear uses its agent internally to resolve roughly a third of incoming bug reports, mostly on the first pass, by gathering evidence from Sentry or Datadog through MCP and tracing the root cause in the codebase. That removes investigation work before an engineer needs to take it on. In these workflows, agents do the first pass and humans have the final say on what gets merged. The PR remains the decision artifact, while automation lowers the cost of reaching an informed decision about it.
Governance, security, and audit controls that make fleet-scale delegation safe for enterprise teams
Central governance is a prerequisite for enterprise delegation. Without it, fleet operation creates credential sprawl, opaque audit trails, and uncontrolled data exposure. SAML SSO and SCIM provisioning provide the identity-lifecycle baseline, including the ability to revoke access when someone leaves. Provisioning alone is not sufficient. The same system that enables delegation must also support withdrawing that authority.
Audit evidence must cover the work itself. Every agent run, file touched, pull request submitted, and API call must be logged with a timestamp and user identity. For SOC 2 Type II, auditors need evidence that controls operated consistently across the audit period. Agent activity therefore needs to reach the enterprise SIEM centrally. Otherwise, the team has to gather evidence from scattered developer sessions for the audit.
Codex cloud’s default-offline agent phase has the strongest network-isolation posture of the major providers described here, while Cursor’s self-hosted workers keep code-touching processes on the team’s infrastructure and connect outbound over HTTPS. As of August 2026, Claude Code also lets Team and Enterprise organizations send cloud sessions to self-hosted environments. Enterprises also need Zero-data-retention mode and code kept out of vendor model training by default, and they still need to set up central logging and data-handling policy when they use self-hosting.
Choosing the right agent harness for fleet work without locking the team in
The harness determines the operating experience around the model. The optimal harness varies by workload, so selection is a workload decision that remains open to revision. Claude Code fits long-horizon, multi-file refactors requiring deep repository reasoning, with MCP integration and sub-agent orchestration for breadth-first exploration. Codex cloud fits isolated task queues where the default-offline agent phase is a central requirement, with automated PR review available through @codex review.
Other workloads place different demands on the harness. Cursor cloud agents suit visual IDE workflows with parallel sub-agents, with self-hosted workers available for teams with data residency requirements. Devin fits autonomous ticket execution where people give little direction while the task runs.
Reversibility is part of that selection decision. Each harness has its own trigger model, context format, and integration pattern, so deep dependencies on a specific API create migration costs when the harness changes. Those interfaces changed significantly in 2026. The architectural counter is a shared environment layer of isolated VMs capable of running Claude Code, Codex, Cursor, or OpenCode interchangeably. This separates harness choice from the team’s workflows, integrations, and credentials, rather than making each change of agent a change of operating model.
What fleet-scale delegation produces in practice, measured in pull requests and engineering hours
To measure how well the fleet works, teams can track merged, reviewable pull requests and engineering hours freed for work that needs more judgment. Agent counts and dispatched tasks measure activity instead. Nubank used Devin to handle repetitive migration subtasks autonomously across its Data, Collections, and Risk business units. Those migrations took weeks instead of months or years, and the time saved was measured in engineering hours.
The result depended on more than parallel execution. Fine-tuning Devin on examples of prior manual migrations roughly doubled task completion scores and substantially reduced per-subtask time. Those examples showed what the output had to look like to be accepted. The broader pattern favors well-scoped, repetitive work, including migrations, bug triage, and test coverage expansion, where agents can apply a consistent approach across similar tasks.
Teams need to specify both what task an agent should attempt and what good output looks like. A vague description dispatched across a fleet produces divergent pull requests, leaving reviewers to reconcile the ambiguity. The architecture supplies capacity, existing-tool triggers make it accessible, and governance keeps execution accountable. Review workflows then convert that capacity into accepted changes.


