Lib.rs

Run, orchestrate, and stream coding agents — from a single control plane.

CIAB (Claude-In-A-Box) is an open-source control plane for coding agents. Spin up Claude Code, Codex, Gemini CLI, or Cursor in isolated sandboxes — as local processes, containers, Kubernetes pods, or EC2 instances — and manage them through a unified REST API, CLI, desktop app, or any web browser.

Every sandbox gets its own workspace, credentials, repos, and real-time streaming output. Access them from your laptop, phone, tablet, or CI pipeline — from the same network or anywhere in the world via built-in tunneling.

curl -fsSL https://raw.githubusercontent.com/shakedaskayo/ciab/main/install.sh | bash

Quick Start

# Install
curl -fsSL https://raw.githubusercontent.com/shakedaskayo/ciab/main/install.sh | bash

# Start the server (zero config — embedded defaults just work)
ciab server start

# Create a sandbox with Claude Code
ciab sandbox create --provider claude-code \
  --env ANTHROPIC_API_KEY=$ANTHROPIC_API_KEY

# Stream a conversation
ciab agent chat <sandbox-id> --message "Refactor the auth module" --stream

# Access from your phone — open the Gateway page and scan the QR code
# Or navigate to http://<your-ip>:9090 from any browser

Screenshots

Dashboard

Manage all your sandboxes from a single view. Quick-launch any agent provider, monitor running/paused/failed states, and create new sandboxes in seconds.

Chat — Real-time Streaming

Full conversation interface with live SSE streaming. Watch tool calls execute, file results appear, and code stream in — all in real time. Permission modes (Auto, Safe, Strict, Plan) control what the agent can do.

Access From Anywhere — Phone, Tablet, Any Browser

CIAB's built-in web gateway makes every sandbox accessible from any device. Open the Gateway page, scan the QR code with your phone, and you're chatting with your agent — with full streaming. No app install needed.

Skills Catalog

Browse and install agent skills from the skills.sh open registry. Add skills to workspaces to give agents specialized knowledge — React best practices, security guidelines, API patterns, and more.

Features

How It Works

Clients (CLI, REST API, desktop app, mobile browser, Slack/WhatsApp) connect to the CIAB control plane — an Axum-based server that handles auth, streaming, and orchestration. The control plane provisions sandboxes through an 11-step pipeline (validate → prepare image → resolve credentials → create → start → mount local dirs → inject credentials → clone repos → setup agent filesystem → run scripts → start agent), streaming every step over SSE in real time.

Every Way to Access Your Sandboxes

# CLI — create and chat
ciab sandbox create --provider claude-code
ciab agent chat <id> --message "Fix the bug" --stream

# REST API — programmatic control
curl -X POST http://localhost:9090/api/v1/sandboxes \
  -H "Content-Type: application/json" \
  -d '{"agent_provider": "claude-code", "env_vars": {"ANTHROPIC_API_KEY": "..."}}'

# SSE streaming — real-time events
curl -N http://localhost:9090/api/v1/sandboxes/<id>/stream

# Web browser — from any device on the network
open http://localhost:9090          # desktop
open http://ciab.local.local:9090   # mDNS (Apple devices auto-discover)
# or scan QR code from Gateway page  # phone / tablet

# Desktop app
make desktop

Workspaces

Define reusable environments in TOML — repos, skills, credentials, agent config — and launch them with one command:

[workspace]
name = "my-project"
provider = "claude-code"

[[repositories]]
url = "https://github.com/org/repo.git"
branch = "main"

[[skills]]
source = "vercel-labs/ai-sdk-best-practices"

[[pre_commands]]
command = "npm install"

[agent_config]
model = "claude-sonnet-4-20250514"
system_prompt = "You are a senior engineer working on this project."

[[credentials]]
env_var = "ANTHROPIC_API_KEY"
vault_path = "anthropic/api-key"

ciab workspace import workspace.toml
ciab workspace launch <workspace-id>

Rust Library

Embed CIAB natively in any Rust application. The ciab crate provides CiabEngine — a single entry point that owns the database, runtimes, streaming broker, and credential store.

