ProofLatch

READY: new commit, clean evidence and a new receipt after re-evaluation.
GPT-5.6 explains the failure and produces a bounded Codex repair brief.
BLOCKED: required evidence fails, so the release cannot proceed.
ProofLatch — deterministic release evidence before model explanation.

Test it in 60 seconds

No account or API key is required.

Open the live app while signed out.
Click Run deterministic proof.
Inspect the BLOCKED verdict, evidence digest, receipt, and Codex repair brief.
Click Apply demo fix set.
Click Re-run deterministic proof.
Confirm the verdict changes to READY and the evidence digest changes.
Sign in for GPT-5.6 is optional; the deterministic proof loop works anonymously.

Inspiration

Agentic coding can create a working feature in minutes, but a confident agent message is not release evidence. The last mile still depends on a human reconstructing which tests ran, what failed, whether the source state was clean, and what should happen next.

We wanted a release tool that benefits from model reasoning without asking a model to invent the truth.

What it does

ProofLatch accepts a strict, bounded evidence packet for one release commit. Deterministic policy evaluates required checks and source cleanliness, then returns one authoritative verdict:

BLOCKED when a policy-required check is not pass or the supplied working tree is dirty;
READY when every policy-required gate passed on a clean supplied source state.

Only after that decision does GPT-5.6 Sol enter the loop. It explains the evidence in plain language and, for a blocked release, creates a bounded Codex repair brief. Every risk and repair step must reference an authoritative blocking check ID. GPT-5.6 has no verdict field and cannot upgrade the release.

After repair, the operator supplies a new commit and new evidence, reruns the gate, and receives a new receipt containing the evaluator version, decision, check statuses, and evidence digest.

If the model path fails or is unavailable, ProofLatch keeps the deterministic decision and returns a visibly labeled deterministic fallback.

How we built it

ProofLatch is a full-stack TypeScript application built with React, Next-style routing through vinext, Zod, the OpenAI Responses API, Sign in with ChatGPT, Cloudflare D1, and OpenAI Sites.

The core evaluator is a pure function. Server-owned, versioned policies define the exact allowed checks and prevent a client from omitting or weakening a release gate. The evaluator canonicalizes the effective policy, validated packet, evaluator version, and assessment summary, then derives a full SHA-256 evidence digest. The model call uses explicit gpt-5.6-sol, structured output, medium reasoning, store: false, zero automatic retries, and a bounded timeout. The server performs a second semantic check on the parsed model output before returning it.

Production model calls require server-side ChatGPT identity and pass through a persistent pseudonymous per-user quota. The included local scanner can emit a read-only repository baseline packet without running project code or tests. Evidence is not stored.

How Codex and GPT-5.6 were used

Codex was the build partner. We used it to frame the product, challenge the novelty, design the deterministic/model boundary, implement the evaluator and API, audit abuse paths, build the responsive interface, write tests and documentation, and validate the release.

GPT-5.6 Sol has a separate runtime job: explain an already-determined release decision and generate a repair brief bounded by the supplied evidence. This is not a generic chat wrapper. The model's authority is deliberately narrower than the deterministic evaluator's authority.

Codex session ID: 019f7221-2421-78e3-b12e-f6082da1ed87

Challenges

The hardest design problem was preventing useful model reasoning from becoming unverifiable model authority. We solved it structurally:

the verdict is computed before the model call;
the model schema contains no verdict;
every risk and repair step must reference an authoritative blocking gate;
READY forbids risks and repair steps;
any model contract violation falls back to deterministic output.

The second challenge was honest proof language. The receipt digest detects changes to captured evidence; it does not authenticate the source or prove a command ran. We expose that limitation in the interface, README, threat model, and demo.

The third challenge was offering a public judgeable demo without exposing an unbounded paid API. Production uses server-side identity and a persistent per-user quota while preserving deterministic fallback behavior.

Accomplishments

A working blocked-to-ready release decision loop.
Two server-owned policy profiles that reject missing, unknown, or weakened checks.
A read-only repository baseline scanner with bounded Git metadata inspection.
A deterministic verdict that remains authoritative when GPT is unavailable.
Strict evidence and structured-output contracts.
Bounded Codex repair briefs linked to exact check IDs.
Reproducible evidence receipts tied to commit, policy version, and packet.
A responsive operational UI that makes the decision visible in the first viewport.
Explicit security, privacy, provenance, testing, and fallback documentation.

What we learned

The most useful place for a reasoning model is not always the decision itself. Separating truth from narration made both layers stronger: rules became easier to test, while the model could focus on turning evidence into the next safe action.

We also learned that proof products must state what they do not prove. Honest boundaries make the receipt more useful, not less.