---
title: "mrin — the execution layer for your agents"
description: "Every command your agent runs is a commit of the whole Firecracker microVM, memory and disk. Fork any commit into a second machine, roll back to any step, and read back exactly what it printed."
url: https://mrin.ai/
---
# mrin — the execution layer for your agents

Every command your agent runs is a commit of the whole microVM, memory and disk. Fork any commit into a second machine, roll back to any step, and read back exactly what it printed.

mrin is the execution layer for your agents: a Firecracker microVM per run, its full
memory and disk committed after every command into a graph you can fork,
restore, and replay. Private alpha, self-hosted with our help; hosted is in
progress. Schedule a call: https://cal.com/boomage-engineering/30min

## What mrin provides

A Linux microVM per run, with a commit graph underneath it and an API over the top. The graph: one commit per exec on a main line; fork branches a commit into a second machine; restore arcs back to an earlier commit as a new branch; suspend pauses a commit in place; hibernate frees its VM.

- **Execution** — Run any command in the sandbox and stream its output as it happens. Attach a live shell when you want to type. Retry with the same key and get the same result, not a second run.
- **State** — The whole machine, memory and disk, is committed after every command. That history is a graph: fork any point into a new machine, or restore it as a branch of the same one.
- **Lifecycle** — Spawn, suspend, resume, hibernate, release. Hot-add vCPUs and RAM to a running machine, up only. Sizes from 1 to 32 vCPUs and 2 to 64 GiB.
- **Observability** — Everything a run printed is kept, in order, for as long as the branch lives. Read it back after the fact or tail it live, many branches on one socket. Webhooks fire on every commit, spawn, and fork.
- **Access** — One CLI. SDKs for TypeScript, Python, and Go that behave identically, because one conformance suite checks all three. List, read, and write files inside any machine.
- **Isolation** — Firecracker microVMs on Linux with KVM. Every run has its own kernel. The org is the tenant; API keys are scoped to it.
- **Computer use** (coming soon) — A desktop inside the sandbox for agents that click, type, and read the screen, with the same commit graph underneath.

## Built for

- Coding: Coding agents that need to try ten fixes from the same state
- Tree search · RL: Tree-search and RL rollouts where every rollback is a restore, not a rebuild
- Eval harness: Eval harnesses that replay a failed run from the step before it broke
- Long-running: Long-running agents that wait hours for a person or a webhook
- Financial: Backtests and settlement jobs where each parameter sweep is a fork and every result is a replayable commit
- Enterprise: Enterprise teams that run it on their own Linux + KVM hosts, one kernel per run

## Deployment

Private alpha. It runs on your Linux + KVM host and we help you deploy it. A
hosted version is in progress. The control plane is one Rust process with
Postgres behind it.

## The four primitives

### 01 fork() — Fork at any step.

Every command lands as a commit of the whole machine, memory and disk. `fork()` turns any commit into a second sandbox at exactly that state, in under 20 ms on one Firecracker host. Ten ideas, ten forks, and none of them re-runs the prefix.

```python
res = mrin.exec(br, "pytest -x").result()
c = res.commit_id           # memory + disk, committed
alt = mrin.fork(c)          # a second machine, same state
```

```typescript
const res = await mrin.exec(br, "pytest -x")
const c = res.commitId         // memory + disk, committed
const alt = await mrin.fork(c) // a second machine, same state
```

```go
res, _ := mrin.Exec(br, "pytest -x")
c := res.CommitID           // memory + disk, committed
alt, _ := mrin.Fork(c)      // a second machine, same state
```

### 02 restore() — Roll back, don’t rebuild.

When a run breaks at step 40, steps 1 to 39 are still commits. `restore()` opens a new branch from any of them inside the same sandbox, so the retry starts from the step before the mistake, not from a fresh image.

```python
log = mrin.get_commits(sb)   # the DAG, root to head
b = mrin.restore(log[-2].id) # branch from the step before
mrin.exec(b.id, "make test")
```

```typescript
const log = await mrin.getCommits(sb)       // the DAG, root to head
const b = await mrin.restore(log.at(-2).id) // the step before
await mrin.exec(b.id, "make test")
```

```go
log, _ := mrin.GetCommits(sb)            // the DAG, root to head
b, _ := mrin.Restore(log[len(log)-2].ID) // the step before
mrin.Exec(b.ID, "make test")
```

### 03 replay() — Read back what it printed.

Terminal output belongs to the branch, not to the call that produced it. Every byte is kept in order, so subscribing before or after a command yields the same bytes. Tail a run live, or read it back once it is over.

```python
page = mrin.get_output(b.id)
for f in page.items: ...    # every frame, in sequence
mrin.get_output(b.id, after_seq=page.head_seq)
```

