Graphban — silence is not a pass

The villain

Vibe coding is the practice of letting an absence read as a clean result.

Not "using AI to write code" — that part is fine, and it works. The practice is what grows around it: accept the diff without reading it, take done at its word, ship. It feels fast because nothing ever pushes back.

And nothing ever pushes back because at every point where a system could object, there is nothing there to object with. You didn't write a spec, so no tool can tell you the work drifted from it. Nobody independent reviewed it, so no review was ever rejected. There is no check for that failure mode, so the suite is green. Each silence is read as approval, and the readings compound.

In one system emptiness produces green; in the other, emptiness produces a name. Same three gaps. The dashed lines exist only on the left, because only there does an absence feed a verdict.

That is the whole disagreement. Three emptinesses, one green tick. In Graphban the same three each produce a named state, and the summary is not green — because a thing nobody checked and a thing that passed are different results, and only one of them is a pass.

What it is

A tracker that refuses.

Graphban is a work tracker, a code graph and an agent memory that your coding agents operate directly over MCP — the same service layer the web UI uses, so an agent's write and your click run identical code. What makes it different from a list is what it declines to do.

The first two below are the first two silences, answered in order. The other two are the same rule applied to what the system knows rather than to what it checked — a file the map has never seen, and a lesson nobody vouched for, are absences that read as clean exactly the way an unwritten spec does.

spec → done

A question nobody answered

Approval isn't a status you set — it's earned by finishing the grill. Ask for it early and you get ApprovalNotEarned, naming the dimensions still open. How the spec lifecycle works →

the fleet

Nobody independent looked

An agent cannot pass its own work, enforced by two separate gates keyed on identity — so promoting it to reviewer doesn't launder it. "We can't tell them apart" fails closed. How coordination works →

the graph

A file the map has never seen

Re-describing prunes to stale, never deletes, and the health read distinguishes "went stale" from "never described at all". How the code graph works →

memory

A lesson nobody vouched for

Saying it three times in one session is saying it once — the ladder counts distinct sources, and approving a shared-file recommendation writes nothing. How the learning loop works →

48

days old

first commit 2026-07-21

1,468

commits

808 non-merge

57

MCP tools

as of 2026-09-07

4,200

tests green

3,471 backend · 729 frontend

0

defects the suite caught

of those found by hand

Graphban was built by agents running Graphban, and that last number is the one worth arguing with — the full account is here. The objection that you already have a folder of Markdown specs is answered at length, and the bug that started all of it is two minutes.

The path

Nobody becomes an orchestrator. You delegate one item, and then another.

There is no version of this where you sit down and start running a fleet. Every rung below is one command more than the rung above it, and none of them asks you to become a manager — because the arbitration is the server's job, not yours.

one agent What you already have. Claude Code, Cursor or Codex with the MCP attached. The grill, the collision check, independence and completeness all fire at N=1 — you are the reviewer, and the record says so.

delegate one item Not a fleet. One thing you do not want to do yourself: delegate(id, lane, tier, seat=true) mints a seat bound to that item and hands back a code. The child claims the item when it registers, so it cannot drift onto something else while your back is turned.

spawn a wave One command, one child per seat, each in its own git worktree, reaped when it exits. The wave reports what two workers both changed, what nobody declared, and how far behind the trunk each branch was cut.

let them review each other Independence is enforced on authorship, not on a role — so no promotion launders it, and you stop being the only pair of eyes. This is the rung where you stop being the bottleneck.

And every rung is the same four refusals. Nothing is switched on by growing: at N=1 they simply resolve to answers about you.

the grill

Four dimensions of the spec, graded — approval is earned, never set.

at N=1 Still fires. It's the check against your own half-written spec.

collision

Work is handed out in non-colliding clusters, with the files reserved.

at N=1 Returns a cluster of one. Costs nothing, changes nothing.

independence

An agent cannot pass its own work — two gates, keyed on identity.

at N=1 Resolves to "a human reviewed it", recorded as such.

completeness

Delivery measured against the frozen spec; absent kept apart from undelivered.

at N=1 Unchanged. This is the one that catches you alone at 2am.

Where self-hosting genuinely stops: a second human

Multi-agent and multi-human are different problems. Twelve agents across four worktrees is free and unlimited on your own machine. But the self-hosted build has no invite flow and no way to add a teammate to a project — one owner, any number of agents. Sharing a backlog with other people, and bridging into the tracker your company already runs on, is what the platform adds.

The part that makes it survivable: your context does not grow

A delegated item's outcome comes back through the ledger — the item moving on the board, with its evidence — and never as a reply in your session. That is the whole difference between delegating and supervising. Twelve agents reporting into one context window is not orchestration; it is one context window with twelve times the reading, and it collapses at about three.

You pick a tier, not a model

cheap or frontier — the resolver picks the harness and model from a committed table of what has actually been verified for that lane and role, filtered by the project's policy and your own preferences, and it records what it chose, what it dropped at each step, and the runner-up. A choice you can read afterwards is a choice you can correct. Naming a model in twelve places is a choice you get to make once and then live with.

Run it

