One Docker. Zero Worries.
A containerized server-side agent platform that runs in one command.
Fully isolated sessions. Multi-LLM ready.
π One-Command Deploy Β |Β π‘οΈ Secure by Default Β |Β π Multi-LLM
OpenKimo is a containerized server-side agent platform. You operate the agent through a web browser, while all code execution tasks run inside sandboxed Docker containers β nothing executes on the host machine.
- One command to deploy the entire stack (
docker-compose up -d). - One browser tab to create sessions, chat with the agent, and review outputs.
- Zero host dependencies β the machine only needs Docker Engine installed.
flowchart LR
U[π€ User Browser] -->|WebSocket| G[kimi-gateway]
G -->|spawn| S1[π‘οΈ Session Sandbox 1]
G -->|spawn| S2[π‘οΈ Session Sandbox 2]
S1 -->|results| U
S2 -->|results| U
- π¬ [Quick Start Demo] (coming soon)
- π [Sandbox Security Demo] (coming soon)
- π [Multi-LLM Switch Demo] (coming soon)
Only Docker Engine is required. No Python, Node.js, or other build tools on the host. Pre-built images are hosted on GitHub Container Registry β no local build needed.
# 1. Download config files
curl -O https://raw.githubusercontent.com/j0x7c4/OpenKimo/main/docker-compose.yml
curl -O https://raw.githubusercontent.com/j0x7c4/OpenKimo/main/.env.example
cp .env.example .env
# 2. Edit .env β set at least one LLM API key
# 3. Pull images and start
docker compose up -dgit clone --recurse-submodules git@github.com:j0x7c4/OpenKimo.git
cd OpenKimo
./scripts/deploy.shThe wizard configures your .env and pulls pre-built images automatically.
git clone --recurse-submodules git@github.com:j0x7c4/OpenKimo.git
cd OpenKimo
cp .env.example .env
# Edit .env and set at least one LLM API key
docker-compose build
docker-compose up -dscripts/start.sh auto-detects Docker and falls back to running directly on the host. Useful when Docker is unavailable, on macOS where Docker Desktop has high overhead, or for quick local dev iterations.
git clone --recurse-submodules git@github.com:j0x7c4/OpenKimo.git
cd OpenKimo
cp .env.example .env
# Edit .env and set at least one LLM API key
./scripts/start.sh # auto-detect: docker if available, else local
./scripts/start.sh --mode=docker # force docker compose
./scripts/start.sh --mode=local # force local mode (no Docker)
./scripts/start.sh --mode=local --port=8080 --host=127.0.0.1Local mode requires Python 3.10+ with kimi-cli installed (pip install -e ./kimi-cli); it disables the per-session sandbox, browser, and Jupyter, so use it only for development. See docs/LOCAL-MODE.md for prerequisites and limitations.
A self-contained macOS application that bundles Python, kimi-cli, and the web frontend. No host dependencies; drag-to-install.
git clone --recurse-submodules git@github.com:j0x7c4/OpenKimo.git
cd OpenKimo/kimi-cli/web && npm install && npm run build
cd ../../packaging && python build.py
open ../dist/OpenKimo-*.dmgDrag OpenKimo.app into Applications, then launch from Launchpad. The first run opens a native Settings window for the LLM API key; once saved, the menu-bar icon turns β Running and your browser opens to http://127.0.0.1:5494. Quit from the menu bar to fully stop the server.
White-label rebrand:
python build.py --app-name="ACME Agent" --bundle-id=com.acme.agent \
--icon=./acme.png --logo=./acme-logo.png --favicon=./acme-fav.pngAll paths, the CLI command, and SQLite branding are derived from --app-name, so multiple brands can coexist on one Mac. See packaging/README.md for full options and the bundle layout.
Open http://localhost:5494 in your browser.
| Field | Value |
|---|---|
| Username | admin |
| Password | admin123 |
Important: Change the default password immediately after first login via the admin panel at
/admin.
If Bearer token authentication is also enabled, append your token to the URL:
http://localhost:5494/?token=<your-token>
- Solo developers who want to deploy an AI Agent backend in minutes, not hours.
- Small teams that need a shared agent infrastructure without managing Python/Node.js runtimes on every machine.
- Security-sensitive environments where code must never run on the host filesystem.
- Teams doing OEM or private deployments who need to white-label the platform with their own branding.
- Kimi / Moonshot users looking for a native, containerized integration with their existing workflow.
docker-compose up -d brings up the entire platform. No runtime installation, no dependency hell.
Every session is forced to run in its own isolated Docker container β not an optional plugin, not a configuration toggle. It is the architecture.
A single browser tab handles session creation, chat, file review, and admin. No WhatsApp bots, no Telegram channels, no desktop apps to install.
Switch between Kimi (Moonshot), OpenAI, and Anthropic (Claude) with a single environment variable.
Per-container CPU, memory, disk, and PID caps via cgroup β your host stays protected even under heavy agent workloads.
Jupyter Kernel + Headless Chromium + Shell execution ready out of the box. No extra plugin installations.
Built-in user management with role-based access control. Each user sees only their own sessions. Admin dashboard for user lifecycle management.
Customize logo, brand name, page title, and favicon directly from the admin panel β no code changes or rebuilds required. Perfect for OEM and private deployments.
Inject custom React components into the agent lifecycle via an event-driven plugin system. Visualize thinking processes, sub-agent clusters, or any custom overlay without touching core code.
OpenKimo uses a two-container architecture: a gateway that proxies traffic and orchestrates sandboxes, and a sandbox template that is cloned per session.
- kimi-gateway β FastAPI web server, WebSocket session proxy, container orchestration.
- Session Sandbox β One Docker container per session. Runs the agent worker, Jupyter kernel, and headless Chromium browser.
- Host β Only needs Docker Engine. No Python, Node.js, or other runtimes required.
flowchart TB
subgraph Host["Host Machine (Docker Engine only)"]
direction TB
G["kimi-gateway<br/>(FastAPI + WebSocket Proxy)"]
D["Docker Daemon"]
end
subgraph Sandbox1["Session Sandbox 1"]
direction TB
A1["Agent Worker"]
J1["Jupyter Kernel"]
C1["Headless Chromium"]
end
subgraph Sandbox2["Session Sandbox 2"]
direction TB
A2["Agent Worker"]
J2["Jupyter Kernel"]
C2["Headless Chromium"]
end
B["π€ Browser (Web UI)"]
B <-->|WebSocket| G
G <-->|spawn / stop| D
D -->|creates| Sandbox1
D -->|creates| Sandbox2
G <-->|proxy| A1
G <-->|proxy| A2
All configuration is done via environment variables in .env:
| Variable | Required | Description |
|---|---|---|
KIMI_API_KEY |
Yes* | Kimi / Moonshot API key |
OPENAI_API_KEY |
Yes* | OpenAI API key |
ANTHROPIC_API_KEY |
Yes* | Anthropic API key |
LLM_PROVIDER |
No | Default provider (kimi / openai / anthropic) |
KIMI_WEB_SESSION_TOKEN |
No | Bearer token for web UI auth |
KIMI_WEB_PORT |
No | Web server port (default: 5494) |
SANDBOX_CPU_LIMIT |
No | Per-session CPU limit (default: 2) |
SANDBOX_MEMORY_LIMIT |
No | Per-session memory limit (default: 4g) |
* At least one API key is required.
See .env.example for the full list.
OpenKimo is NOT trying to be your personal chat companion. If you want an AI that lives in WhatsApp or Telegram, check out other projects in that space.
OpenKimo IS for you if:
- You need a server-side agent that runs 24/7 and is accessed via a browser.
- You want zero host contamination β every code execution happens inside a throwaway container.
- You prefer infrastructure as code β deploy, scale, and upgrade with Docker Compose.
- You use Kimi / Moonshot and want a native containerized integration rather than a wrapper script.
We welcome contributions! Please see CONTRIBUTING.md for guidelines.
This project is licensed under the Apache License 2.0.
If OpenKimo saves you time, please consider giving us a β on GitHub!