alineo
Get started
Model support AIGI logo

Intelligence
Designed To Evolve

Run code, manage state, and coordinate complex tasks with reliable, stateful execution infrastructure.

Get started free View on GitHub
$ bunx alineo-cli init
Watch it run

Live session

One prompt. A real sandbox. A durable session.

Active Connections

Slack Workspace
GitHub (drej-private)
Production DB

Available Tools

fetch slack messages...3 found
SLACK_FETCH_MESSAGES
GITHUB_CREATE_PR
DB_QUERY_RECORDS
Sandbox Execution Shell
Processing
> Initializing sandbox sbx_7C3D1P...
❯Waiting for next command...

Sandbox Telemetry

Instance ID
sbx_7C3D1P
CPU Usage2%
Memory105MB

Session Summary

0 lost work
Processed 45 messages across 2 channels. Created 1 pull request. Queried 1,204 rows. Checkpointed successfully.

Why Alineo

Your agent is smart.
Its sandbox should be too.

01
Sandboxes that persist
02
Checkpoint & resume
03
Spawn & fork
04
Programmatic workflows
⌕ run python script in sandbox...
SANDBOX_EXEC
Run a command, stream stdout
MATCH
EXEC_CODE
Run code in a persistent context
MATCH
resources = { cpu: "500m", memory: "256Mi" } // required
$ sb.exec("python3 train.py")
→ exec_start · exec_event · exec_complete
$ sb.checkpoint()
✓ snapshot saved · cp_0142
— process restarts —
$ client.resume(sandboxId)
→ restored from cp_0142, replaying cached results
agent.spawn("./worker.json")
parent · sbx_8F4K2M
child · sbx_2Q9RTA (forked fs + packages)
spawnDepth: 2 · maxAgents: 5 enforced
workflow(client)
  .sandbox({ resources }, (sb) => {
    sb.exec("pytest -q");
    sb.checkpoint();
  })
  .pipe(sink);

// one await, however complex

Sandboxes that persist

Every exec runs inside a live, isolated OpenSandbox container — filesystem, packages, and processes carry over between calls.

  • —A live container as a first-class object: spawn(), exec(), close()
  • —Streamed events: text, tool_start, tool_end over one API
  • —Resource limits required on every request — no runaway containers

Checkpoint & resume

Every exec is written to a durable ledger. checkpoint() snapshots the container; resume() reconnects after a full restart.

  • —SQLiteAdapter for local dev, PostgresAdapter in production
  • —Resume replays cached results, runs only what's left live
  • —Invisible to the caller — no special resume-path code

Spawn & fork

Fork a running agent's live sandbox — filesystem, installed packages, everything on disk — into an independent sub-agent.

  • —spawnDepth and maxAgents cap recursive fan-out
  • —steer() redirects a running agent mid-response
  • —attach() reconnects to any live sandbox by ID

Programmatic workflows

@alineo-labs/workflow is a lazy pipeline builder — retry, branching, fan-out, and parallel steps queue synchronously.

  • —The queue flushes on one await, regardless of complexity
  • —Hooks fire on every lifecycle event — bring your own tracer
  • —maxConcurrency caps simultaneous sandboxes with a semaphore

For agent builders

From chatbot to an agent that actually executes.

Execute your code inside the sandbox itself — reading and writing real files, running real shell commands, and capturing outputs in real time.

Learn more →
sandbox · alineo 
 █████╗ ██╗     ██╗███╗   ██╗███████╗ ██████╗
██╔══██╗██║     ██║████╗  ██║██╔════╝██╔═══██╗
███████║██║     ██║██╔██╗ ██║█████╗  ██║   ██║
██╔══██║██║     ██║██║╚██╗██║██╔══╝  ██║   ██║
██║  ██║███████╗██║██║ ╚████║███████╗╚██████╔╝
╚═╝  ╚═╝╚══════╝╚═╝╚═╝  ╚═══╝╚══════╝ ╚═════╝
/workspace/app · sbx_8F4K2M
❯ try "fix the failing integration test"
spawn a worker to handle the auth module
checkpoint before the risky migration
resume sbx_8F4K2M from yesterday
fork this sandbox for a second reviewer
 █████╗ ██╗     ██╗███╗   ██╗███████╗ ██████╗
██╔══██╗██║     ██║████╗  ██║██╔════╝██╔═══██╗
███████║██║     ██║██╔██╗ ██║█████╗  ██║   ██║
██╔══██║██║     ██║██║╚██╗██║██╔══╝  ██║   ██║
██║  ██║███████╗██║██║ ╚████║███████╗╚██████╔╝
╚═╝  ╚═╝╚══════╝╚═╝╚═╝  ╚═══╝╚══════╝ ╚═════╝  SDK
import { Alineo, textOnly } from "alineo";

const agent = await Alineo.load(spec, { adapter });
for await (const chunk of textOnly(
  agent.prompt("Write and run a hello world script.")
)) {
  process.stdout.write(chunk);
}

For developers

Five lines to a running agent. Full control underneath.

A plain TypeScript SDK — no framework lock-in, no hidden runtime. Swap the storage adapter, the model, or the hooks without touching the rest.

Storage adapters
SQLite for local dev, Postgres in production — same interface.
Hooks & OTel
onExecStart, onCheckpoint, onSandboxClosed — bring your own tracer.
Concurrency limits
maxConcurrency caps simultaneous sandboxes with a semaphore.
Model agnostic
Snapshot and resume mid-session — tools and state carry over.

Isolation & security

Protected from every angle, by default.

Every sandbox is ephemeral, resource-capped, and network-gated — an agent gets exactly the reach you grant it, nothing more.

cpu/memory are required on every sandbox request — OpenSandbox rejects anything without them. No runaway containers.

DNS or direct egress modes, plus an agent-egress-approval gate so outbound calls need explicit sign-off.

Secrets are injected into the sandbox at exec time — never returned to the agent, never written to the ledger.

Every exec_start, exec_event, and exec_complete is recorded to your storage adapter and fully replayable.

Your agent's ready.
Give it somewhere to run.

One command spins up OpenSandbox locally — no infra to provision first.

Try Alineo today Join the Discord