Sandbox For Agents
e2b-aligned sdk
template families
long-lived runtimes
k8s-backed
Give agents
real hands.
Set gateway env vars once, keep an E2B-aligned SDK, and run agent work in a runtime that stays alive.
Fast to enter. Better when the work gets real.
Get startedExplore SDK
Templates
official + custom
Lifecycle
reconnect + cleanup
Control
files + pty + preview
brain outside->hand in cloud
hand = live
/runtime/hand/live
runtimemainattached session
$attach terminal-hand --agent research-worker
>runtime live | tools mounted | state attached
$git clone acme/agent-playground
$open preview && run test suite
>preview ready | pty attached | artifacts streaming
$reconnect --session agent-hand-live
requested
spec stays predictable
burst
headroom when free
surface
pty / git / preview
The Runtime For Agent Action
Three planes. One boundary for agent execution.
Templates
base / claude / codex / custom
Storage
ephemeral / memory / cloud / nfs / block
Runtime
k8s-backed / observable / long-lived
Why SeaCloud
Easy to adopt. Hard to outgrow.

Familiar entry only matters if the runtime gets better when the work gets heavier.

01
Fast Migration
env first + aligned sdk
02
Runtime Control
templates + builds + storage
03
Production Reliability
k8s + burst headroom + observability
Fast Migration
Adopt with an SDK flow your team already recognizes.

Set env once, then stay close to the public workflow teams already know.

focus
migrate without reset
signal
env first + aligned sdk
outcome
faster adoption
Where It Fits
A hand for real agent work.
Built for work that needs a real runtime boundary.

For coding agents, runtime-owning teams, and workloads that do not fit short jobs.

Common Fit
The moment an agent needs more than one run.

That is where template control and lifecycle stability start paying off.

tooling
real terminals
continuity
live sessions
outputs
artifacts back
Coding Agents
Let agents clone, edit, test, preview, and return artifacts.

Move repo work, installs, browsers, and tool chains into a live runtime.

repos / tests / previews
Runtime Platforms
Ship runtime families for different agent workflows.

Mix official templates with custom images, specs, and storage policies.

official / custom / images
Long Tasks
Keep sessions alive beyond one request.

Use reconnect, recovery, and steady lifecycle control for heavier jobs.

heartbeat / reconnect / burst tolerance
What You Can Verify
Familiar on entry, real at runtime.

It should prove migration ease, runtime depth, and production continuity without feeling like docs.

Check 01
The entry path should feel familiar immediately.
env / create / connect
Check 02
Ready and custom runtimes should both be first-class.
official + custom
Check 03
The control surface should be broader than one-shot execution.
commands / files / pty
Check 04
Longer sessions should stay visible and recoverable.
state / heartbeat / outputs
Check 01
The entry path should feel familiar immediately.

A team that already knows E2B should understand env setup and Sandbox.create on first read.

check
env / create / connect
proof
no relearning
outcome
faster first integration
Bring Runtime Into The Agent Loop
env -> sdk facade -> execution plane
Env
gateway vars set once

Base URL and API key come from the environment first. Template choice stays in app code.

SDK
aligned create / connect / manage

Use the public workflow your team already knows.

Hand
templates / lifecycle / control

Operate through one runtime object.

Environment Setup
set once in shell or secret manager
export SEACLOUD_BASE_URL="https://sandbox-gateway.cloud.seaart.ai"
export SEACLOUD_API_KEY="..."
SDK Surface
Familiar SDK surface.
More capable runtime.

Easy to switch into, but built to stay useful after agents outgrow short-lived execution.

typescript
/env-configured/execution-plane
1import { Sandbox } from "@seacloudai/sandbox"
 
3const templateId = "claude";
4const sandbox = await Sandbox.create(templateId, {
5 waitReady: true,
6 timeout: 1800,
7});
 
9const filePath = "/root/workspace/hello.txt";
10await sandbox.files.write(filePath, "hello from node");
11const run = await sandbox.commands.run("sh", {
12 args: ["-lc", `cat ${filePath}`],
13});
14console.log(run.exitCode, await sandbox.files.read(filePath));
Sandbox.create(...)
commands.run(...)
files.read(...)
SeaCloud NODE

Set env once. Keep the workflow familiar.

Use gateway env vars for config, create through the aligned facade, and move beyond one-shot execution.

Start
Configure through env, then keep the API shape familiar.

Set gateway vars once and adopt without redesigning the agent loop.

Shape
Move from ready templates into your own runtime families.

Control images, storage, startup, and defaults when stock runtimes stop being enough.

Operate
Run the same task longer and more safely.

Reconnect, recover, and keep work alive with visible lifecycle state.

Give Agents A Place To Act
Start with a familiar SDK. Keep the runtime useful later.

Set env once, adopt through the aligned SDK surface, then let the runtime become where agent work actually runs.

entry
env-configured sdk, lower migration friction
runtime
templates, lifecycle, and control that stay useful later