Bug 1: Send button never submits (2/3). Claude's patch, verified by a fresh cloud browser: form submits, "Thank you" shows (3/3).
Bug 2: form posts to a wrong endpoint, user hits 404 (2/3). After the verified patch the submission succeeds (3/3).

ProofLoop — The Trust Layer for Autonomous Software Repair

AI can write code. But who verifies that it actually works?

ProofLoop closes the gap between AI-generated fixes and verified software outcomes. It autonomously reproduces real-world bugs, generates safe code patches in isolated environments, and independently validates every fix before it can be approved.

No blind trust. No self-grading. Just verifiable results.

Inspiration

AI agents are becoming remarkably good at writing code. But generating a plausible fix is not the same as proving that it works.

Today, developers still spend significant time reproducing failures, reviewing AI-generated changes, and manually checking whether a fix introduces new problems.

We believe the next frontier of autonomous software engineering isn't just better code generation. It's verifiable autonomy.

We built ProofLoop around one principle: the agent that proposes a fix should never be the one that decides whether it succeeded.

What it does

ProofLoop is an autonomous website debugging and verification system that closes the entire repair loop:

Detect → Diagnose → Repair → Verify → Learn

Reproduce: Anchor Browser executes real user journeys in cloud Chromium, capturing actual failures rather than relying on static code analysis.
Diagnose: Claude Sonnet 5.5, running through AWS Bedrock, examines failure evidence and source code to propose a structured patch.
Repair: Daytona applies the proposed change inside an isolated candidate sandbox, preserving the original baseline.
Verify: A fresh browser session independently reruns the same acceptance tests. The fix is accepted only if those tests pass.
Learn: SurrealDB Agent Memory records verified fixes and failed attempts, allowing future runs to learn from prior outcomes.
Observe: Arize AX captures execution traces, model activity, evaluation results, and debugging evidence.

Every proposed change passes deterministic safety checks. No arbitrary model-generated shell commands are executed, and no code is automatically merged or deployed.

The result: a traceable, repeatable repair process where correctness is demonstrated through execution—not model confidence.

Results: Real Execution, Measurable Outcomes

We tested ProofLoop on three distinct, intentionally introduced bugs in a controlled website.

Scenario	Before	After	Attempts	Runtime
Broken form submission button	2/3	3/3	1	34.0s
Navigation link returning 404	2/3	3/3	1	34.1s
Incorrect form submission endpoint	2/3	3/3	1	29.0s

Key achievements:

3/3 scenarios independently verified after repair.
100% first-attempt success across these three controlled scenarios.
Zero modifications to the original baseline.
16 unit tests covering the deterministic safety gate.
Persistent Agent Memory with traceable recall of previous fixes.

In repeat testing, SurrealDB successfully retrieved a previously verified fix. In another scenario, Claude rejected an irrelevant memory suggestion rather than blindly following it.

These results demonstrate a working end-to-end prototype, not a general reliability benchmark across production websites.

How we built it

ProofLoop uses a Python-based orchestration engine with a bounded finite-state workflow and a maximum of two repair attempts.

Our architecture combines five sponsor technologies:

Daytona: Ephemeral, isolated execution environments, baseline/candidate separation, and signed preview URLs.
Anchor Browser: Real cloud-browser interaction and independent end-to-end acceptance testing through Playwright.
AWS Bedrock: Claude-powered diagnosis and structured code patch generation.
Arize AI: OpenTelemetry/OpenInference tracing and observability across the repair workflow.
SurrealDB Agent Memory: Persistent, traceable knowledge of verified and failed repair attempts.

The LLM outputs a constrained JSON patch proposal containing the root cause, target file, exact replacement, reasoning, and confidence.

A separate deterministic safety gate validates file permissions, patch size, exact-match constraints, and prohibited operations before Daytona applies any changes.

Crucially, the LLM is the proposer—not the judge. Developer-defined browser tests remain the independent source of truth.

Challenges we ran into

Cloud-to-cloud browser access. A remote browser cannot access a developer's localhost. We solved this by serving test websites directly from Daytona through expiring, signed preview URLs.

Preventing stale verification. Flask template caching initially made repeated testing unreliable. We isolated candidate retries on fresh ports to ensure the browser always evaluated the latest version.

Protecting sensitive information. We designed logging and tracing to exclude signed preview tokens and other secrets.

Making Agent Memory trustworthy. Previous fixes can guide the agent, but cannot override deterministic safety rules or independent browser checks. Memory is treated as evidence, never authority.

Accomplishments that we're proud of

We're most proud that ProofLoop is not simply a conceptual Agent workflow.

We built and executed an end-to-end system integrating five sponsor technologies, successfully repaired three different failures, and independently verified each outcome.

More importantly, we established a clear boundary between AI reasoning, deterministic safeguards, and external verification.

The agent can make mistakes. The system is designed not to trust those mistakes blindly.

What we learned

The hardest part of autonomous software repair isn't generating code.

It's establishing when a proposed change deserves to be trusted.

We learned that separating AI-generated decisions from deterministic validation creates a system that is easier to audit, debug, and improve.

Persistent memory also becomes significantly more valuable when it stores verified outcomes rather than unvalidated model responses.

What's next

Our vision is to evolve ProofLoop from a website repair prototype into a reusable verification infrastructure layer for autonomous software engineering.

Next steps include:

Cross-site learning: Reuse verified repair patterns across similar websites while independently validating each new application.
Autonomous test generation: Generate acceptance tests from user journeys, with separate verification of test quality.
Real-world benchmarking: Measure detection, repair, and verification performance across 20 open-source websites.
Developer workflow integration: Connect verified patches with GitHub pull requests and human approval workflows.
Continuous verification: Move from one-time bug repair toward proactive, evidence-driven software maintenance.

Our long-term vision: AI agents shouldn't just produce software changes. They should provide the evidence needed to trust them.

GitHub: https://github.com/miiikkee/proofloop