Keep the workspace, not the process tree
MonkeyBox treats the container as replaceable and keeps durable state in the workspace path, so pause and resume fit real build and agent loops.
MonkeyBox
Beta
A container you can keep working in.
Create durable Docker-backed workspaces for AI agents, dev workflows, and sandboxed services without hand-building the control plane around pause, resume, snapshots, templates, and public ingress.
One box surface across SDK calls, CLI jobs, dashboard views, and org-scoped auth.
Beta note: the public surface is live and usable, but some box APIs and operational details may still evolve as MonkeyBox hardens.
Runtime Surface
Create the box, run the setup, keep the workspace.
const box = await monkey.boxes.create({
name: 'eval-runner',
image: 'default',
httpPort: 3000,
})
await box.exec('python scripts/bootstrap.py')
const snapshot = await box.snapshot({ name: 'baseline' })Persistent `/home/monkey`
Pause the box and keep the working state that matters.
Templates and snapshots
Move from one good environment to a reusable baseline quickly.
CLI, SDK, and dashboard parity
Use the same box model whether a human or agent is driving it.
Why MonkeyBox
The workspace model for teams who need more than a fire-and-forget job.
MonkeyBox is for code, agents, and services that need a durable place to live between runs without pushing you down to host-management first.
Start from something repeatable
Use the built-in image, restore from a snapshot, or build an org-owned template when the default environment is not enough.
Drop into the box when you need to
One-shot exec and PTY-backed terminal sessions both exist, which covers scripted automation and interactive debugging on the same runtime.
Expose services without extra plumbing
Run an HTTP service inside the box, ask for its public URL, and keep the deployment model close to a normal container workflow.
Lifecycle
Durable workspace in the middle, disposable container around it.
The core mental model is simple: keep the filesystem state you care about, rebuild the container around it when needed, and reuse good environments instead of recreating them from scratch.
1. Start from default, template, or snapshot
New boxes come from a built-in image, an org-owned template build, or a snapshot restore flow layered on top of one of those sources.
2. Work inside a durable home directory
Your commands, files, and agent state live in the workspace path, while the running container stays disposable and easy to recreate.
3. Pause, resume, snapshot, or promote
Stop compute without discarding state, capture a reusable checkpoint, or turn a proven environment into a repeatable template.
What Persists
The workspace is the product.
- The box runs as a normal non-root user instead of a root-by-default host shell.
- Pause and resume preserve filesystem state while compute stops and starts around it.
- Snapshots capture workspace state, and templates turn a proven setup into a reusable starting point.
Start
Default image, template build, or snapshot restore.
Work
Commands, files, and agent artifacts accumulate in the durable workspace.
Reuse
Pause, resume, snapshot, or promote the environment into a repeatable template.
Box operations
execcreate terminalget URLpause / resumesnapshottemplate builds
Real Surface Area
The same box model in code or from the shell.
These examples match the implemented SDK and CLI surface. The marketing page should sell the real product, not a future dialect of it.
TypeScript SDK
Create a box, bootstrap it, expose a service, and capture a reusable baseline.
typescript
import { Monkey } from '@monkeyhub/sdk'
const monkey = new Monkey(process.env.MONKEY_KEY!)
const box = await monkey.boxes.create({
name: 'eval-runner',
image: 'default',
size: 'small',
idleTimeout: 900,
httpPort: 3000,
env: {
MODEL_PROFILE: 'support-triage',
},
})
await box.exec('python scripts/bootstrap.py', {
cwd: '/home/monkey/app',
timeout: 60_000,
})
const url = await box.getUrl()
const snapshot = await box.snapshot({ name: 'baseline' })Monkey CLI
Use the same box lifecycle from scripts, local tooling, and CI-style jobs.
bash
monkey box create \
--input '{"name":"eval-runner","image":"default","size":"small","idleTimeout":900,"httpPort":3000}'
monkey box exec box_123 "python scripts/bootstrap.py"
monkey box url box_123
monkey box pause box_123Compare
More reusable than an ephemeral runtime, less infrastructure work than hand-rolling the host fleet yourself.
MonkeyBox is aimed at the awkward middle ground where a queue worker is too disposable and a DIY Docker control plane is too much product tax.
Need
Raw EC2 + Docker
Ephemeral Containers
MonkeyBox
Persistent filesystem state
You wire up volumes, lifecycle rules, and restore behavior yourself.
Best for short-lived jobs, but the runtime is not the place you keep working state.
Durable workspace state is part of the product model instead of an afterthought.
Repeatable environment setup
You hand-roll images, tagging, and rebuild discipline across hosts.
Good for fixed job images, weaker for iterative workspace reuse.
Templates and snapshots are built into the same box lifecycle.
Interactive access
You bolt on SSH or custom host access and maintain the blast radius yourself.
Often no real interactive debugging path once the job has started.
Exec and terminal sessions are first-class box operations.
Platform fit
You still need separate auth, usage, billing, and org-level controls.
Strong for isolated jobs, but usually another tool in the stack.
Boxes live on the same auth, billing, dashboard, and SDK surface as the rest of MonkeyHub.
MonkeyBox on the MonkeyHub control plane
Use a durable box when the workflow needs somewhere real to live.
Sign up if you want the shortest path to a real org, API keys, and a box you can create today. Or read the docs first if you want to inspect the exact surface before you commit.
Beta note: expect the operational polish and some API details to keep tightening as MonkeyBox moves through rollout hardening.