One command, and it's yours.

Self-hosted is the real product, not a trial tier. It starts empty by design, runs fully offline with stub embeddings and no API keys, and nothing phones home.

your machine

git clone https://github.com/asc-me/graphban && cd graphban
./start.sh          # brings the stack up and mints your first agent key

# web :8080 · api :8000 · Postgres + pgvector
# writes ~/.graphban/mcp.json — paste it into Claude Code, Cursor or Codex

Migrations run automatically at startup. ./start.sh is idempotent, and refuses to run on a hosted deployment or a seeded instance rather than quietly minting a credential where it shouldn't.

Or natively, on a Mac or a Linux box

A box that already has Postgres + pgvector can skip Docker altogether: python3 scripts/graphban_host.py is one CLI for install, upgrade and uninstall, under launchd or systemd. Compose stays the default and is what the hosted service runs; this is the other one.

Postgres is required and verified, never installed. The installer refuses when Postgres or pgvector is missing, and it will not create, migrate or reconfigure a cluster. A tool that quietly provisions a database is a tool that quietly owns your data directory.

launchd or systemd

# from an unpacked release, with backend/.env already written
python3 scripts/graphban_host.py install --root /opt/graphban --from .

Preflight first — Postgres reachable, vector enabled, the port free — then the venv, then the unit, and it refuses if the job is not actually running afterwards. Upgrades swap the release, keep your .env, and put the old one back if /health does not come up serving the new sha. Uninstall never drops the database.

Install from the release tarball, not GitHub's source zip: a git tag is not a release and the source zip has no built web bundle. Settings → This box → Updates does the same fetch-and-upgrade from inside the app.

And the two local tools, when you want them

gban is the client for a human at a terminal — issue seats, read why an agent is stuck, re-task one — for the acts that otherwise need a browser. It installs on a laptop and pulls no dependencies at all.

the local tools

# macOS
brew install asc-me/tap/gban

# anywhere
uv tool install graphban-cli
uv tool install graphban-fleet   # gbfleet + gbagent, only if you run waves

The supervisor is a separate package on purpose: it exists to be resolved on PATH by whatever launched it, and it is the one that carries dependencies. If you skip it, gban fleet will offer to install it the first time you need one — and ask first.

Honestly

What's not done.

A list of known gaps is the only version of this section that isn't an absence reading clean. All of these are open as of 2026-09-07.

half-run The native install is walked on macOS and only partly on Linux. All eight steps ran on macOS, in the user domain. On Linux only the systemd unit itself was exercised — start, restart-on-kill, crash-loop refusal, removal. A privileged install on either platform, and upgrade/rollback/uninstall on Linux, have not been run.docs/acceptance-prd27.md
half-run Eleven of the living graph's twenty-two acceptance steps have not been measured. The eleven that ran all pass and found four defects, now fixed. The rest need things an agent cannot provision for itself — a second human's agent on a second account, and a graph past the 800-node budget that would mean writing 800 descriptions nobody wrote into the live code map, corrupting the thing being measured.docs/acceptance-prd20.md
partial Revoking a seat still has no push channel. A child discovers it on the next server call, or the supervisor notices after a quiet spell longer than a test run — because a child running tests is quiet that long, and killing it for silence was the defect. Instant it is not.GRPH-452
filed Work with no test suite cannot be signed off. The sign-off gate wants adversarial evidence — a claim, a mutation, and how many tests failed. That is the right demand for code and an impossible one for a design document or a game level, so specialised agents can reach review and no further.GRPH-P23 §H
partial The reference docs are still partial. Measured 2026-09-07: 132 of 200 routes, all 63 settings, 31 of 62 tables. Settings are paid down; the rest of the debt is real and ratcheted — nothing new can go undocumented silently.docs/completeness-baseline.json
partial The code graph covers about 30% of our own repo, and 15 of 100 live touchpoints resolve to no node on the map — docs, config, and areas that were never repo paths. They are reported rather than dropped, because a silently idle-looking codebase is indistinguishable from nobody working.
by design Graphban does not touch git. It now tells agents the delivery contract — base branch, whether they may push to it — or that the process is unmeasured. It still never opens a PR, never merges, never rebases. A branch that exists only in a claim is still a branch nobody can find.

Two ways in. Pick by how many people, not how much you'll pay.

There is no feature-gated free tier here. Self-hosting gives you the whole tool, unlimited. The platform exists because some problems only start when a second person shows up.

If it's just you

Self-host it, free, today.

One docker compose up. Postgres, API and UI, fully offline, no accounts and no keys required. Every mechanism on this page, no quotas — including multi-agent fleets. Source under FSL-1.1: free for personal, internal and development use, and each release converts to Apache-2.0 two years after it ships.

Run it now Source

If it's a team

Join the platform waitlist.

Teammates on one backlog, shared memory across people, org roles and audit — and an agent-facing layer on top of Linear and Jira, so your agents can work the tickets your company already files. invite-only private beta

Request access What the platform does →

The tracker bridge is designed and decided, not built — every capability is marked shipped, beta or planned. Already have platform access? Sign in.

Silence is not a pass.