Who 5dive is for#
Solo founders running AI development teams
One person overseeing multiple AI agents: a coder, a marketer, a researcher. 5dive gives each agent a name, a role, and a Telegram channel. Tasks flow between them via the shared backlog. The founder checks in via phone and approves the decisions that matter.
Skip if:
You need attended, interactive coding sessions with tight human-in-the-loop review at each step. 5dive is designed for asynchronous delegation, not for supervised pair programming.
Small engineering teams adding AI to existing workflows
Teams already using Claude Code or Codex can spin up 5dive to turn single sessions into a persistent team: one agent monitors the issue queue, another writes code, a third reviews PRs. Work continues between standups without manual handoffs.
Skip if:
Your team is not yet comfortable running a Linux server or managing systemd services. The install is straightforward, but ongoing maintenance requires basic Linux administration.
Developers who need agents across multiple provider CLIs
5dive supports Claude Code, Codex, Grok, Antigravity, and several community harnesses under one team. If you want a coder on Claude and a researcher on a cheaper OpenRouter model, one 5dive instance coordinates them on the same task queue.
Skip if:
You only use a single coding CLI and do not need multi-agent coordination. A single Claude Code session is simpler and lower-overhead for single-agent workflows.
Infrastructure engineers experimenting with autonomous AI workflows
5dive's architecture (Linux users, systemd, SQLite) maps directly to infrastructure patterns engineers already know. The `5dive trace` command gives full causal timelines. The isolation tiers provide explicit control over what each agent can do on the host.
Skip if:
You need Windows or macOS support, or a containerized setup without systemd. 5dive is Linux-only and assumes systemd is available.
The problem it solves#
Running AI coding agents interactively works for short tasks, but breaks down at the scale a real project requires. When you close the terminal, work stops. When you want two agents working in parallel on a sprint, there is no coordination layer. When an agent hits a decision that requires your input, it halts and waits until you happen to be watching.
Paid multi-agent platforms address this by hosting the orchestration for you, but that means your API keys transit their servers, your code runs on their infrastructure, and their pricing scales with your usage. Teams that want persistent autonomous work without that trade-off are left writing glue scripts or running attended sessions around the clock.
How it solves it#
Named agents on an org chart
Each agent is its own Linux user running an official coding CLI as a systemd service. You give it a name, a role, and a communication channel. Multiple agents share the same host and the same 5dive CLI as their coordination bus, without any separate broker or message queue.
Shared task backlog with agent-to-agent handoffs
Agents pull work from a shared SQLite task queue and hand tasks to each other when one finishes or needs a specialist. The `5dive task` command manages the queue, and `5dive trace` shows the complete causal timeline from the original request through every handoff to the final verdict.
Human-gate escalation to your phone
Decisions you reserve (spend approvals, publishing actions, anything destructive) arrive on your phone as tap-to-answer buttons via Telegram or Discord. Agents keep working on everything else while you decide.
Support for every major coding CLI
Claude Code, Codex, Google Antigravity, xAI Grok, Devin, and several community harnesses all run as first-class agent types. Multiple agents can share a single subscription or API key through 5dive's account profiles.
Three-tier isolation model
Each agent seat operates under one of three isolation tiers: `sandboxed` (own home directory, no sudo, resource limits), `standard` (named 5dive subcommands only), or `admin` (full 5dive CLI as root, which is not root on the host box). A fourth `beyond-admin` tier is available but must be explicitly granted by an operator.
Strengths and trade-offs#
Strengths
- MIT license, no open-core splitThe entire codebase ships under MIT with no paid tier or enterprise edition. Unlike commercial multi-agent platforms that restrict self-hosting or charge per seat, 5dive's full feature set is available on your own infrastructure at no additional cost.
- Auth tokens never leave your server5dive routes credentials directly from your server to the model provider. There is no OAuth proxy or intermediary. The project documents this architecture explicitly, and there is no telemetry, error reporting, or usage data sent to 5dive's servers.
- Runs on a 1 GB VMThe orchestration layer is Bash, SQLite, and systemd. A single-agent setup runs comfortably on a 1 GB VM. Adding agents adds Linux users and systemd units, not framework overhead. This contrasts with node-based orchestration frameworks that require several hundred megabytes of runtime before any model calls.
- Agents keep running when you're offlineAgents run as systemd services and stay alive when you close the terminal. You can message them via Telegram any time. Work that would stall in an interactive session continues between your sessions, across time zones, or overnight.
Trade-offs
- -Linux only, systemd required5dive's architecture relies on Linux users for agent isolation and systemd for service supervision. It does not run on macOS, Windows, or containers that lack an init system. Developers on Mac must provision a remote Linux box; the README explicitly assumes a Linux host with systemd available.
- -Early stage, 65 GitHub starsThe project was created in May 2026 and has 65 stars and 12 open issues at the time this was written. The API surface is not yet stable and may introduce breaking changes between minor versions. Teams that need a production-hardened multi-agent runtime may find it too early.
- -Requires your own model subscriptions5dive is the orchestration layer, not the model provider. Each agent needs its own Claude Pro/Max OAuth session or API key, OpenAI API key, or equivalent. Costs scale with how many agents you run and how much work they do; 5dive provides no model access itself.
5dive vs alternatives#
5dive vs Claude Code
Claude Code is an AI-powered coding assistant from Anthropic that runs in your terminal. 5dive is a multi-agent orchestration layer that manages a team of coding agents, including Claude Code, on a server you own. These tools are not substitutes. Most 5dive deployments run Claude Code inside the agent seats. The comparison that matters is between using Claude Code alone versus using Claude Code through 5dive.
| Feature | 5dive | Claude Code (standalone) |
|---|---|---|
| Session model | Persistent systemd services | Interactive terminal session |
| Multi-agent | Named team with shared task queue | Single session at a time |
| Escalation to phone | Yes, via Telegram or Discord | Not built in |
| Infrastructure | Self-hosted Linux server required | Runs locally; no server needed |
| Licensing cost | Free (MIT); model costs apply | Claude Pro/Max subscription |
| Offline operation | Agents run without your presence | Stops when terminal closes |
Claude Code alone is the right choice for interactive, attended coding sessions where you want tight control over each step and immediate feedback. It is simpler, requires no server, and runs wherever you have a terminal.
5dive is the better fit when you want a team of agents working asynchronously. Long-running tasks that span hours, multiple agents working in parallel, or autonomous work that continues while you sleep all benefit from persistent agent services. The tradeoff is operational overhead. You maintain a Linux server, manage systemd services, and provision API keys for each seat.
A common pattern is Claude Code in your local terminal for active work and 5dive on a small VPS for the background team. 5dive's own codebase is maintained by agents running on 5dive (the project tracks this with a zero-human badge in the README), so the separation-of-concerns model is one the authors use themselves.
Quick start#
5dive installs on any Linux server running systemd.
```bash
curl -fsSL https://install.5dive.ai | sudo bash
sudo 5dive init
```What it's built on#
- Languages
- Shell
FAQ#
Does 5dive replace Claude Code?
No. Claude Code is the coding agent that runs inside each 5dive seat. 5dive is the orchestration layer that manages a team of agents: it assigns work, tracks the task queue, routes escalations to your phone, and keeps agents running as persistent services when you close the terminal. The two tools are complementary. Most 5dive users run Claude Code as the agent type for their coding seats.
What do I need to run 5dive?
A Linux box with systemd and your own agent CLI subscription or API key. 5dive itself requires no account and creates no external account dependency. The installer is one curl command. Each agent you add becomes a new Linux user on the same host.
Does 5dive have access to my API keys?
No. Auth tokens go from your server directly to the model provider (Anthropic, OpenAI, etc.) and never pass through 5dive's servers. The project documents this design decision explicitly and states there is no telemetry, error reporting, or usage data sent to 5dive.
Can I run 5dive on a cheap VPS?
Yes. The orchestration layer is Bash, SQLite, and systemd, which adds minimal overhead beyond the coding CLIs themselves. A single-agent setup runs comfortably on a 1 GB VM. Costs scale with how much model usage your agents generate, not with 5dive's own resource requirements.
What AI coding agents does 5dive support?
Claude Code (Anthropic), Codex (OpenAI), Google Antigravity, xAI Grok, Cognition Devin, OpenCode, and several community harnesses including hermes, openclaw, and pi. The claude agent type also supports third-party Anthropic-compatible endpoints via a custom base URL, letting you point agents at local inference servers or OpenRouter.
Similar open-source tools#
Pstack Claude
Structured coding workflows for Claude Code, Codex, and Pi
Gstack
Turn Claude Code into a virtual engineering team with 23 skills
PiG
Pi's coding agent, in Go. One binary, no Node.js required.
orbi
self-hosted, open-source (AGPL-3.0) AI coding agent
Pi
The minimal, self-extensible coding agent for the terminal
Jean
A dev environment for running AI agents in isolated git worktrees