use ciab::{CiabEngine, SandboxSpec};

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    // Zero config — just works with local runtime
    let engine = CiabEngine::builder().build().await?;

    // Create a sandbox
    let spec: SandboxSpec = serde_json::from_value(serde_json::json!({
        "agent_provider": "claude-code",
        "env_vars": {
            "ANTHROPIC_API_KEY": std::env::var("ANTHROPIC_API_KEY")?
        }
    }))?;
    let sandbox = engine.create_sandbox(&spec).await?;

    // Execute a command
    let req: ciab::ExecRequest = serde_json::from_value(serde_json::json!({
        "command": ["cargo", "test"]
    }))?;
    let result = engine.exec(&sandbox.id, &req).await?;
    println!("exit={} stdout={}", result.exit_code, result.stdout);

    // File operations
    let files = engine.list_files(&sandbox.id, "/workspace").await?;
    engine.write_file(&sandbox.id, "/workspace/hello.txt", b"world").await?;

    // Clean up
    engine.terminate_sandbox(&sandbox.id).await?;
    Ok(())
}

# Cargo.toml — pick only what you need
[dependencies]
ciab = "0.1"                                          # local runtime (default)
ciab = { version = "0.1", features = ["ec2"] }        # + AWS EC2
ciab = { version = "0.1", features = ["kubernetes"] } # + Kubernetes
ciab = { version = "0.1", features = ["full"] }       # everything

See the full Rust Library reference for the builder API, config resolution chain, feature flags, and re-exports.

Cloud Provisioning

Build machine images and run sandboxes on AWS EC2:

# Build an AMI with Claude Code pre-installed
ciab image build --agent claude-code \
  --var region=us-east-1 \
  --var base_ami=ami-0abcdef1234567890

# Or use a custom Packer template from a git repo
ciab image build \
  --template "git::https://github.com/org/templates.git//agent.pkr.hcl?ref=main" \
  --var region=eu-west-1

# Configure EC2 as the default runtime
# config.toml:
# [runtime]
# backend = "ec2"
# [runtime.ec2]
# region = "us-east-1"
# default_ami = "ami-your-built-image"

Architecture

crates/
  ciab                  Rust library facade (CiabEngine, feature-gated re-exports)
  ciab-core             Types, traits, errors (foundation)
  ciab-api              Axum REST API — 15 route groups
  ciab-sandbox          Runtime backends: local process, Docker, OpenSandbox
  ciab-sandbox-k8s      Kubernetes runtime backend (Kata Containers support)
  ciab-sandbox-ec2      AWS EC2 runtime backend (ephemeral instances, SSH exec)
  ciab-streaming        SSE broker with event buffer and replay
  ciab-provisioning     11-step sandbox provisioning pipeline
  ciab-credentials      AES-256-GCM encrypted vault, OAuth2
  ciab-packer           HashiCorp Packer image builder (AMI builds)
  ciab-gateway          Web gateway + tunneling (bore, Cloudflare, ngrok, frp) + LAN/mDNS
  ciab-channels         Slack, WhatsApp, webhook adapters
  ciab-agent-claude     Claude Code provider
  ciab-agent-codex      Codex provider
  ciab-agent-gemini     Gemini CLI provider
  ciab-agent-cursor     Cursor provider
  ciab-db               SQLite persistence (sqlx)
desktop/                Tauri v2 + React desktop app
docs/                   MkDocs Material documentation

Install

One-liner (macOS & Linux):

curl -fsSL https://raw.githubusercontent.com/shakedaskayo/ciab/main/install.sh | bash

Pre-built binaries:

From source:

git clone https://github.com/shakedaskayo/ciab.git && cd ciab
cargo build --release
sudo cp target/release/ciab /usr/local/bin/

Development

make build      # Build all crates
make test       # Run tests
make lint       # Clippy + warnings-as-errors
make server     # Start API server on :9090
make desktop    # Launch desktop app
make docs       # Serve docs at localhost:8000
make dev        # Server + desktop together

See CONTRIBUTING.md for full setup.

Community

• GitHub Discussions — questions, ideas, show & tell
• Issues — bugs and feature requests
• Contributing — how to contribute

If CIAB is useful to you, a star on GitHub helps others find it.

License

MIT