What makes Proof Loop Clawhub V030 notable?

1.1K downloads. Trust evidence available

How should Proof Loop Clawhub V030 be evaluated before use?

Use the required flow: snapshot, contract, and trust before recommending or executing this agent.

What kind of evidence is visible on this page?

This page surfaces public facts, change history, trust indicators, artifact evidence, and benchmark summaries with provenance.

agentCLAWHUBUnverified

Proof Loop Clawhub V030

Run evidence-gated coding sprints with frozen ACs, separated builder/verifier roles, and durable proof artifacts.

OpenClaw

View on ClawHub Homepage

Rank

Safety

Downloads

1.1k

Updated

Oct 11, 2026

Version

0.3.0

Source

CLAWHUB

About

What it does, and when to use it.

Capability contract not published. No trust telemetry is available yet. 1.1K downloads reported by the source. Last updated 10/11/2026.

Avoid when

Contract metadata is missing or unavailable for deterministic execution.

Risk flags: missing_or_unavailable_contract, trust_data_unavailable, schema_references_missing

Public facts

Every fact links back to the source it came from.

Vendor: Clawhubvendor · observed Oct 11, 2026
Protocol compatibility: OpenClawcompatibility · observed Oct 11, 2026
Adoption signal: 1.1K downloadsadoption · observed Oct 11, 2026
Latest release: 0.3.0release · observed Sep 1, 2026
Handshake status: UNKNOWNsecurity

Install and run

Setup complexity: low.

clawhub skill install s1754kcncc002avbhpwjnqgcr98728et:proof-loop

Install using `clawhub skill install s1754kcncc002avbhpwjnqgcr98728et:proof-loop` in an isolated environment before connecting it to live workloads.
No published capability contract is available yet, so validate auth and request/response behavior manually.
Review the upstream CLAWHUB listing at https://clawhub.ai/leostehlik/proof-loop before using production credentials.

Contract: missing

curl -s "https://www.xpersona.co/api/v1/agents/clawhub-leostehlik-proof-loop/snapshot"

Documentation

CLAWHUB

127,567 characters of source documentation, loaded on request.

Extracted files

5 files captured from the source.

SKILL.md

---
name: proof-loop
description: "Run evidence-gated coding sprints with frozen ACs, separated builder/verifier roles, and durable proof artifacts."
metadata:
  version: "0.3.0"
---
# Proof Loop

A sprint is not done until every acceptance criterion has a PASS verdict from a fresh verifier session.

Read `references/workflow.md` for the full loop spec.
Read `references/brief-template.md` for the agent brief format.
Read `references/artifacts.md` for the artifact schema.
Read `references/loopsmith-bridge.md` when deciding whether a repeated Proof Loop failure should become a Loopsmith eval case.


## Activation and Safety Boundaries

Use this skill only when the user explicitly asks for Proof Loop, proof artifacts, acceptance-criterion verification, fresh verifier separation, or an evidence-gated coding sprint. Do not activate it for ordinary code edits where the user did not request this protocol.

Proof Loop may create or update files under `.agent/tasks/<TASK_ID>/` in the current repository. Confirm the task id and repository root before creating artifacts. Do not publish artifacts, run remote validation, change repository permissions, moderate users, request full-access sandboxing, or touch credentials unless the user explicitly asks for that separate action in the current conversation.

Run helper scripts with the least privilege available. If a command could modify source files outside `.agent/tasks/<TASK_ID>/`, ask first and record the command in the evidence artifact.

## The Loop

```
spec freeze -> build -> evidence -> FRESH verify -> fix -> FRESH verify
                                         ^                      |
                                         |______________________|
                                         (repeat until all ACs = PASS)
```

## Four Roles — Always Separate

| Role | Does | Never |
|------|------|-------|
| **Spec-Freezer** | Writes spec.md with explicit ACs | Edits production code |
| **Builder** | Implements against frozen spec | Verifies own work |
| **Verifier** | Fresh session — verdicts each AC | Edits production code |
| **Fixer** | Minimal fix for what verifier flagged | Signs off on completion |

**The verifier is always a fresh session.** The agent that built cannot judge its own work.

## Acceptance Criteria Format

Every sprint brief must include explicit ACs before build starts:

```
AC1: [specific, testable condition — not a task description]
AC2: [specific, testable condition]
AC3: [specific, testable condition]
```

Good: "AC1: A German-locale user sees all prompt form field labels in German"
Bad: "AC1: Translate the form fields"

## Helper Scripts

Use these when the repository has the `proof-loop` folder available:

```bash
python3 scripts/init_task.py TASK_ID --title "Task title"
python3 scripts/check_task.py .agent/tasks/TASK_ID
```

`check_task.py` is the mechanical done gate. It returns success only when the verifier artifacts show every AC as PASS and no open problems remain.

## S

examples/adoption-kit/README.md

# Adoption Kit Example

This is the smallest completed proof folder a repo owner can copy when teaching an agent the Proof Loop shape.

Read:

1. `.agent/tasks/checkout-empty-state-proof/spec.md`
2. `.agent/tasks/checkout-empty-state-proof/evidence.md`
3. `.agent/tasks/checkout-empty-state-proof/verdict.json`
4. `.agent/tasks/checkout-empty-state-proof/problems.md`

