AgentProof is a free, local-first proof harness that verifies AI-generated code and diffs by detecting the project type, running safe local checks, launching the app, crawling routes with Playwright, and scoring launch readiness — all without uploading your source, using an API key, or trusting a cloud vendor. For AI code CI verification, it answers one question the chat transcript never can: did this app actually work, or did it just look good in the transcript? This review covers how AgentProof works, its GitHub Action score gate, its pricing, and how it compares to ProofPack and the broader “proof beats diffs” movement.
What Is AgentProof?
AgentProof is a local proof harness for AI-built apps, repositories, and public pull requests. Built by dicnunz and released as an open-source tool, it exists to answer a single, stubborn question: when an AI coding agent claims it finished a feature, did the resulting app actually work?
The tool is deliberately positioned against the most common failure mode of AI coding agents. A coding agent produces a transcript full of confident “done” messages, and a reviewer is left staring at a large diff and still has to judge mergeability and correctness by hand. AgentProof automates that judgment by running the app and verifying outcomes rather than eyeballing code.
Key properties from the official repository:
- Detects the project type automatically and runs safe local checks appropriate to that stack.
- Starts the application and crawls its routes using Playwright.
- Captures screenshots and console errors during the crawl.
- Checks accessibility and broken links.
- Produces a numeric “launch readiness” score.
- Writes a static report to
agentproof-report/index.html.
Because everything runs locally, AgentProof makes no paid API calls, needs no API key, requires no hosting, uses no database, sends no telemetry, and never uploads your source code.
Why AI-Generated Diffs Need a New Kind of Verification
The traditional code review workflow was built for human-authored changes. A human writes a diff, and a reviewer reads it, reasons about intent, and approves or requests changes. That model breaks down when the diff is generated by an AI agent.
The core problem is the scale and nature of AI diffs. As the ZeroNoise analysis of verification-first coding agents notes, the core failure is “coming back to a 1000-line diff and still having to judge mergeability and correctness yourself.” When an agent produces a thousand lines of changes in minutes, line-by-line review becomes impractical, and reading a transcript tells you little about whether the software actually runs.
There is also a determinism problem. CI/CD for AI agents behaves differently from CI/CD for traditional software because agents are non-deterministic. As the UnderstandingData analysis of CI/CD agent patterns points out, the same prompt can produce different outputs on each run, which means a test that passed yesterday can fail today for no obvious reason.
The emerging consensus, captured in the “proof beats diffs” thesis, is that teams should stop reviewing code and start verifying outcomes. Instead of asking “does this diff look correct?”, you ask “does the built application work?” That shift is exactly what AgentProof automates.
The market context is enormous. The OpenAI Codex CLI repository has roughly 105,000+ stars as of mid-2026, underscoring how large the AI-coding-tool audience has grown. That audience increasingly needs trust tooling before large AI-generated diffs get merged.
How AgentProof Works: From Project Detection to Launch Score
AgentProof’s verification pipeline is designed to be automatic and hands-off. The workflow follows a defined sequence:
- Project detection. AgentProof inspects the repository to determine the project type and stack.
- Safe local checks. It runs checks that are safe to execute locally and appropriate for the detected stack.
- Application startup. It launches the app so the runtime behavior can be observed.
- Route crawling with Playwright. It crawls the application’s routes, simulating a user navigating through the UI.
- Evidence capture. During the crawl it captures screenshots and console errors.
- Quality checks. It checks accessibility and looks for broken links.
- Scoring. It aggregates the results into a launch-readiness score.
The output is a static HTML report. This report becomes the durable evidence artifact that a reviewer, a CI system, or a human stakeholder can inspect to judge whether the app actually works.
This runtime-verification approach is philosophically different from simply validating that code compiles or that unit tests pass. AgentProof verifies that the application launches, renders, navigates, and behaves correctly as a running product — which is closer to what a human reviewer actually cares about when an agent claims a feature is done.
AgentProof in CI: GitHub Action, Min-Score Gate, and Badge
The most practical reason to use AgentProof for AI code CI verification is its GitHub Action integration. AgentProof ships a reusable GitHub Action that plugs directly into a workflow.
The key feature is the min-score gate. You can configure a minimum launch-readiness score, for example min-score: '70', and the workflow fails if the app scores below that threshold. This turns a fuzzy “did the AI do a good job?” judgment into a deterministic, repeatable quality gate.
The Action also produces a README badge, so the launch-readiness score becomes a persistent, visible signal on the repository. Path targeting is supported, allowing you to scope the verification to a specific directory, such as examples/demo-app.
This score-gate pattern matters because it addresses the non-determinism of AI agents head-on. When a human reviews every AI diff, the gate is inconsistent and slow. When a CI gate enforces a numeric threshold, the verification is automatic, repeatable, and cheap to run on every pull request.
A typical usage flow is:
- An AI agent produces a diff and opens a pull request.
- The GitHub Action runs AgentProof against the PR’s build.
- AgentProof crawls the app, scores launch readiness, and writes the report.
- The workflow passes or fails based on the configured
min-score. - The report and badge give reviewers objective evidence to merge or reject.
Privacy and Local-First Design: No API Key, No Telemetry, No Source Upload
A central selling point of AgentProof is its local-first, privacy-preserving design. The tool is explicitly built to verify AI code without uploading source or trusting a cloud vendor.
The design constraints from the repository are unambiguous:
- No paid API. All verification runs locally with local tooling.
- No API key. There is nothing to configure or leak.
- No hosting. The report is a static local file.
- No database. No server-side state.
- No telemetry. The tool does not phone home.
- No source upload. Your code stays on your machine.
This makes AgentProof attractive for teams with strict privacy and sovereignty requirements. If your organization cannot send proprietary source code to a third-party verification service, a local harness is the only viable option for automated AI-code verification.
For open-source projects, this local design also means anyone can audit the verification itself. There is no opaque cloud service sitting between the code and the verdict — the entire proof is reproducible on any machine.
Pricing and the $149 Mini Audit: When Free Local Proof Isn’t Enough
AgentProof itself is free and open source. The monetization model is a fixed-price professional service for cases where local verification alone is not sufficient.
The paid offering is a Mini Audit at a flat $149 for an asynchronous, written proof packet of one public repository, demo, or pull request. The scope is deliberately narrow: no calls, no secrets, no private-repo access. You get an external, written verification that a public AI-built artifact actually works.
The pricing logic is framed as a break-even trade against the review churn it replaces. At a fully loaded rate of $50/hour, $149 breaks even after roughly 3 hours of saved review time. At $100/hour, it breaks even after 1.5 hours. If you would otherwise spend that long manually reviewing and re-testing a large AI diff, the Mini Audit pays for itself.
The Mini Audit is aimed at a specific situation: when you need outside, independent written proof — for a client deliverable, a pitch, a launch, or a public-facing claim — and running the harness yourself is not sufficient evidence.
AgentProof vs ProofPack: Runtime Verification vs Evidence Bundle
The most direct comparison for AgentProof is ProofPack, another open-source local-only tool in the same space. Although both claim to be “proof” tools for AI coding agents, they solve different problems.
| Dimension | AgentProof | ProofPack |
|---|---|---|
| Core purpose | Runtime/launch verification of the app | Evidence bundle / diff provenance |
| What it proves | The app actually launches, crawls, and scores | A record of what the agent did |
| Approach | Detect project, run app, crawl with Playwright, score | Wrap agent command, capture logs and state |
| Output | agentproof-report/index.html + score | Proof folder with prompt, logs, git.diff, checksums |
| Typical usage | verify the built app works | proofpack run -- claude "fix login bug" then proofpack verify |
| Verification target | The running product | The agent’s execution artifact |
ProofPack positions itself as “receipts for AI coding agents.” It wraps Claude Code, Codex CLI, Hermes, or any command and writes a proof folder containing the prompt, stdout/stderr logs, git before/after state, git.diff, a commands log, test output, a manifest, and checksums.
AgentProof, by contrast, is runtime verification. It does not primarily care about the execution transcript; it cares about whether the resulting application behaves correctly when launched.
In practice the two are complementary. ProofPack answers “what did the agent actually do?” AgentProof answers “does the finished app actually work?” A rigorous team could use both: ProofPack to capture provenance, and AgentProof to verify the runtime outcome.
Pros and Cons
| Pros | Cons |
|---|---|
| Free and open source | Local verification depends on the local environment being set up correctly |
| Fully local-first: no API key, no telemetry, no source upload | Playwright crawling may miss behavior that only appears under real user conditions |
| Automated score gate makes CI verification deterministic | Numeric score can be gamed or may not capture every correctness issue |
| Answers “did the app work?” not “does the diff look ok?” | Scope limited to launchable app projects; not suited to every repo type |
| Produces a readable static report and README badge | The paid Mini Audit only covers public repos/demos/PRs |
Who Should Use AgentProof (and Who Shouldn’t)
AgentProof is a strong fit if:
- You rely heavily on AI coding agents and merge large generated diffs.
- You need a deterministic CI gate for non-deterministic agent output.
- You cannot or will not send proprietary source to a third-party cloud verification service.
- You want objective launch-readiness evidence for reviews, demos, or client deliverables.
- You maintain open-source projects where a README score badge adds trust.
AgentProof may not be the right tool if:
- Your work is mostly backend logic with no launchable app or browsable routes to crawl.
- You need deep, line-by-line code correctness analysis rather than runtime outcome verification.
- You require verification of code that must never be executed locally in your environment.
- You need independent, third-party written proof of a private repository — that is outside the Mini Audit’s scope.
Verdict and Alternatives
AgentProof is a genuinely useful addition to the AI-verification toolkit. It aligns with the strongest trend in the space — the “proof beats diffs” shift from reviewing code to verifying outcomes — and it does so with a discipline most competitors lack: fully local, no telemetry, no source upload, no paid API. The GitHub Action with a min-score gate turns fuzzy human judgment about AI output into a repeatable CI check, which is precisely what teams merging large agent-generated diffs need.
Its main limitation is scope. Runtime, launch-oriented verification is not a substitute for code correctness analysis, and teams with strict non-execution constraints will find it unusable. The pricing is also worth weighing against recurring spend: a single agent task costs roughly $0.015–0.05 in tokens, a 50-scenario suite runs $0.75–2.50, and 20+ runs a day on every PR can total $15–50 per month — so a $149 Mini Audit is best reserved for cases where local proof is not enough.
Strong alternatives depend on your priority. For diff provenance and execution evidence, ProofPack is the natural counterpart. For teams that want cloud-scale verification and spec-driven loops, the broader verification-first agents ecosystem — exemplified by Cursor’s 10x usage jump when agents can prove their own correctness — points to a future where verification is the core product feature of coding agents, not an afterthought.
For most teams, the sensible starting point is the free, local harness: wire AgentProof into CI, set a reasonable min-score gate, and let the launch score do the reviewing while you focus on the outcomes that matter.
FAQ
What is AgentProof? AgentProof is a free, local-first proof harness that verifies AI-built apps and public pull requests by detecting the project type, running safe checks, launching the app, crawling routes with Playwright, and producing a launch-readiness score in a static report.
How does AgentProof verify AI-generated code diffs in CI?
It ships a GitHub Action with a min-score gate (for example min-score: '70'). The Action crawls the built app, scores launch readiness, and fails the workflow if the app scores below the threshold, turning agent verification into a deterministic CI check.
Is AgentProof really free and private?
Yes. It requires no paid API, no API key, no hosting, no database, and no telemetry, and it never uploads your source code. Everything runs locally and outputs a static agentproof-report/index.html.
What is the $149 Mini Audit? It is a fixed-price, asynchronous written proof packet for one public repository, demo, or pull request — no calls, no secrets, no private-repo access. It breaks even after roughly 3 hours of saved review time at $50/hour or 1.5 hours at $100/hour.
How does AgentProof compare to ProofPack? AgentProof verifies the runtime outcome — whether the launched app actually works and scores — while ProofPack is an evidence bundle that captures what the agent did (prompt, logs, git.diff, checksums). They are complementary: ProofPack gives provenance, AgentProof gives runtime proof.