Now available: Managed Agents and Depot Sandboxes

wpnews.pro

Stay in the loop #

Today we're launching two products: Managed Agents, which runs the coding agents you already use from Claude, OpenAI, and Devin on Depot, and Depot Sandboxes, isolated Linux machines you can create from your own code with the Sandbox SDK.

A growing share of the code teams ship is written by agents, and those agents need what any engineer needs to do the work: a real machine, a warm cache, the right secrets, and a place where the rest of the team can see what happened. That's part of software delivery now, alongside source control, builds, and CI, so it belongs on the same infrastructure.

One fleet for builds, CI, and agents #

Managed Agents and the Sandbox SDK both run on Depot Sandboxes: microVMs on Depot Metal, the same bare-metal compute and storage that runs Depot CI jobs. Managed Agents uses sandboxes to run sessions for the agent providers you connect. The Sandbox SDK hands you the sandboxes directly.

We built most of what sandboxes can do today because Managed Agents needed it. Agents needed to pick up a session where they left off, so we built snapshots. They needed to build real projects, so every sandbox gets your Depot Cache. Each piece then went into the SDK, so anything our agents can use, yours can too.

Managed Agents: bring the agent you already use #

Claude, OpenAI, and Devin all let you run agent workloads on your own compute. With Managed Agents, Depot supplies that compute. You start sessions through your provider, and when one needs a machine, Depot boots a sandbox, starts the provider's runner or worker inside it, and handles cleanup.

At launch you can connect:

Claude Code : sessions you start in Claude Code on the web, run through a self-hosted environment. The agent loop and its tools both run in the sandbox.
Claude Managed Agents : agents you define in the Claude Console and drive over the API. Anthropic runs the agent loop, and Depot runs its commands and file operations.
OpenAI : sessions you create through the Agents API with a self-hosted environment.
Devin : sessions on a Devin Outpost.

What you get:

Your workflow stays the same. You keep your provider account, your agents, and your prompts. Depot supplies the machine.
Nothing to operate. There's no worker to deploy, no VM to keep warm, and no runner image to patch.
A machine sized for the job. Each session gets its own sandbox: 4 vCPUs and 16 GB of memory by default, configurable per connection from 2 vCPUs and 8 GB up to 16 vCPUs and 64 GB.
Work that continues without you. Sessions run on Depot, not your laptop, so you can close the lid.
Pick up where you left off. Depot snapshots the session's workspace and home directory. When you come back to a conversation, the new sandbox starts with the agent's files in place.
Every run in one place. TheAgent runs page shows sessions from every connected provider: which are running or waiting for input, how long each took, and why one failed. Your whole team sees them.

Depot Sandboxes: build your own on the same machines #

A sandbox is a full Linux microVM that you create, use, and stop from your own code. It can install packages, run your test suite, and run Docker. The agent doesn't have to live in the sandbox, either. It can run anywhere and use the sandbox to execute commands.

import {createClient, Sandbox} from '@depot/sandbox'

const client = createClient({token: process.env.DEPOT_TOKEN!, orgID: process.env.DEPOT_ORG_ID})
const sandbox = await Sandbox.create(client, {architecture: 'arm64'})

const command = await sandbox.runCommand({cmd: '/bin/sh', args: ['-c', 'echo hello from depot']})
await command.wait()
console.log(await command.stdout()) // "hello from depot\n"

// Save the sandbox's files, then boot a new sandbox with them restored
await sandbox.fs().writeFile('/home/runner/notes.txt', 'hello')
const snapshot = await sandbox.snapshot()
const copy = await Sandbox.create(client, {snapshot})
console.log(await copy.fs().readFile('/home/runner/notes.txt', {encoding: 'utf8'})) // "hello"

await Promise.all([sandbox.stop({blocking: true}), copy.stop({blocking: true})])

The SDK gives you:

Size and architecture. Choose 2 to 64 vCPUs, memory, and disk, on x86 or Arm.
Your CI secrets. Expose your organization's Depot CI secrets to the sandbox's commands as environment variables.
Depot Cache by default. Every command gets your organization's cache credentials, so tools like sccache, Turborepo, and Nx start warm.
Snapshots. Save a sandbox's home directory and workspace, and boot new sandboxes from them.
Commands and files. Stream command output as it arrives, and read and write files through an interface modeled onnode:fs/promises .

Get started #

To connect an agent provider:

Open Settings → Connections → Agent providers and connect your provider with credentials from its console. TheManaged Agents docs show where to find them forClaude Code ,Claude Managed Agents ,OpenAI , andDevin .
Optionally, change the connection's sandbox size.
Start a session the way you already do, and watch it appear in Agent runs .

To use sandboxes from your own code, install the SDK with pnpm add @depot/sandbox, set DEPOT_TOKEN and DEPOT_ORG_ID, and follow the SDK quickstart. The Depot Sandboxes overview covers how sandboxes work.

Pricing #

Managed Agents, Depot Sandboxes, and Depot CI share one pool of included compute usage. On Developer and Startup plans, usage beyond that allowance costs $0.00005 per vCPU-second. Larger sandboxes consume the allowance faster. For included usage and plan details, see pricing.

Managed Agents sandboxes for Claude Code, Claude Managed Agents, and OpenAI stay running for five to ten minutes after the agent becomes idle, so a quick reply can use the same machine. That idle time counts toward compute usage.

Depot rates cover sandbox compute, not your agent provider's model or subscription charges.

Current limits #

Sandboxes run Linux. Managed Agents sandboxes run on x86.
When a session goes quiet and its sandbox stops, a new message starts a new sandbox from the latest snapshot.
Snapshots save files, not running processes. Dependency folders such as node_modules aren't saved for agent sessions, so the agent reinstalls them.
Managed Agents sessions can't use your Depot secrets yet.
Each provider's own plan requirements apply. For example, Claude Code self-hosted environments need a Claude Team or Enterprise plan.
The SDK is Node.js only, and stopping a sandbox is final. To come back to its files later, snapshot it first.

What's next #

We'd like to hear which agents you want to run on Depot next and what you build with sandboxes: tell us in Discord or through support.

source & further reading

depot.dev — original article CI is changing How I delegate the work, not my judgment Why SOCI belongs in the build