Skip to content

Self-hosted · Agent control

Mission control for your AI coding agents.

Run a whole team of AI coding agents across a task board — on your own machine, in isolated git branches, opening pull requests. Your code never leaves your box.

CodeCave is self-hosted: install it, point it at a git repo, and orchestrate the whole backlog from one board.

npm i -g codecave && codecave start
Read the quickstart →

Your code never leaves your machine · SQLite, no cloud · macOS & Linux

An illustration of the CodeCave board: tasks move from Ready through In progress and Testing to Done, where each finished task has an open pull request.

Live
architect·picked up "add rate limiting"·3sbackend·committed 4 files·feat/rate-limitingtester·running suite·$0.12security·opened PR #214refactor·worktree created·step 2/4docs·needs input — ambiguous spec·parkedtester·no-op run flagged·nothing committedbackend·squad complete·$0.41 · 1 PR

The shift

One agent in a chat isn't a team.

You've already got an AI agent in your editor. It's great — for one task, one session, one thing at a time. But your backlog needs ten of them working at once. And your source code shouldn't have to leave your laptop to get help.

CodeCave is the layer above the chat: a private command center where a fleet of agents works your board, on your infrastructure.

How it works

Point it at your repo. Queue the work. Review the PRs.

  1. 01

    Connect a project

    CodeCave points at a local git repo on your machine. No uploads, no server-side clone — it works the checkout you already have.

  2. 02

    Queue tasks on a board

    Kanban columns, just like your team already works. Write the task, pick the agent, drop it in Ready.

  3. 03

    Agents get to work

    Each run happens in its own git worktree, on its own branch — then opens a pull request when it lands.

  4. 04

    You review

    Merge it like any teammate’s PR. An agent never touches main, and every diff is yours to reject.

  1. projectlocal git
  2. boardkanban
  3. agentclaude code
  4. worktreeisolated
  5. branchfeat/*
  6. PRreviewable
  7. reviewyou
Every agent works in isolation and hands you a reviewable PR. Nothing runs against your main branch.

ORCHESTRATION

Not one agent. A team.

Assemble agents into a Squad — an ordered team that relays a single task and hands off as it goes: architect it, build it, test it, review it. One shared branch, one pull request out the other side.

squad · feature-deliverytask #214 · add rate limiting
  1. Architectplans it
  2. Backendbuilds it
  3. Testerproves it
  4. Securityreviews it
  5. PRPull requestyou review
one shared worktreebranch squad/214-rate-limitingone pull request

Each agent builds on the work the last one committed and hands off with a note. Nothing is re-explained, nothing is re-cloned, and you get one thing to review at the end.

Then turn the board into an autopilot.

Give a column a rule. When a task lands in it, a Squad starts on its own — and the rule also says where the task goes next: one column on success, another on failure.

So a finishing Squad routes the task onward, into a column that fires its rule. Tasks cross the board by themselves until they reach a column that ends the run. Your kanban board is the state machine.

  • Blocked or failed? It pauses.A Squad stops where it is when an agent needs input or a step fails — and you resume it when you’ve unblocked it.
  • Save it or assemble it on the spot. Squads are reusable definitions, or an ad-hoc lineup for one task.
codecave — board settings · column automationenabled

Rule · Testing

when task entersTesting
run squadQA Squad
on success→ Done
on failure→ Needs input
when blocked→ Needs input · notify

Wire the columns once. A ticket dragged into Ready can build, test and land in Done without anyone touching it again — and park itself in Needs input the moment it needs a person.

SAFE BY DESIGN

Autonomy you can actually leave running.

Agents are powerful and occasionally overconfident. CodeCave is built so that never becomes your problem.

codecave — project settings · guard railsarmed

Caps · api-gateway

Revisit cap (per column)3/ 3
Total hops7/ 12
Cost budget$3.86/ $5.00

Trip a cap and the task parks in Needs input and a human gets notified. It never loops, and it never dies silently. Any human board move resets the counters.

column · Needs inputNeeds input

Add rate limiting to the runs API

#214

Parked by a guard rail: revisit cap reached (3 of 3). The Squad stopped here rather than trying a fourth time.

parked · waiting on yousquad · QA Squadstep 3/4

Cost, in the open

live
This run$0.34
QA Squad · task #214$1.92
Project · api-gateway$18.40

Per run, per Squad, per project — and rolled up on the dashboard.

  • Branches & PRs, never main.

    Every run happens in its own git worktree, on its own branch, and ends as a pull request you review like any teammate’s.

  • Guard rails.

    Cap revisits, total hops and cost per project. Cross a line and the task parks for a human — it never loops, and it never quietly drains the budget.

  • No fake success.

    A run that exits clean but committed nothing is reported as a no-op and parked. Narrated work that never happened does not get marked done.

  • Cost, in the open.

    See what every run, every Squad and every project costs, as it happens — not at the end of the month.

PRIVATE BY DEFAULT

Your code never leaves your machine.

CodeCave runs on your hardware. Your repositories, your data and your history stay in one place: with you. There’s no cloud account to create and nothing to upload — the only thing that talks to a model is the agent, using the Claude you already pay for.

Your git. Your Claude. Your data. Your rules.

  • No cloud account. Nothing to sign up for. Install it and it is yours.
  • Nothing to upload. CodeCave points at a local path. Your repo stays where it is.
  • One local file. All of it lives in a single SQLite file you can back up, move or delete.
Your machine
Your git repository~/code/api-gateway · worktrees, branches, commits
CodeCaveboard, agents, runs · one SQLite file at ~/.codecave
The agentClaude Code, running as you, on your hardware

everything above stays on this side of the line

the only thing that leaves · the model API call

Claude

your subscription, or your API key

No repository upload, no third-party agent cloud, no copy of your history sitting on someone else’s disk. One box, one line out of it.

BUILT FOR TEAMS

Real roles. Real limits.

CodeCave is multi-user from the first commit. Give each person exactly the access they need: global and project roles, custom roles you define, per-project membership, and scoped API keys that expire.

codecave — project · api-gateway · rolescustom roles
An example role set and the permissions each role grants
PermissionReaderBuilderOperator
View the board, runs and costsgrantedgrantedgranted
Create and move tasksnot grantedgrantedgranted
Run agents and Squadsnot grantedgrantedgranted
Edit agents, Squads and column automationsnot grantednot grantedgranted
Issue API keysnot grantednot grantedgranted
Terminal accessdangerousnot grantednot grantedgranted

Dangerous permissions are labelled as such. Terminal access and run execution are code execution as the server user, and CodeCave tells you that in plain words before you hand them to anyone.

Example role set. Global and project roles ship with CodeCave; the names and the boxes you tick are yours.

Keys that expire

API keys are scoped and given an expiry, and they are hashed at rest — CodeCave stores a hash, not your key. Agent runs get ephemeral keys that die with the run.

scopedexpiringhashed at restephemeral per run

Access, project by project

Membership is per project, so a contractor sees one client’s board and nothing else. Access comes in two layers: your role across the instance, and your role on each project you belong to.

VISIBILITY

See every agent, right now.

No black box. A live activity ticker streams what your agents are doing this second. An agent rail shows who's working. The board updates as tasks move — over sockets, not polling — and you can drop into any run's console to watch it think. When an agent needs you, the bell rings.

Agent rail

4 working
  • architectdrafting the approachworking
  • backendediting rate-limit.tsworking
  • testerrunning the suiteworking
  • securityreviewing the diffworking
  • docsparked — needs inputparked
Bell · chime

docs needs input on task #147. Real-time bell, audible chime — you hear it from the kitchen.

codecave — run console · backend · task #142step 2/4$0.12
  1. worktreecreated .codecave/wt/task-142branch feat/rate-limiting
  2. agentbackend picked up "rate limit the auth routes"
  3. readsrc/server/middleware/index.ts+3 more
  4. editsrc/server/middleware/rate-limit.ts+84 −0
  5. editsrc/server/routes/auth.ts+6 −1
  6. decisiontoken bucket over fixed window — tolerates bursts
  7. testnpm test -- rate-limit12 passed · 0 failed · 4.8s
  8. commitfeat: rate limit auth routes2 files
  9. propened #214 · feat/rate-limiting → main
  10. notemain untouched · confidence 0.86 · $0.12
  11. ›watching
confidence 0.86decision log · 3live · socket.iono polling
Live
backend·worktree created·feat/rate-limitingbackend·edited 2 files·+90 −1tester·suite green·12 passed · 4.8ssecurity·logged a decision·token bucketbackend·opened PR #214·$0.12docs·needs input — ambiguous spec·parkedarchitect·picked up "expire stale sessions"·2s

USE CASES

What will your agents do tonight?

Five things people put on the board on day one. Each one is the product working the way it already works — a task, a worktree, a branch, a PR.

  • Burn down the backlog

    Queue the boring stuff — bugs, chores, cleanups — run a fleet overnight, and wake up to pull requests waiting for review.

  • Tests & refactors

    Point a Squad at coverage gaps and mechanical rewrites. Every run commits to its own branch, so a bad idea costs you one PR close.

  • Whole features

    A Squad takes one ticket end to end — architect, build, test, review — relaying through a single shared branch and out as one PR.

  • Client work, kept private

    Run agents on client repos without the code leaving your infrastructure. Isolate each client by project, then scope access with roles.

  • Autopilot pipelines

    Wire your columns once and tickets flow build → test → done on their own, with guard rails that park anything that stalls.

GET STARTED

Yours in one command.

Install it, start it, open the URL it prints. The browser wizard does the rest — you are looking at your own board in about a minute.

your terminal — zsh

  1. # 1. install

    npm i -g codecave

  2. # 2. start it

    codecave start

  3. # 3. open the printed URL and finish setup in your browser

Copy this

npm i -g codecave && codecave start

No database to run — CodeCave keeps everything in a single local SQLite file. The browser wizard sets up your admin account, checks your agent harness, and creates your first project.

Read the docs

Requirements macOS or Linux (Windows via WSL2) · Node.js · a Claude subscription or API key · gh optional (for automatic PRs)

COMPARISON

Where CodeCave is different.

Not better at everything — different in a specific way. It runs on your hardware, it runs many agents instead of one, and the board drives them.

How CodeCave compares with cloud agent SaaS products and single-agent command line tools across nine capabilities. Values are yes, no, or partial.
CapabilityCodeCaveCloud agent SaaSSingle-agent CLI
Runs on your machineyesnoyes
Your code stays localyesnoyes
Run many agents at onceyespartialno
Squads (agents hand off)yespartialno
Board-driven autopilotyesnono
Guard rails & cost capsyespartialno
Roles & multi-user (RBAC)yespartialno
Bring your own modelyesnopartial
Watch it liveyespartialno
  • yes
  • partial / varies
  • no

Illustrative; ~ = partial/varies. No specific products named.

FAQ

Questions, answered.

The things people ask before they install it. If yours isn't here, the docs go deeper.

  • Is my code sent anywhere?

    No. CodeCave runs on your machine and works against your local git. Your source never leaves your box — the only thing that reaches a model is the agent, using your Claude.

  • Is self-hosting hard?

    It is one command: npm i -g codecave && codecave start. Storage is a single SQLite file, so there is no database to run, and a browser wizard handles the rest.

  • Will an agent mess up my repository?

    No. Every run happens in an isolated git worktree on its own branch and ends in a pull request. Agents never touch main.

  • What stops an agent from looping or blowing my budget?

    Guard rails. You cap revisits, total hops, and cost per task; cross a limit and the task parks in Needs Input for a human instead of running away. You also see cost per run, per Squad, and per project.

  • Which models does it use?

    You bring your own Claude — either a Claude subscription through Claude Code’s login, or an API key. Support for more runtimes is on the roadmap.

  • Can my team use it?

    Yes. CodeCave has real role-based access control: global and project roles, custom roles, per-project membership, and scoped, expiring API keys. Dangerous permissions such as terminal access are flagged and off by default.

  • What do I need to run it?

    macOS or Linux (Windows via WSL2), Node.js, and a Claude subscription or API key. The gh CLI is optional and enables automatic pull requests.

  • Is there a hosted version?

    Not yet — CodeCave is self-hosted today. A hosted option is on the roadmap; join the list and we will tell you when it is ready.

Ready when you are

Mission control for your AI coding agents.

Self-hosted, on your machine. Isolated branches, real pull requests, guard rails you set. Your code never leaves your box.

npm i -g codecave && codecave start

macOS & Linux (Windows via WSL2) · single local SQLite file · no cloud account

Building in the open.

Get the launch — and the hosted beta when it exists. It is on the roadmap, not on your machine today.

Launch news + the hosted beta. No spam.