Fabrika

One person plus a fleet of agents, run like a software factory. Fabrika is a single Go binary that orchestrates the local coding agents you already run. You define big tasks and make decisions. Agents plan, build, test, and verify the work in parallel. Fabrika merges what is safe and surfaces only what needs your judgment.

The point is to protect your attention. Routing, building, gating, reviewing, and merging low-risk work all run without you. What reaches you is the small set of things only you can do.

Install

With Go 1.26 or later:

go install github.com/berkaycubuk/fabrika/cmd/fabrika@latest

Or the curl one-liner, which downloads the right binary for your OS/arch and skips the macOS Gatekeeper prompt:

curl -fsSL https://raw.githubusercontent.com/berkaycubuk/fabrika/main/install.sh | sh

Grab a .deb package or tarball from the releases page.

Quick start

Three steps from zero to a running board.

1. Install. go install github.com/berkaycubuk/fabrika/cmd/fabrika@latest

2. Init and run. From your repo:

   fabrika init && fabrika

   fabrika init scaffolds fabrika.toml and auto-detects your stack's verbs (build, test, typecheck). Running fabrika serves the browser UI and opens it.

3. Open the board. http://localhost:7777. Register an agent on the Agents screen, then create a big task. Watch it get planned, the diff reviewed, and the work merged.

How it works

Attention is the scarce resource, so Fabrika keeps it. Everything that can run without you does. A single feed shows the only four things that are yours:

• Approve the plan. A planner agent decomposes a big task into a DAG, each task carrying a machine-verifiable acceptance contract the implementer can't author or game.
• Decide open questions. When agents hit ambiguity, they escalate it instead of guessing.
• Accept finished work. Every branch runs the full gate plus review; low-risk green work auto-merges, higher-risk work escalates to you.
• Ship what's merged. Accumulated merges go out as a release that bakes before going live, with rollback at the deploy level.

Pipeline

  BigTask (you define)
        │
        ▼
     plan   ── planner agent: task DAG + acceptance contracts + open decisions
        │
        ▼
  you approve
        │
        ▼
  implement ── each task in its own git worktree; agents run in parallel
        │
        ▼
     gate   ── setup → typecheck → lint → build → test → verify → e2e
        │        + held-out checks written in after commit
        ▼
  review / mutation ── reviewer agent vets diff; mutation testing probes changed lines
        │
        ├─▶ auto-merge   (low risk)
        ├─▶ accept       (you gate medium / high)
        ▼
     ship   ── merged work goes out as a release, bakes, rolls back per deploy

  decide ◀── agents escalate open questions at any step

Held-out acceptance checks are written into the worktree after the branch is committed, so the implementer never sees them. Mutation testing is scoped to the changed lines only.

Configuration

Agents are configured in the web UI, never in config files. Name, command template, model, roles (implementer / planner / reviewer), tags, concurrency, and timeout all live in the global store (~/.fabrika/fabrika.db), managed from the Agents screen, and are reusable across every repo.

fabrika.toml is the only per-project file. Scaffolded by fabrika init, it maps abstract verbs to your repo's commands, marks which paths are high or medium risk, sets the auto-merge policy, and optionally wires [deploy] and [ci]. It holds no agent definitions.

Per-project tasks, plans, attempts, comments, and releases live in the repo's own .fabrika/fabrika.db.

Screenshots

From source

Requires Go 1.26+ and Node 18+ for the UI bundle.

make build      # build UI (esbuild), then the Go binary with the UI embedded
make run        # build, then run from this repo
make test       # go test ./...

The binary is self-contained: the TypeScript UI builds to static assets and is embedded via go:embed, so nothing ships alongside it.

Specs

Full design lives in SPECS.md. The downstream release and incident work is in SPECS-PHASE4.md.

License

Fair Source, under the Functional Source License 1.1 (MIT future). Read, run, modify, and redistribute for any purpose other than building a competing product; each release becomes plain MIT two years after publication.