https://github.com/risingwavelabs/box0
Agent swarm platform. Run multiple AI agents on your laptop or across distributed systems. Works natively with Claude Code and Codex.
https://github.com/risingwavelabs/box0
ai-agents claude-code codex cursor llm multi-agent self-hosted
Last synced: 3 months ago
JSON representation
Agent swarm platform. Run multiple AI agents on your laptop or across distributed systems. Works natively with Claude Code and Codex.
- Host: GitHub
- URL: https://github.com/risingwavelabs/box0
- Owner: risingwavelabs
- License: mit
- Created: 2026-03-12T07:58:16.000Z (3 months ago)
- Default Branch: main
- Last Pushed: 2026-03-22T19:39:57.000Z (3 months ago)
- Last Synced: 2026-03-22T19:42:32.032Z (3 months ago)
- Topics: ai-agents, claude-code, codex, cursor, llm, multi-agent, self-hosted
- Language: Rust
- Homepage:
- Size: 36.9 MB
- Stars: 56
- Watchers: 0
- Forks: 0
- Open Issues: 0
-
Metadata Files:
- Readme: README.md
- License: LICENSE
Awesome Lists containing this project
README
__Open-Source Platform for Subagents and Agent Teams.__
[](https://go.risingwave.com/slack)
[](https://www.npmjs.com/package/@box0/cli)
[](LICENSE)
[](https://github.com/risingwavelabs/box0/tree/main/docs)
[](SKILL.md)
Box0 runs multiple AI agents in parallel across your machines. You create agents with different roles, delegate tasks to them, and collect results. It works with Claude Code and Codex. Single Rust binary, no dependencies.
- **Long-running**: agents that persist across sessions and never disappear
- **Collaborative**: shared across machines and team members
- **Proactive**: cron jobs, webhooks, Slack notifications
## Box0 vs Subagents
| | Box0 | Subagents |
|:-------------:|:---------------------------------:|:----------------------:|
| Setup | `npm install`, one binary | Built-in, zero config |
| Multi-machine | One laptop or a fleet of machines | Single machine only |
| Persistence | Agents and conversations persist | Session only |
| Scheduling | Cron jobs | :x: |
| Notifications | Webhooks, Slack, and more | :x: |
| Team sharing | Workspaces, multi-user | :x: |
| Dashboard | Web UI | :x: |
| Runtime | Any agent runtime | Claude Code only |
## How it works
A **server** coordinates everything. It stores agent definitions, routes tasks, runs the scheduler, and serves a web dashboard. Start one with `b0 server`.
**Machines** are computers that run agents. When the server starts, it registers itself as the `local` machine. Add more with `b0 machine join`. Each machine uses its own Claude Code or Codex credentials. Machines belong to the server and are shared across all workspaces.
**Workspaces** organize agents by team. Each user gets a personal workspace. Create shared ones with `b0 workspace create` and invite members. Agents in a workspace are visible to all its members.
**Agents** do the actual work. Each agent has a name, a set of instructions, and runs on a specific machine. There are three kinds:
- **background** - persistent agents that stay around and handle tasks on demand. Created with `b0 agent add`.
- **cron** - run on a schedule. Created with `b0 cron add --every 6h "..."`.
- **temp** - one-off tasks that clean up after themselves. Created with `b0 agent temp "..."`.
Your AI (Claude Code or Codex) delegates work with `b0 delegate`, waits for results with `b0 wait`, and can run multiple agents in parallel. You type one prompt. Your agent handles the rest.
## Agent onboarding
```bash
npx skills add risingwavelabs/skills --skill b0
```
Or read [SKILL.md](SKILL.md) directly.
Your agent sends tasks to the Box0 server via `b0 delegate`. The server stores them in an inbox. A node daemon polls the inbox, spawns a separate Claude Code (or Codex) process for each worker, and writes the results back. Your agent calls `b0 wait` to collect the responses.
Each worker runs in its own isolated directory. Workers can also run across multiple machines. See [Multi-machine](docs/multi-machine.md).
Agent runs use a 30 minute default execution timeout. This prevents longer workflow steps from failing at the old 5 minute default on first run.
## Getting started
Install:
```bash
npm install -g @box0/cli@latest
```
Start the server:
```bash
b0 server
```
On first start, Box0 creates an admin account and prints your API key.
If you want a fixed admin credential for other services, configure it before first start:
```toml
# server.toml
admin_name = "service-admin"
admin_key = "b0_service_admin_key"
```
```bash
b0 server --config server.toml
```
You can also use `B0_ADMIN_NAME` and `B0_ADMIN_KEY`. These settings are applied when Box0 bootstraps the initial admin for a new database.
If the server has already been started before, create or update a dedicated admin user explicitly:
```bash
b0 admin ensure --db ~/.b0/b0.db --name service-admin --key b0_service_admin_key
```
This command runs locally against the Box0 database. It can create a separate admin user for integrations without replacing your existing admin account.
### Frontend development
The server now prefers `frontend/dist` when it exists, and falls back to the legacy `web/` dashboard otherwise.
For day-to-day frontend development, run Vite separately:
```bash
cd frontend
pnpm install
pnpm dev
```
Vite proxies `/workspaces`, `/machines`, and `/users` to `http://127.0.0.1:8080` by default. To point it at a different backend, set `B0_FRONTEND_BACKEND_URL`.
To let the Rust server serve the Vue app directly, build the frontend first:
```bash
cd frontend
pnpm build
```
### 3. Teach your agent to use Box0
Teach your agent to use Box0 ([how skills work](docs/skills.md)):
```bash
npx skills add risingwavelabs/skills --skill b0
```
Then open Claude Code or Codex and say:
> Create three agents: an optimist, a pessimist, and a realist. Ask them to debate whether AI will replace software engineers in 5 years. Give me your own conclusion.
## Features
**Parallel delegation.** Send tasks to multiple agents at once, collect results when they are done.
```bash
b0 delegate reviewer "Review this PR for correctness."
b0 delegate security "Review this PR for vulnerabilities."
b0 wait --all
```
**Cron jobs.** Schedule recurring tasks.
```bash
b0 cron add --every 6h "Check production logs for errors and summarize."
```
**Webhooks and Slack.** Get notified when agents finish.
```bash
b0 agent add monitor --instructions "Watch for regressions." --webhook https://example.com/hook
b0 agent add alerter --instructions "Triage alerts." --slack "#ops"
```
See [Slack setup](docs/slack.md) for configuration.
**Multi-turn conversations.** Continue where you left off.
```bash
THREAD=$(b0 delegate researcher "Compare Postgres and MySQL for our use case.")
b0 wait
b0 delegate --thread $THREAD researcher "Now factor in DynamoDB."
```
**Pipe content.** Pass files and diffs directly.
```bash
git diff | b0 delegate reviewer "Review this diff."
b0 delegate analyst "Summarize this codebase. @src/"
```
**Temp agents.** One-off tasks, no setup.
```bash
b0 agent temp "List the top 5 differences between Rust and Go."
```
**Multi-machine.** Distribute agents across machines. Each machine uses its own credentials.
```bash
b0 machine join http://server:8080 --name gpu-box --key
b0 agent add ml-agent --instructions "ML specialist." --machine gpu-box
```
**Web dashboard.** Manage agents, view tasks, and monitor machines at `http://localhost:8080`.
## CLI reference
```
b0 server Start server
b0 login --key Connect from another machine
b0 status Show connection info
b0 invite Create user (admin only)
b0 admin ensure --name --key Create/update a local admin user
```
```
b0 agent add --instructions "..." Create agent
b0 agent ls List agents
b0 agent info View agent details
b0 agent logs View recent task history
b0 agent stop Deactivate agent
b0 agent start Reactivate agent
b0 agent remove Delete agent
b0 agent temp "" One-off task (auto-cleanup)
```
```
b0 delegate "" Send task (non-blocking)
b0 delegate --thread "" Continue conversation
b0 wait [--all] [--timeout ] Collect results
b0 reply "" Answer agent question
b0 threads List recent conversations
```
```
b0 cron add --every "" Schedule recurring task
b0 cron ls List scheduled tasks
b0 cron remove Delete scheduled task
```
```
b0 machine join --name Join as remote machine
b0 machine ls List machines
```
```
b0 workspace create Create workspace
b0 workspace add-member Add member
```
## Learn more
- [Skills](docs/skills.md) - how skills teach your agent to use Box0
- [Multi-machine setup](docs/multi-machine.md) - distribute agents across machines
- [Cron jobs](docs/cron.md) - schedule recurring tasks
- [Slack notifications](docs/slack.md) - get notified when agents finish
- [Workspaces](docs/teams.md) - share a Box0 server with multiple users
- [Architecture](docs/architecture.md) - task flow, data model, and diagrams
- [CLI reference](docs/cli.md) - full command reference
- [Workflows](docs/workflows.md) - agent-first DAG workflow design for Box0
## Web dashboard
Open your browser to the server URL (default `http://localhost:8080`) and log in with your API key. Manage workers, view tasks, monitor nodes, and manage your team from the UI.
## License
MIT License. Copyright (c) 2026 RisingWave Labs.