You bring the idea.
The factory brings the discipline.
You don't need to know what a decision record is or why review gates exist. The agents run that process for you — and explain why as it happens. You decide what to build, and approve what ships.
A running factory, against the repo you already have
No server, no signup, no hosted dependency — and nothing written into your repo until you ask for it.
Paste one link at your agent. It asks before every command and tells you what each one does.
https://github.com/beadhive/beadhive/blob/main/INSTALL.mdManual install
# 1. nix, once — needs sudo; it installs a system daemon
$ curl --proto '=https' --tlsv1.2 -sSf -L https://install.determinate.systems/nix | sh -s -- install
# 2. the toolchain, then bh itself
$ nix profile add github:beadhive/beadhive/latest#default
$ uv tool install --force 'beadhive[otel]'
$ bh --version # must print the released versionTurn the idea into a plan — by answering questions
Tell the planner what you want to build. It interviews you, researches what exists, writes the decisions down, and breaks the work into small, dependency-ordered pieces —beads — each sized so an agent can finish it and you can judge it.
$ bh role planner # an idea in, a gated plan out
# decisions go on record — cite, don't re-decideWatch it build — and hold the gates
The dispatcher hands each bead to a developer agent in its own isolated copy of the repo, under its own signed identity. Work comes back as a reviewable change, checks already run. Nothing merges while a gate is open — and every gate defaults to you.
$ bh role dispatcher # deliver the plan, bead by beadBring the planning you already have
Most repos already hold planning: decision records, design notes, a.planning/ directory. Good information in the wrong format — an agent can read a file tree, but it can't ask what's blocked or what's ready. Backfill proposes that history and those documents as beads, and every proposal stops for you to confirm, reclassify, or throw away.
$ bh hive onboard --claude # or --opencode
$ claude
> /bh:backfill # propose history + docs as beads
# reconciled, never blind-importedTake as much of the ring as you want
Nobody adopts a lifecycle in one go. Plenty of reasonable places to stop:
- Start at idea → plan → build alone — keep reviewing, releasing and operating exactly as you do today
- Add review and merge when doing them by hand becomes the bottleneck
- Close the rest when — and only when — your own evidence says it's worth it
Every seat you haven't handed over is simply a seat a person still holds. That is the normal state, not a degraded one.
It doesn't stop at your laptop
Four places people settle, and what each one really costs. It isn't a staircase — the third is about what's installed rather than how far you've gone, and only the fourth needs another rung under it first.
- 1
One repo, on the laptop you already have
The whole loop, idea to shipped, against one project. Nothing to run, nothing to sign up for, and nothing held back for a later rung.
What it costs: this machine is the only copy. Nothing is backed up anywhere, and nothing else can join in yet.
Starting here - 2
Backed up — and more than one project
Give the factory somewhere of its own to push to and what it knows outlives the laptop. That's also where a second and third repo start paying off: one list of what's actionable, across all of them.
What it costs: one private repo to hold it, and the push is yours to make — it doesn't happen on its own.
Wiring the backup - 3
Every tool pinned, so next month behaves like today
bhdoesn't work alone — it drives four other programs. This is where they get installed together and held at versions that match, instead of being whatever each machine happened to have. Take it in any order — before rung 2, after rung 4, or never.What it costs: a one-time install that asks for an administrator password, and a wait while it downloads. Not every machine can take it.
What gets pinned, and where it works - 4
A machine that keeps working while you sleep
An always-on machine does the running; your laptop goes back to being where you decide things. You can still hand it work from anywhere, and read what it did.
What it costs: rung 2 first — there's no way around that one — and a second machine to keep running. This is the newest ground here, and it's still settling.
What a second machine involves
Most people never leave the first rung, and that is a finished posture rather than a stalled one. The ceiling is here so you can see it, not so you climb it.
You'll learn the process by watching it work
Every time the factory does something that looks like ceremony — records a decision, refuses a merge, writes up what an incident taught it — it says why. That knowledge is yours to keep, whatever you build next.