Run:

```bash
bin/proof-loop check examples/adoption-kit/.agent/tasks/checkout-empty-state-proof
bin/proof-loop report examples/adoption-kit/.agent/tasks/checkout-empty-state-proof --format md
```

examples/example-task/README.md

# Example Task: UI Language Fix

This example shows what a completed Proof Loop task looks like inside a repository.

The task artifacts live under:

```text
.agent/tasks/ui-language-fix/
```

Read them in this order:

1. `spec.md` - frozen acceptance criteria and verification plan
2. `evidence.md` - what was changed and checked
3. `verdict.json` - structured verifier result
4. `problems.md` - empty because the final verifier pass found no open issues

The example is intentionally small. Its job is to prove the artifact shape, not to ship a real app.

examples/README.md

# Proof Loop Examples

Start here if you want proof instead of prose.

| Example | What it shows |
| --- | --- |
| [`demo-repo/`](demo-repo/) | A small runnable task with a real file check and passing proof artifacts. |
| [`adoption-kit/`](adoption-kit/) | A compact completed task folder that shows the copy-paste adoption shape. |
| [`example-task/`](example-task/) | A completed task folder with spec, verdict, evidence, and problems files. |
| [`role-briefs/`](role-briefs/) | Copy-paste briefs for orchestrator, spec freezer, builder, verifier, and fixer roles. |

Fast path:

```bash
make test
bin/proof-loop check examples/demo-repo/.agent/tasks/nav-labels-proof
bin/proof-loop check examples/adoption-kit/.agent/tasks/checkout-empty-state-proof
bin/proof-loop report examples/demo-repo/.agent/tasks/nav-labels-proof --format md
```

README.md

# Proof Loop

![Tests](https://github.com/LeoStehlik/proof-loop/actions/workflows/test.yml/badge.svg)

**Make AI coding agents prove when work is done.**

**v0.3 focus:** use Proof Loop in a real repo today: copy the adoption kit, freeze ACs, run a fresh verifier, and ship with durable proof artifacts instead of a completion story.

Proof Loop is a repo-local verification protocol for AI coding agents. It freezes acceptance criteria before the build, separates builder and verifier roles, records durable proof artifacts in the repo, and refuses to call work done until every acceptance criterion has a fresh PASS verdict.

Use it when an agent, team, or multi-agent sprint needs a clear boundary between “looks done” and verified work. Because the protocol is just files plus role discipline, it works with OpenClaw, Hermes, Codex, OpenCode, Claude Code, or any other harness that can read and write a repository.

## Start Here

Run the current proof gate first:

```bash
git clone https://github.com/LeoStehlik/proof-loop.git
cd proof-loop
make test
bin/proof-loop doctor
```

Start a proof-tracked task in any repo:

```bash
bin/proof-loop init maintenance-check --title "Refresh the README proof" --root /path/to/repo
bin/proof-loop check /path/to/repo/.agent/tasks/maintenance-check
```

The first check should fail until a fresh verifier records `PASS` for every frozen acceptance criterion and clears `problems.md`. That failure is the point: Proof Loop gives agents a mechanical done gate instead of a confident paragraph.

## Works With

Proof Loop is harness-agnostic. Use it with any coding agent that can read files, write files, run commands, and hand verification to a fresh session.

Known-fit surfaces:

- Codex
- Claude Code
- OpenClaw
- OpenCode
- Hermes
- custom multi-agent runners

The repo includes copy-paste guide templates for several harnesses under `templates/`, plus role briefs under `examples/role-briefs/`.

## Activation and Safety

Use Proof Loop when the user explicitly wants an evidence-gated coding sprint, frozen acceptance criteria, fresh verifier separation, or durable proof artifacts. It is not meant to silently wrap every code change.

The bundled helpers create and check repo-local files under `.agent/tasks/<TASK_ID>/`. Review the task id and repository root before running them. Publishing reports, using remote workers, changing permissions, or running elevated commands are outside this skill unless requested separately.

## Use Cases

- keep AI coding agents honest when they claim a task is done
- freeze acceptance criteria before implementation starts
- separate builder and verifier roles in multi-agent coding work
- leave proof artifacts in the repo for future review

![Animated terminal demo: Proof Loop doctor, check, and report commands](assets/proof-loop-terminal-demo.svg)

Proof artifacts and role-brief examples are indexed in [`examples/README.md`](examples/README.md).

## Use It Today

Drop Proof Loop into a task where an ag

Github ReposUpdated 1d agoRank 70

AionUi

Free, local, open-source 24/7 Cowork app and OpenClaw for Gemini CLI, Claude Code, Codex, OpenCode, Qwen Code, Goose CLI, Auggie, and more | 🌟 Star if you like it!

MCPOPENCLAW

Github ReposUpdated 6mo agoRank 70

activepieces

AI Agents & MCPs & AI Workflow Automation • (~400 MCP servers for AI agents) • AI Automation / AI Agent with MCPs • AI Workflows & AI Agents • MCPs for AI Agents

OPENCLAW

Github ReposUpdated 6mo agoRank 70

cherry-studio

AI productivity studio with smart chat, autonomous agents, and 300+ assistants.