One place to see, steer, approve and pay for every AI coding agent you run.
Nautelle, formerly AgentDock.
Documentation · Install · Concepts · Wiki · Website
Nautelle is a self-hosted control plane for Claude Code agent fleets. You describe work in one sentence. Nautelle interviews you, turns the answer into cards, can draw a design for them and runs a dedicated agent per card on your own machines. Each agent opens a pull request and fixes its own CI. You stay in charge of what merges, what it costs and what an agent may do — from the browser, from Telegram or from the terminal you already use.
It works alongside the Code Sentinel orchestrator, and GitHub issues and pull requests stay the source of truth.
To try it, one container is enough:
docker run -p 8000:8000 -v nautelle:/data abegma/nautelleIt runs a demo PostgreSQL and Redis inside, so it is not for production. Open the setup link it prints to create the first administrator. The install guide has the details.
To install it for real, on a Linux host with Docker:
curl -fsSL https://raw.githubusercontent.com/AndreyBegma/Nautelle/main/deploy/compose/install.sh | sh- Run the command above. It writes a Docker Compose stack into
./nautelleand starts it. - Open http://localhost:8000.
- Create the first administrator on the setup page.
The images are on ghcr.io (ghcr.io/andreybegma/nautelle-*, the default) and
on Docker Hub as abegma/nautelle-api, abegma/nautelle-web and
abegma/nautelle, with the same digests and signatures. Add
--registry docker.io/abegma to pull them from Docker Hub.
Then pair a runner on the machine that holds your repositories, with a code from Admin › Runners › Add runner:
brew install andreybegma/tap/nautelle-runner # or: npm i -g nautelle-runner
nautelle-runner pair --server http://localhost:8000/api --code XXXX-XXXX --allow-root ~/dev
nautelle-runner install-service--tunnel-token puts the install behind a Cloudflare tunnel and --domain
serves your own domain with automatic HTTPS. The
install guide
covers the three modes, the
requirements,
upgrades and
backups.
On Kubernetes, the Helm chart runs the control plane; runners stay on the developer machines:
helm install nautelle oci://ghcr.io/andreybegma/charts/nautelle --version X.Y.Z \
-n nautelle --create-namespaceValues, Ingress, external databases and backups are in Kubernetes (Helm).
| Board and cards | A per-project board (Inbox → To Do → In progress → Finished → Completed). Cards have dependencies and Auto-run, and support bulk actions. |
| New work intake | One sentence goes in. A short interview follows. Out comes one card, a split or a staged stack, and you accept it before anything runs. |
| Design and stacks | HTML mockups drawn from your project's UI profile, with pinned comments, revisions and approval. A stack shares one design. |
| Card workers and shipping | Each card gets its own worktree and Claude session. It opens a draft PR, fixes red CI on its own and can auto-merge. |
| Fleet and orchestrator | Code Sentinel slots, the queue of ready issues, PR approvals, a live terminal pane and an audited terminal attach. |
| Sessions, usage and budgets | Every session is shown as a tree of turns, tools and subagents, priced at API-equivalent cost. Budgets can alert or stop new runs. |
| Token Saver | Agents read less: command output is filtered, oversized and repeated reads are guarded, history is compacted early, and the savings are measured. |
| Steward | Spots stuck agent work, applies the few fixes that are safe and asks a person for the rest. |
| Context handoff | A short note per card, so the next round or session starts in context and costs less. |
| Claude Code integration | A plugin with MCP tools and hooks. Terminal sessions appear on the board, and away mode sends permission prompts to your phone. |
| Telegram | Browse, run and accept cards, answer agents, approve PRs and send voice notes. A Mini App opens the board. |
| AI assistant | A floating chat on every page that reads your board and fleet and drafts cards. It uses your own provider keys and spend caps. |
| Automation | Skills from skills.sh, cron schedules, signed webhooks and a GitHub App. |
| Security and access | Roles, an approval-gated sign-up and a hash-chained audit log. The runner keeps a local policy the server cannot change. |
Note
Orchestrator slots and card workers run Claude Code today. Codex sessions are listed, but Codex workers are the next milestone and are not built yet (roadmap).
flowchart LR
people["Browser · Telegram · terminal"] --> cp
subgraph cp["Control plane — your server"]
web["Web<br/>Next.js"] --> api["API<br/>NestJS"]
api --> pg[("PostgreSQL")]
api --> redis[("Redis")]
end
subgraph machine["Each of your machines"]
runner["nautelle-runner"] --> agents["Claude Code<br/>(Codex: sessions listed)"]
agents --> repo["worktrees · tmux · gh"]
end
runner -- "outbound WebSocket<br/>events up · typed commands down" --> api
repo -- "pull requests" --> github[("GitHub")]
- The control plane never reads a project's filesystem. A runner on each machine does, and it dials out, so the machine needs no open port (ADR-0001).
- The runner runs typed commands from an allowlist and refuses anything outside the folders you allowed, under a local policy the server cannot change (ADR-0010, ADR-0047).
- Code and credentials stay on your machines. Claude Code and GitHub credentials never reach the server.
A card goes from an idea to a merged pull request like this:
flowchart LR
idea(["One sentence<br/>web · Telegram · assistant"]) --> intake["Interview<br/>one card · split · stack"]
intake --> todo["To Do<br/>you accept candidates"]
todo --> design{"Needs a<br/>design?"}
design -- yes --> mock["Mockups<br/>pin · revise · approve"] --> run
design -- no --> run["Run<br/>own worktree + Claude session"]
run --> pr["Draft PR<br/>→ ready on finish"]
pr --> ci{"CI"}
ci -- red --> fix["Fix round<br/>(up to 3)"] --> ci
ci -- green --> merge["Auto-merge<br/>or your Accept"]
merge --> done(["Completed<br/>worktree cleaned up"])
| Where | What |
|---|---|
| Documentation site | Install, configuration (every environment variable), operations (upgrade, backup, reverse proxy, troubleshooting, privacy) and concepts |
| Wiki | Feature guides and FAQ |
docs/ |
The engineering source of truth: ADRs, specs, architecture, product |
apps/runner |
Runner commands, files and environment |
deploy/ |
CI pipelines, image, runner and docs releases |
Pull requests target develop. Read CONTRIBUTING.md
and CLAUDE.md for the conventions; help is in SUPPORT.md,
vulnerabilities go through SECURITY.md. An architectural change records
a new ADR in the same pull request.
To work on Nautelle itself you need Bun 1.4.0+, Node.js 24+ and Docker:
git clone https://github.com/AndreyBegma/Nautelle && cd Nautelle
bun install
cp apps/web/.env.example apps/web/.env
bun run db:setup # docker/.env + apps/api/.env with generated passwords, PostgreSQL 127.0.0.1:5421, Redis 127.0.0.1:6421, migrations, seed
bun run admin:create # the first admin
bun run start:dev # API http://localhost:8180 · web http://localhost:3517
bun run docs:dev # the documentation site at http://localhost:4321/Nautelle/Pair a development runner with --server http://localhost:8180.