Infra to build your software factory.

Build background agents that automate software generation. Spin up multiplayer sandboxes pre-loaded with any coding agent.

amika.dev

Join Waitlist | Docs | Discord

Amika is an open-source CLI and HTTP API for running AI coding agents in sandboxes. Each sandbox comes pre-configured with development tools and agent CLIs — Claude Code, Codex, and OpenCode — ready to go out of the box.

Agent credentials are auto-discovered from your host machine and mounted into every sandbox. Git repos are auto-detected from the current directory (or pointed to with --git <path|url>), and setup scripts let you customize the environment on creation. The REST API (amika-server) exposes the same functionality for programmatic access.

This is the same infra pattern used by Ramp, Coinbase, and Stripe for their in-house coding agent platforms.

• Preset environments — Ubuntu 24.04 sandboxes with Claude Code, Codex, OpenCode, Python, Node.js, and standard dev tools
• Credential auto-discovery — Zero-config agent auth; your Claude Code and Codex API keys and OAuth tokens are found and mounted automatically
• Git repo mounting — Auto-detects the git repo containing your current directory (or pass --git <path|url>). Clean clone by default; --no-clean includes uncommitted files
• Setup scripts — Run custom initialization logic on sandbox creation with --setup-script
• Port publishing — Expose container ports to the host for live previews with --port
• REST API — amika-server exposes all operations as HTTP endpoints with OpenAPI docs at /docs
• TypeScript SDK — @amika/sdk wraps the REST API for programmatic access from Node.js

Prerequisites: Docker, macOS or Linux (Go 1.21+ only needed to build from source)

Install the latest release binary with the install script:

curl -fsSL https://raw.githubusercontent.com/gofixpoint/amika/main/install.sh | sh

This downloads the release binary, verifies its checksum, and installs amika to /usr/local/bin (override with AMIKA_INSTALL_DIR). Pin a specific version with --install-version:

curl -fsSL https://raw.githubusercontent.com/gofixpoint/amika/main/install.sh | sh -s -- --install-version 0.9.0

Once installed, the amika binary is on your PATH — run commands directly (e.g. amika sandbox create).

git clone https://github.com/gofixpoint/amika.git && cd amika
make build

Run this from within a git repo and Amika will auto-detect the repo root and mount the entire repo into your sandbox.

./dist/amika sandbox create --name my-sandbox --connect

Inside the sandbox you get a zsh shell at /home/amika/workspace/{repo} with your full repo, dev tools, and agent credentials ready.

Create a sandbox with your git repo and auto-connect to it:

./dist/amika sandbox create --connect
# Inside the sandbox:
claude "Add unit tests for the auth module"

./dist/amika sandbox create --name task-1
./dist/amika sandbox create --name task-2
./dist/amika sandbox list

┌────────────────────┐
│   Your Host        │
│                    │     ┌──────────────────────────────────┐
│  Git repo ───────────>   │  Docker Sandbox                  │
│                    │     │                                  │
│  Credentials ────────>   │  /home/amika/workspace/{repo}    │
│  (auto-discovered) │     │  Agent CLIs ready (claude, codex)│
│                    │     │  Dev tools (git, node, python)   │
│  Setup script ───────>   │  setup.sh runs on start     │
│                    │     │                                  │
│  Port 8080 <──────────   │  --port 8080:8080                │
│  (live preview)    │     │                                  │
└────────────────────┘     └──────────────────────────────────┘

For the full flag reference, see docs/cli-reference.md.

Start the server:

./dist/amika-server
# Listening on :8080

OpenAPI documentation is available at /docs. The API mirrors the CLI — create sandboxes, run materializations, extract credentials, and manage volumes over HTTP.

See the endpoint table in docs/cli-reference.md for the full list of routes.

@amika/sdk is a typed wrapper around the REST API for Node.js callers.

npm install @amika/sdk

import { AmikaClient } from "@amika/sdk";

const amika = new AmikaClient({
  baseUrl: "https://app.amika.dev",
  accessToken: process.env.AMIKA_API_KEY!,
});

// Create a sandbox (returns immediately with state "initializing")
const sb = await amika.createSandbox({
  name: "dev-box",
  repoUrl: "https://github.com/gofixpoint/example-repo",
  preset: "coder",
});

// Wait until it's ready (polls every 3s)
await amika.waitForSandbox(sb.name);

// Send a prompt to an agent
const resp = await amika.agentSend(sb.name, {
  message: "Refactor the auth module",
  agent: "claude",
});
console.log(resp.result);

// Tear down
await amika.deleteSandbox(sb.name);

Point baseUrl at the hosted API (https://app.amika.dev) or a local amika-server. See sdk/typescript/README.md for the full method list, configuration options, and error handling.

Preset images are built automatically on first use from bundled Dockerfiles (one-time build, takes a minute).

Agent credentials are auto-discovered from your host and mounted as read-only snapshots — coding agents authenticate without manual configuration. See docs/presets.md and docs/auth.md for details.

amikalog is a separate, independently-versioned CLI that captures Claude Code and Codex hook activity — along with the git state of each hook's working directory — as append-only events under the amika state directory.

Install the latest release binary with the install script, passing --component amikalog:

curl -fsSL https://raw.githubusercontent.com/gofixpoint/amika/main/install.sh | sh -s -- --component amikalog

This downloads the release binary, verifies its checksum, and installs amikalog to /usr/local/bin (override with AMIKA_INSTALL_DIR). Pin a specific version with --install-version:

curl -fsSL https://raw.githubusercontent.com/gofixpoint/amika/main/install.sh | sh -s -- --component amikalog --install-version 0.1.0

git clone https://github.com/gofixpoint/amika.git && cd amika
make build-amikalog

Install the Claude Code and Codex hooks once — this is what makes amikalog start recording:

amikalog start

From then on, agent and git activity is captured as append-only events under the amika state directory. Run amikalog stop to remove the hooks.

Optionally sync captured events with your org's storage (requires AMIKA_API_KEY):

amikalog beta:push          # upload not-yet-pushed events
amikalog beta:fetch <dir>   # download the org bucket into <dir>

See docs/amikalog.md for the full command reference, event storage layout, and event schema.

• Docker-backed persistent sandboxes
• Credential auto-discovery and mounting
• Git repo mounting (auto-detect or --git <path|url>)
• Setup scripts (--setup-script)
• Port publishing (--port)
• REST API with OpenAPI docs
• Linux support
• Remote providers (Modal, E2B, Daytona)
• Scheduled sandbox jobs

Amika is in beta. APIs and CLI flags may change. If something breaks or you have ideas, open an issue — feedback shapes what we build next.

See CONTRIBUTING.md for development setup and guidelines.

Apache 2.0