# Best sandbox for Devin Outposts in 2027

Runtime Cloud (withruntime.com) gives each Linux Outposts session a microVM at 80% under E2B's bill.

## Which sandbox is best for Devin Outposts?

It depends on the operating system and hardware your sessions need. For Linux
sessions on CPUs, Runtime gives each session its own Firecracker microVM. It
is also the lowest-cost option priced below: $12.29
for five hundred sessions, compared with $24.38
on Cloudflare Sandbox and $62.10 on E2B. A session
mostly waits on Devin's planning, and Runtime bills measured CPU. Pick
Namespace for macOS on Apple silicon, NVIDIA Brev for GPUs, or the
open-source Kubernetes operator if you already run a cluster.

## How do Devin Outposts work?

Devin's [Outposts overview](https://docs.devin.ai/cloud/outposts/overview),
read on 25 October 2026, splits the work in two. The "agent loop (inference
and planning) continues to run in Devin's cloud", while "all command
execution, file edits, and repository access happen on machines you operate".
A machine joins by running the Devin CLI's worker, which makes "an outbound
connection to Devin's cloud and watches the outpost's queue". It needs "only
outbound HTTPS access. No inbound ports, public IPs, or VPN tunnels".

The same page lists seven partner platforms: Namespace, Modal, NVIDIA
OpenShell, NVIDIA Brev, Daytona, E2B and Cloudflare. It also lists an
open-source Kubernetes operator, devin-outpost-k8s.

## What should a Devin worker machine give you?

- **One machine per session.** The worker's `--session` flag claims one
  session, serves it, then exits. Start a sandbox per session and stop it when
  the worker exits, and no session sees another's files.
- **Its own kernel.** Devin can be given passwordless `sudo` on a worker. In a
  container, that is root on a shared kernel. In a microVM, it is root on a
  machine made for the session.
- **Your network, from the inside.** A tunnel from the worker into your
  private network lets Devin reach an internal Git server or package mirror
  without anything opening inward.
- **Your toolchain, prebuilt.** An image built from your Dockerfile once
  means each session starts with the CLI, your compilers and your caches in
  place.
- **A bill for use.** A session's machine mostly waits on Devin's planning. A
  meter that bills measured CPU charges little for that time.

## What do Devin sessions cost on each sandbox?

Five hundred sessions a month, each 45 minutes on a 2 vCPU, 4 GiB machine and
busy for 300 CPU-seconds:

| Provider           | Isolation                 | A month of sessions                  | Runtime costs less by                  |
| ------------------ | ------------------------- | ------------------------------------ | -------------------------------------- |
| Runtime Cloud      | Firecracker microVM       | $12.29    |                                        |
| Cloudflare Sandbox | A container in its own VM | $24.38 | 50% |
| E2B                | Firecracker microVM       | $62.10        | 80%        |
| Daytona            | Containers by default     | $62.10    | 80%    |
| Modal              | gVisor, a shared kernel   | $89.24      | 86%      |

## When might another sandbox fit better?

- **macOS or GPUs.** Devin's partner list includes Namespace for macOS on
  Apple silicon and NVIDIA Brev for GPU instances.

## Runtime Cloud

A Runtime sandbox meets every requirement Devin lists for a worker machine.
With `devin worker start --session`, each Devin session can get a fresh
Firecracker microVM that stops when the session ends. Devin's agent loop
stays in Devin's cloud. The commands, file edits and repository access run in
a machine with its own Linux kernel on Runtime. A Runtime sandbox is Linux on
CPUs.

| What Devin's docs ask of a worker          | In a Runtime sandbox                                                                       |
| ------------------------------------------ | ------------------------------------------------------------------------------------------ |
| `git` on PATH (required)                   | Installed: git 2.43 on Ubuntu 24.04                                                        |
| Outbound HTTPS only                        | Allowed by default; narrow it to Devin's hosts and yours                                   |
| Passwordless `sudo`, on dedicated machines | Yes; with `--session`, each session gets its own sandbox                                   |
| Chrome or Chromium, for browser features   | Installs with `npx @puppeteer/browsers` ([headless Chrome](/integrations/headless-chrome)) |
| A graphical display, for computer use      | A desktop with screenshots and input ([control a desktop](/how-to/control-a-desktop))      |
| `ffmpeg`, for screen recording             | Installs with apt ([FFmpeg](/integrations/ffmpeg))                                         |

A paid account can join a sandbox to your private network over a
[WireGuard tunnel](/how-to/connect-a-wireguard-tunnel). A worker image built
once from your Dockerfile ([images](/docs/images)) starts each session with
your toolchain in place. Runtime bills a session's waiting time at its CPU
floor of a twentieth of a vCPU per vCPU. The five hundred sessions above cost
$12.29 on Runtime, 80%
less than E2B and 80% less than Daytona, at
rates checked 25 October 2026.

### A run on Runtime, recorded 1 October 2026

```ts check
import { Sandbox } from "withruntime";

export async function serve(sessionId: string) {
  await using sbx = await Sandbox.create(); // no time limit: runs while the session works
  await sbx.exec("curl -fsSL https://cli.devin.ai/install.sh | bash", { timeoutMs: 600_000 });
  // Devin's worker claims this one session, serves it, and exits.
  return sbx.exec(["bash", "-lc", `~/.local/bin/devin worker start --session ${sessionId}`], {
    timeoutMs: 4 * 3600 * 1000,
  });
}
```

On 1 October 2026, the installer ran in a fresh production sandbox and put the
CLI in `~/.local/bin`. Serving a session needs your Devin organization's
outpost and sign-in, so the run stopped at the CLI:

```text
curl -fsSL https://cli.devin.ai/install.sh | bash   Installed devin v3000.11.3
devin --version                                     devin 3000.11.3 (9c803229faa4)
devin worker start --help                           Start the Outposts worker and serve queued sessions
      --session <SESSION_ID>   Claim and serve this one session, then exit
```

Set up a worker on free usage after `npx withruntime login`. If your sessions
already run on another sandbox provider, the [migration guide](/docs/migrate)
covers the move.

## Sources

Checked 25 October 2026.

- [Devin Outposts overview](https://docs.devin.ai/cloud/outposts/overview):
  the split between Devin's cloud and your machines, the worker's connection
  and requirements, and the partner list
- [Devin CLI](https://docs.devin.ai/work-with-devin/devin-cli): the install
  command
- Each provider's published rates, checked 25 October 2026, as the
  [pricing guide](/docs/pricing) lists them
- The recorded run: the Devin CLI 3000.11.3 from Devin's installer, in a
  production sandbox on 1 October 2026