Done is a claim. Proof is a state.
AI agents are getting very good at producing work and increasingly good at reporting that the work is finished. The remaining trust problem is deeper: did the agent prove the right definition of success, did it have authority to act on that definition, and is that proof still valid after the world changes?
DONE / PROVEN is a proof-carrying work layer for humans and agents.
A human owns the mission and the semantic authority to decide what success means. An agent can inspect the mission and acceptance contract through WebMCP and can attack that contract by submitting a concrete counterexample: an outcome that appears to satisfy the current definition of done but should still count as failure.
The system evaluates that counterexample deterministically. If the unacceptable outcome would pass, DONE / PROVEN surfaces a false-green contract defect to the human. The agent cannot rewrite the contract, approve its own fix, or impersonate the human decision.
After the human admits a corrected contract, execution evidence can earn PROVEN state. If a dependency later changes, DONE / PROVEN invalidates only the proof that depended on the change. Unrelated evidence remains valid, and the system produces a minimum re-proof plan.
Why WebMCP
WebMCP turns the page from a dashboard into a structured human-agent collaboration surface. The release exposes seven tools that let an agent read the mission, inspect authority, inspect the candidate contract, list known contract risks, inspect evidence state, request a bounded human decision, and submit an adversarial counterexample.
The key tool is submit_counterexample. It lets the agent actively pressure-test the human-owned definition of done while keeping semantic authority with the human.
Better human-agent UX
The point is not to make people write longer specifications. The system concentrates human attention on the few decisions automation cannot safely settle, gives the agent a typed way to expose loopholes, and keeps deterministic code responsible for evaluation and proof state. A later dependency change reopens only evidence that actually depended on what changed rather than discarding all prior proof or trusting a stale green checkmark.
What people and agents can do together
The agent can inspect mission, authority, candidate acceptance criteria, contract risks, and proof state; request a bounded human decision; and submit a concrete adversarial counterexample. The human owns unresolved meaning and admission. Deterministic code owns evaluation, proof validity, dependency impact, and minimal re-proof.
Demo
The demo begins with an agent claiming a landing-page task is DONE. The initial acceptance contract is deliberately wrong in two directions:
- False green: it forgets to require the waitlist signup to actually persist.
- False red: it requires one exact headline even though the human said wording does not matter.
The agent submits a broken-waitlist counterexample. The deterministic engine returns EXPOSES_FALSE_GREEN, records the visible challenge, and leaves the active contract unchanged.
The human resolves the genuinely semantic admin-privacy question, the corrected contract is admitted, and five requirements earn evidence-backed PROVEN state.
Then a dependency changes. Exactly two of five proof receipts become STALE while three remain PROVEN. Re-running only the affected checks restores 5/5.
WebMCP implementation
Seven imperative tools register through the current document.modelContext surface when available, with the older navigator path retained only as compatibility fallback. submit_counterexample uses a narrow JSON schema, additionalProperties: false, runtime size/type validation, and an untrusted-content hint. It is non-read-only only because it records a visible challenge. It has no capability to edit or admit the acceptance contract.
Evidence boundary
This project does not claim that AI can automatically infer arbitrary human intent, that acceptance contracts themselves are novel, or that every verification problem is solved.
The demonstrated contribution is narrower: an agent can adversarially falsify the human-owned definition of done without becoming the authority, and proof can remain dependency-aware after reality changes.
The final licensed release passes 38/38 deterministic tests, TypeScript typecheck, static build, responsive browser verification, seven-tool WebMCP current-API harness registration, adversarial counterexample execution, agent-content injection probes, deployment-header verification, and zero unauthorized contract mutation.
Existing-project disclosure
Existing project, meaningfully extended during the challenge. The underlying contract-adequacy and continuous-validity research began before August 25. During the WebMCP Challenge submission period, the project was materially extended with the responsive human product surface, authority reconciliation, seven WebMCP tools, the agent-submitted counterexample mechanism, WebMCP trust boundaries and runtime validation, current-API harness verification, deployment-origin and permissions hardening, browser/mobile/injection verification, public-release packaging, and challenge-specific testing/documentation. Dated commit history and release evidence preserve that distinction.
Built With
- css
- html
- javascript
- node.js
- playwright
- typescript
- webmcp
