Your coding agent's “done” is not evidence. Gate it on exit codes.
Seven phases where every autonomous boundary is a machine-checkable gate — a verification command’s exit code, or an independent cross-model reviewer’s structured verdict. Nothing pushes to a remote without a human. Hardened over ~390 production work items. MIT, agent-agnostic, bring your own gates.
// the problem
Strong generators. Unreliable narrators.
Neither the agent's claim, nor a panel of agents' consensus, nor a human's felt sense of progress can serve as a gate. Only executed evidence can.
of validated failure episodes are inaccurate self-reporting — the agent claiming a test or deploy passed when it did not. Its share grows as models improve.
unanimously endorsed an OpenSSL padding-oracle vulnerability that does not exist — ten of them dedicated reviewers. One executed test killed it.
Experienced devs forecast a 24% speedup and felt a 20% speedup — and were measurably slower. Felt progress is not evidence either.
// the core rule
A phase boundary is a gate only when a machine can check it: a command’s exit code, or an independent reviewer’s structured verdict. The implementing agent’s own assessment is never a gate. And neither is a panel of agents’ consensus, nor a human’s felt sense of progress.
// how it works
Run the gates. Read the evidence. Nothing else counts.
ProveGate wraps your agent's workflow in checks a machine settles. The CLI prints exactly what ran, what passed, and what did not — then hands the push back to you.
Declare the gates
Each check is a command with an expected exit code, declared in gates.manifest.json. No prose, no vibes — a gate is a thing a machine can run.
Agent works the phases
The agent implements, tests, audits and learns autonomously. Every claim it makes is re-run, not trusted.
Evidence decides
Green is earned by exit 0 or an operator verdict. Listed but not run is never passed — the handoff card records what actually ran.
// playground
Edit the manifest. Read the plan.
This is the whole model: gates in, evidence out. gates.manifest.json declares the per-phase commands; phases 5, 6 and 7 carry built-in gates it cannot remove. Edit it and the plan below re-reads it live.
a plan, not a run — validation and chain order are the shipped ones; verdicts come only from `gate run`.
// the method
Phases 1–3 human, 4–7 autonomous. Push is always yours.
Humans own intent and release. The machine owns the verified middle.
// the seven phases
Every phase, and who owns it.
Select a phase to see what happens and who decides. A human owns 1–3 and the push; the agent works 4–7 — and earns nothing without evidence.
Test
machine gate · agentThe PRD’s declared verification commands run. A command that was listed but not executed is never passed.
// operator gates
When a command can't decide, a person does.
Some checks aren't machine-settleable — a release sign-off, a security judgement. Route those to a named owner; the acceptance is recorded like any other evidence, and the merge gate refuses while the row is unaccepted.
An agent never writes an acceptance for itself: recording one is a deliberate action by an allowlisted owner, and the merge gate refuses a row that has none.
// the evidence ledger
Listed but not run is never passed.
Every gate leaves a record: the command, the machine verdict, the exit code, and where the evidence lives. Auditable after the fact, by anyone.
The vocabulary is closed: passed operator blocked — never a silent pass.
// proof, and its honest limits
Showing the limits next to the proof is the point.
ProveGate is measured, not breathless. The evidence is real — and so are the conditions under which it doesn't apply.
// anatomy of a gate
One line, and nothing hidden.
This is a single line of gate run output. Every part is evidence a machine produced — the glyph carries the status on its own, so the line survives NO_COLOR.
// the difference
Self-attestation vs. evidence.
An agent saying it's done and a gate proving it are not the same event. ProveGate only records the second one.
Self-attestation
ProveGate evidence
// where it sits
Spec-driven development gates what you intend to build. ProveGate gates what you actually shipped — complementary, downstream of the spec.
// why provegate
Built for engineers who don't trust vibes.
Exit-0 semantics
A gate passes on exit 0 and fails on anything else. The contract is the one your shell already understands.
Operator gates
Some things a command can’t settle — a release sign-off, a judgement call. Route those to a named owner; the acceptance is recorded and the merge gate validates it.
Independent audit
Phase 6 is blocking and independent — by default a different model family. A pass mechanically requires Critical: 0; an absent reviewer never counts.
Handoff cards
Each phase hands off with a card: what ran, what passed, and whether the boundary is clear to cross.
CLI-native
Runs where you already work. Plain output, real exit codes, scriptable — no daemon, no dashboard, no account.
A greppable evidence trail
Workflow state, review artifacts and handoff cards are files in your repo. Reproducible, greppable, and honest about what was not run.
// install
Install however you ship.
One package, zero runtime dependencies, Node ≥ 22. The gates are the same either way — they are your commands, not ours.
// command reference
Thirteen commands. The one it refuses is load-bearing.
No daemon, no dashboard, no account. Everything runs where you already work and prints exactly what it did — and the runner has no code path that pushes, so gate push refuses.
MIT · zero deps · local-only · no telemetry · Node ≥ 22
// ci integration
Same gates in CI. Exit codes travel.
A gate is a command, so it drops into any pipeline unchanged — no plugin, no adapter, no ProveGate-specific runner. The one thing CI must not do is push on your behalf, and it can't: the runner has no push code path.
// quickstart
Green in four steps.
One package, no runtime dependencies. Node ≥ 22.
Scaffolds the workflow tree and starter configs. Nothing is ever overwritten.
Per-phase commands in gates.manifest.json; per-PRD verification commands in the PRD itself.
Runs phases 4–7, merges into your LOCAL base branch, prints the handoff card. You push.
// faq
Honest answers.
It runs the commands you declare — the per-phase commands in gates.manifest.json and the verification commands in the PRD — and nothing else. Commands it cannot classify as safe are refused rather than guessed at.
It merges locally, no-ff, into your base branch after the gates are green. It never pushes: the runner contains no code path that pushes to a remote, and gate push refuses by design.
Your gates are plain commands in a JSON manifest. Delete ProveGate and they still run in CI exactly as before. There is no lock-in and no proprietary format to migrate off.
A check a machine can’t settle — a sign-off, a judgement call. It is routed to a named owner whose acceptance is recorded as a file in the repo, and the merge gate refuses to close while the row is unaccepted. An agent never writes its own acceptance.
The CLI and the method are open source under MIT: zero runtime dependencies, local-only, no telemetry, no account.
// get started
Two commands to your first gate.
Install the CLI and initialize the workflow. ProveGate reads your gates from gates.manifest.json and the PRD, then prints the evidence.
Prove it, then propagate.
Open source. CLI-first. Free forever for the checks that keep your agents honest.