Review the intent. Prove the result.
Agents write more code than people can review, and an AI reviewer is one more opinion. Mlola holds every change, by an agent or a person, to its approved change request. Each acceptance criterion is proven by your test report, your API or a real browser, without a model, in a signed proof that names the few things a person still has to look at.
$ mlola prove contracts/CR-123.json --base origin/main
CR-123 · Users can change their display name
contract approved by the product owner and tech lead
The agent's first attempt: "done, tests pass"
⚠️ →✅ AC-1 test 3 tests passed
❌→✅ AC-2 browser text "Saved!" is present
❌→❌ AC-3 api GET …/api/profile answered 200
without "Ada Lovelace" in the body
👤→👤 AC-5 manual the brand team reviews the AC-2 screenshot
NOT PROVEN · 3/5 acceptance criteria · auto-merge: no
Walkthrough
One change request, from intent to proof.
An agent says a change is done and its tests pass. The proof says the name was never stored. Every terminal line in the video is real output.
From intent to proof
A person approves the intent once. Every change is held to it.
The question a reviewer answers changes from “is this diff right?” to “is this what we want?”, and it is asked once, when the change request is approved.
Step 1
Approve the intent
The PRD or change request becomes a contract: each acceptance criterion says what must hold and how it is proven. The approved contract is pinned by its digest.
Step 2
Prove the change
mlola prove checks every criterion at the lowest layer that can prove it: the JUnit report your CI already wrote, a GET to your API, or a short script of visible labels in a real browser.
Step 3
Before and after
Against a proof made on the base branch, each criterion shows ❌ → ✅. A criterion that already held before the change is flagged: it may test nothing new.
Step 4
Sign the proof
The proof records each verdict with its evidence and screenshots, sealed by a digest and signed with ed25519. Anyone can check it offline, with no browser, network or model.
Step 5
Review what is left
Instead of the whole diff, a person sees only what a machine cannot settle: a new or changed contract, tests the change edited, UAT, and high-risk changes. Auto-merge is earned only when that list is empty.
Proof layers
Each criterion is proven where it can be.
No model judges a criterion. Each layer reads evidence your system already produces, and says plainly when it could not check.
Test
Logic and rules. Reads the JUnit report CI wrote: every named case must have run and passed. A change that edited its own tests is flagged.
API
What the server stored or answers. Sends a GET, never another method, and records the answer's hash, not its body.
Browser
What a user can do and see. Plays steps by visible label, with no selectors, judges the page and the server, and keeps a screenshot.
Manual
What only a person can judge. Listed for UAT, and never counted as proven.
In CI and for agents
A proof on every pull request.
In CI, the GitHub Action mlolahq/prove-action posts each contract's verdict, its evidence and what is left for a person as one comment on the pull request, and keeps the signed proofs as the audit trail.
An agent proves its own change through the MCP tool browser_prove before it says it is done, and keeps fixing until it is proven. It names a contract from the directory the operator configured; it cannot hand in its own.
- uses: mlolahq/prove-action@v1
with:
base-url: http://localhost:3000
Trust
Checkable by anyone, and plain about its limits.
Verify and receipts
Judge browser work any agent did.
- mlola browser verify judges a page another agent, script or person drove: no model, and it acts on nothing
- The same criteria language as prove: text, URL, form state, downloads, and readbacks from your server
- Every verdict can become a signed receipt that anyone can check
- mlola receipt check rechecks a receipt or a proof offline, and rejudges it from what it recorded
What a proof does not claim
A proof is as good as its contract.
It shows the change does what the contract says, not that the contract says everything; that is why the contract is what a person reviews.
The test layer reads a report, it does not run your tests; signing in CI ties the proof to that job.
A browser script plays labels, not intent: if a label changes, the step fails and says which.
Checks act on the app you point them at: use a test or preview environment.
Case study
Three change requests, proven against a live product.
DataFawn, an SEO product from the same team, promised to prove that a change worked. In production it did not, although every test passed. Three contracts fixed it, each proven against the live site.
Three times the proof stayed not proven while the test suite was green: a result that read as a win and was not, a worker that could not finish, and a model call that never succeeded.
CR-DF-3 · Every result reads true, and a result that failed says why
2026-11-09, before
✖ AC-5 text "No data after the change" not found on the page
✖ AC-6 text "Calculating the result due" is present,
and must not be
failed; 0/7 acceptance criteria proven
2026-11-10, after
✔ AC-5 browser
✔ AC-6 browser
👤 AC-7 UAT: the product owner compares with Search Console
verified; 6/7 acceptance criteria proven · auto-merge: no
The runtime underneath
One observation. One decision. One typed action.
Mlola can also do the browser work itself. Browser mechanics, safety, verification and recovery are deterministic systems; a fast model picks one operation from the options the runtime offers, and no model has direct authority over the browser.
Try the browser runtimeStep 1
Observe
One atomic observation per step: controls, labels, values, geometry and page state in a single pass, with no screenshot in the normal loop.
Step 2
Decide
One request to the fast path: the model picks one operation and its target from the list that is actually compatible.
Step 3
Policy
Risk is classified in code: payments, deletions, sends, secrets. Risky actions need approval or a human takeover.
Step 4
Execute
A typed action runs after freshness, visibility and occlusion checks. Model output never becomes a selector or code.
Step 5
Verify
“Done” is a claim. Independent evidence confirms it: an artifact, a URL, DOM state, a runtime event, or a human.
Safety
Boundaries are code, not prompt requests.
- Typed actions only: no selector, coordinate or JavaScript ever comes from a model
- Risk can only be raised by the target's context; a model cannot lower it
- Passwords, OTP and card data require a takeover and never enter model state, traces, receipts or proofs
- Page content that reads like an instruction is quarantined, not negotiated
- Actions with an unknown effect (submits, uploads) are never retried without observing again
Status
Version 0.16 runs today.
All 17 packages are published on npm under one version: the CLI, the SDK, a local daemon and an MCP server for Claude Code, Cursor and other agents. Prove, verify and receipt check use no model and need no API key.
Mlola proves its own work first: the last release's fixes came from proving the changes to DataFawn against its live site.