Open the dashboard

Machines for AI agents

Give every agent its own computer.

Rookbox gives your agents on-demand Linux machines. Each one is a Firecracker microVM with its own kernel, and it works with the E2B SDK you may already use.

Open the dashboardQuickstart
  • Its own kernel
  • Boots in about 2 s
  • Resumes in about 1 s

How it feels

Create, run, expose, suspend, resume.

A few calls cover most of an agent's day. Pick your language and watch a session.

sbx = Sandbox.create(template="seed")
# ready in about 2 s
sbx.commands.run("uname -sr").stdout
Linux
sbx.get_host(3000)
3000-<sandbox-id>.box.rookbox.run
sbx.pause() # E2B pause = suspend
# memory kept, compute released
sbx = Sandbox.connect(sbx.sandbox_id)
# resumed in about 1 s
  1. 1CreateA microVM with its own kernel, ready in about 2 s
  2. 2RunRun a command inside
  3. 3Expose a portA public URL for a port
  4. 4SuspendKeep memory, release compute
  5. 5ResumeBack where it left off in about 1 s

An illustration of the E2B SDK pointed at Rookbox. Output is simplified.

A desktop in the browser

When an agent needs to see a screen, it has one.

Every machine can run a full Linux desktop with Chromium. Watch it live in your browser over VNC, or let the agent drive it.

  • Chromium installed and ready
  • Viewable in your browser over VNC
  • The same machine as your terminal and files
Illustration of a machine's desktop

What you get

A real machine, not a shared container.

Its own kernel and root

Every machine is a Firecracker microVM. Your agent can install packages, run services and break things without touching a neighbour.

Suspend keeps memory

Park a machine while its agent waits. Resuming brings back memory and running processes in about a second.

Fork a working setup

Copy the disk into a new machine and try a second approach in parallel. Fork copies the disk, not memory.

A public URL per port

Expose a port and reach it at <port>-<sandbox-id>.box.rookbox.run. Preview a dev server or share a link.

Commands and files

Run commands, stream their output, read and write files. These are the same calls your E2B code already makes.

Sized per machine

Choose the vCPU and memory of each machine through the SDK, so a small task does not need a big machine.

Lifecycle

Four moves, all measured in seconds.

Timings are typical, not guarantees.

  1. Running
    ~2 s

    Boot

    A new microVM from a template: own kernel, own root disk.

  2. Suspended
    Memory kept

    Suspend

    Persist memory and state and release the worker.

  3. Running again
    ~1 s

    Resume

    Pick up exactly where the agent left off, processes and all.

  4. A new machine
    Disk only

    Fork

    Copy the disk into a sibling machine. Memory is not copied.

What agents do with it

Made for work that needs a real computer.

Browsing and computer use

Give an agent a desktop with Chromium so it can open pages, fill forms and use apps built for people.

Code execution

Run code the model wrote in a machine you can throw away, with its own kernel and files.

Long-running background agents

Let an agent work for hours, suspend it while it waits and resume it in about a second.

Parallel experiments

Fork a prepared disk into several machines and try different approaches side by side.

E2B compatible

Already using E2B? Change one line.

Rookbox speaks the E2B protocol. If you already use the E2B SDK, point it at Rookbox and your code keeps working.

Prefer environment variables? Set E2B_DOMAIN and E2B_API_KEY instead.

API key: request access in the dashboard

Before
sbx = Sandbox.create(
    api_key=API_KEY,
)
With Rookbox
sbx = Sandbox.create(
    domain="box.rookbox.run",
    api_key=API_KEY,
)

Get started

From zero to a running machine in five steps.

You need the E2B SDK for Python or TypeScript and an API key.

  1. 1

    Install the SDK

    Rookbox uses the E2B SDK. Install it for your language.

    pip install e2b
  2. 2

    Set the domain and your key

    Point the SDK at Rookbox and give it your API key.

    export E2B_DOMAIN=box.rookbox.run
export E2B_API_KEY=your-api-key
  3. 3

    Create a machine

    A new machine boots in about 2 seconds.

    from e2b import Sandbox

sbx = Sandbox.create(template="seed")
  4. 4

    Run a command

    The command runs inside the machine and returns its output.

    result = sbx.commands.run("echo hello from a machine")
print(result.stdout)
  5. 5

    Open a port

    Start a server, then ask for its public URL and open it in your browser.

    sbx.commands.run("python3 -m http.server 3000", background=True)
print(sbx.get_host(3000))

No key yet? Request access in the dashboard. Names and output are illustrative.

Pricing: early access

Billed per second. Prices coming soon.

Rookbox is in early access. Billing will be per second, and prices have not been published yet. Open the dashboard to get started.

Open the dashboardRead the quickstart