Self-hosted · One binary · Your repos

An engineering org, compiled to one binary.

Forge runs autonomous coding agents against your git repositories. It triages the ask, plans it into tasks, builds them in parallel, verifies every claim, merges what's green, reviews its own output — and learns from every run.

Read the docs Why I built it

07:41:02 work.created rebuild-equitizr size=L mode=plan

07:44:19 plan.batch_created tasks=7 edges=5

07:44:19 plan.continuation_created round=1/3

08:02:56 target.merged seed-dataset checks=green

08:31:40 plan.task_dep_cancelled failed_on=map-view

08:32:07 supervise.assessment outcome=revise weakness="map tiles unbundled"

08:59:44 supervise.done overall=4/5 cost=$11.20

09:00:01 scratch.promoted csv-cols → library ▌

The shape of it

Fire-and-forget agents don't ship. Organizations do.

An organization is a suite of imperfect people, tools, and workflows that turns inputs into an output worth more — and that has to change, optimize, and do better tomorrow than it did today. Forge is that, for software: a suite of imperfect agents, tools, and workflows, arranged so the imperfections get caught, corrected, and learned from. A software factory whose floor plan is an org chart.

So it's org-shaped all the way down: a planner that decomposes, builders that work in parallel under write-set leases, reviewers and QA that hold verdicts, a merge queue that rebases and re-checks before anything lands, and a supervisor that reads what actually happened and orders the next round. Every role is an agent; the structure is the product.

Triagechallenge the ask, size it S·M·L, route it

Plana DAG of tasks with write-sets and blocked_by edges

Buildparallel attempts in isolated worktrees, budget-aware

Verifyclaims vs. reality, L0–L3 — self-report is never trusted

Mergeserial queue: rebase, re-check, land — or bounce

Superviseread outcomes, score 1–5, revise or accept

↺ corrective tasks loop back — bounded rounds, bounded nesting, bounded spend

What makes it hold

Trust is manufactured, not assumed.

Verification levels

Every attempt's claims are checked against git reality at L0; declared checks re-run at L1; a separate verify agent rebuilds and exercises the thing at L2; a human gate is L3. "The agent said it works" is not a state in the machine.

Everything journaled

Every state change writes a journal row; every prompt is frozen byte-for-byte as a snapshot with its hash; every spawned task carries its cause and its root. You can walk any outcome back to the ask that produced it.

Budget as physics

Subscription-window tracking, admission classes (interactive / normal / backlog), hard stops, quiet hours. Agents negotiate for more turns through an adjudicator — they don't take them.

A prompt operating system

Directives, personas, and fragments live in a git library — composed at materialization, hot-reloaded, hash-audited. Agents read them as skills and call them as tools; base improvements distribute by git merge.

Tools that earn tenure

Agents jot quick scripts into an LRU scratch cache. A script reached for enough times, by enough different attempts, triggers a curation task that dedupes, optimizes, and promotes it into the permanent library.

It measures itself

Supervision scores land in SQLite next to cost, turns, and size. A recurring benchmark — rebuild an entire app from an empty repo — turns "is it getting better?" into a chart instead of a feeling.

See it

The floor of the factory

The web UI is the operator's window: what's running, what needs a human, where the budget stands — and the same journal the daemon writes. These are live screenshots, failed run included; hiding it would be against the house rules.

The Forge dashboard: budget windows, an attempt timeline, the repository fleet, running tasks, and items needing attention — **The dashboard.** Budget windows, the attempt timeline, the repo fleet — one errored benchmark run and its successor mid-flight — and the human-attention queue.

The workflow editor showing the flow-deep pipeline: challenge, plan, design, implement, review, qa, eval nodes chained on success — **The workflow editor.** `flow-deep` — challenge → plan → design → implement → review → QA → eval — tool-callable, so agents can fire it too.

The directives library: personas, directives, scripts, and fragments in a tree, with a directive selected — **The library.** Everything agents read, as a git tree the daemon hot-reloads — personas, directives, scripts, fragments.

The stack, honestly

One Go binary. One SQLite file. Your git repos.

No cloud, no queue cluster, no yaml farm. The daemon serves the API and UI, schedules work, runs the merge queue, and supervises budgets; a worker executes attempts in sandboxed worktrees. State lives in a single SQLite database; executable content lives in git. If you can read a journal table and a git log, you can audit the whole system.

forge daemon start · forge task add "rebuild equitizr from scratch" --mode plan --size L · forge bench list rebuild-equitizr