```typescript
const page = await mrin.getOutput(b.id)
for (const f of page.items) {} // every frame, in sequence
await mrin.getOutput(b.id, { afterSeq: page.headSeq })
```

```go
page, _ := mrin.GetOutput(b.ID, nil)
for _, f := range page.Items {} // every frame, in sequence
mrin.GetOutput(b.ID, &mrin.OutputOpts{AfterSeq: page.HeadSeq})
```

### 04 suspend() — Pause in place, or free the VM.

Agents spend most of a run waiting. `suspend()` pauses the vCPUs and keeps the VM resident, so resume is a few milliseconds. `hibernate()` commits the machine and frees it entirely; resume restores memory and disk from that commit.

```python
mrin.suspend(br)            # vCPUs paused, VM resident
mrin.resume(br)
mrin.hibernate(br)          # committed, VM freed
mrin.resume(br)             # restored from the commit
```

```typescript
await mrin.suspend(br)      // vCPUs paused, VM resident
await mrin.resume(br)
await mrin.hibernate(br)    // committed, VM freed
await mrin.resume(br)       // restored from the commit
```

```go
mrin.Suspend(br)            // vCPUs paused, VM resident
mrin.Resume(br)
mrin.Hibernate(br)          // committed, VM freed
mrin.Resume(br)             // restored from the commit
```

## Not available yet

| Not available | Today | Status |
|---|---|---|
| Hosted mrin | No self-serve hosted. Self-host on your Linux + KVM host with our help, or ask for a per-customer hosted URL. | In progress |
| SOC 2, HIPAA | No audits, no certifications. On the roadmap after the alpha. | Post-alpha |
| Computer use | No desktop in the sandbox yet. Shell, files and output only. | Coming |
| Replay beyond terminal output | Output frames only today. Efficient filesystem diffs, syscall capture and network capture are in development. | In development |
| Scale down in place | vCPUs and RAM grow in place on a running machine. To go smaller, fork the commit into a new machine at the smaller size. | Not scheduled |
| Multi-agent primitives | None. Coordination is yours; fork gives each agent its own machine. | Not scheduled |
| GPU workloads | Experimental. Limited today by ACPI issues in the virtualisation driver and by what bare-metal providers make available. | Experimental |
| Hosts other than Linux + KVM | Built on Linux + KVM with Firecracker. Ports to Apple's Hypervisor framework (https://developer.apple.com/documentation/hypervisor) and Windows Hyper-V (https://learn.microsoft.com/en-us/windows-server/virtualization/hyper-v/) are experimental and in development, paced by post-alpha maturity. | Experimental |

Here's what is not available, in all honesty: what's built, and what isn't yet. We operate a small team, so we work the list in the order alpha customers ask for. If one gap is blocking a real workload, tell us on a call (https://cal.com/boomage-engineering/30min) and we will make sure it goes to the top. This is one of the major reasons we're doing this privately.

## FAQ

**What exactly is a sandbox here?**

A Firecracker microVM whose whole state, memory and disk, is committed after every command. The commits form a graph: fork any of them into a second machine, restore any of them as a new branch, read back the output of any branch.

**What happens on suspend?**

The vCPUs pause and the VM stays resident, so resume takes a few milliseconds. Hibernate goes further: it commits the machine and frees the VM, and resume restores memory and disk from that commit. Long waits cost storage, not compute.

**What's underneath — containers or VMs?**

Firecracker microVMs on Linux with KVM. Each run has its own kernel, not a shared one. The control plane is a single Rust process; the branch state machine inside it is a pure function, so a timer or a retry cannot race a commit.

**Where does it run? Can I self-host?**

Self-hosting is the preferred option in the private alpha: it runs on your Linux + KVM host and we help you deploy it. A hosted version is in progress and coming soon.

**What does it cost?**

Indicative alpha rates are on the pricing page (https://mrin.ai/pricing) — directional, not a quote. The model: pay for resident hours at the size you configured, with no base fee. Hibernated sandboxes bill nothing, and storage, forks and restores are free. Real numbers come out of a call.

**How does mrin compare to X?**

Most sandbox vendors offer a snapshot you take on purpose. mrin commits the whole machine on every command, so the history is already there when a run breaks, and fork, restore, and replay work from any point in it. The docs (https://docs.mrin.ai) carry a comparison against the projects most worth benchmarking.

**What's actually live today?**

Everything on this page runs in the private alpha: the commit graph, fork and restore, suspend and hibernate, output replay, the CLI and the three SDKs. Hosted mrin is not live yet. Ask for a capability on the call and we'll demo it, or tell you it isn't there.

## Contact

Bring a workload. We'll fork it, roll it back, and replay it live on a call.
Schedule a call (30 minutes): https://cal.com/boomage-engineering/30min