TL;DR

  • AI agents finish tasks and report "done." A diff proves code changed — it does not prove the app behaves correctly. Today that gap is filled by you, re-running everything by hand.
  • Proof of work is the fix: the agent verifies its own change on a real screen, records that verification with Clipy, stamps timestamped observations onto the recording, and hands you two links — a watch page for humans and a .md twin other agents can read.
  • It works with Claude Code, Codex, Cursor, Windsurf, OpenCode — or any tool that can run a CLI. One line in your task prompt is enough: "when you're done, verify the change and send proof through Clipy."
  • Three proof paths, so the agent uses whatever it already has: stitch screenshots into a narrated recording, upload a video its browser tool already produced, or record the live verification session — including the real Mac screen.
  • You watch 30 seconds instead of re-running the task. Or you don't watch at all — another agent reads the proof and confirms it.

The trust gap nobody talks about

Delegating work to a coding agent has a strange asymmetry. The agent does twenty minutes of work in two; then you spend ten minutes checking it. Pull the branch, run the app, click through the flow, squint at the result. The agent said "the fix works" — but "works" was a claim, not evidence, so you became the QA department for your own delegation.

The standard artifacts don't close this gap:

  • The diff proves the code changed. It says nothing about whether the button now does the right thing when clicked.
  • Test output proves the tests pass — the tests the same agent may have just written, exercising the behavior it decided to exercise.
  • The agent's summary is the least reliable of all: a model describing its own success, with every incentive (and every failure mode) pointing toward "done ✅."

What closes the gap is the same thing that closes it between humans: show me. Not "the login fix works" — a recording of the login page rejecting the bad password and accepting the good one, timestamped, with the observed values written down. That's what we mean by proof of work: verification you can watch, attached to evidence you can check, produced by the agent as the last step of the task.

What Clipy proof of work actually is

Clipy is an agent-native screen recorder: every recording gets a transcript, an AI summary, key moments, and a machine-readable .md twin at clipy.online/video/<id>.md that any agent can fetch and read. Proof of work builds on that. When an agent finishes a change, it:

  1. Runs the real verification — opens the app, performs the flow the change was supposed to fix.
  2. Records it — as video, through whichever capture path fits its environment (below).
  3. Marks the evidence — timestamped observations with literal observed values: "Reproduced: total shows $0 — verdict fail", then "After fix: total shows $49 — verdict pass", with chapters like BEFORE and AFTER.
  4. Returns two links — clipy.online/video/<id> for you, and the .md context document for any agent that needs to consume the result.

The marks matter as much as the pixels. A raw screen recording still makes you hunt for the moment that matters; a marked one is skimmable — the timeline tells you where the before is, where the after is, and what value was observed at each. One honesty note that's core to the design: marks are driver-attested. They prove what the agent driving the verification reported observing, at a timestamped moment in the footage — Clipy doesn't independently certify the claim. That's exactly the status of a human QA engineer's notes, and it's why the video is attached: the footage is what makes the attestation checkable.

Run it alongside Claude Code, Codex, Cursor — or anything else

Setup is three commands, once:

npm install -g @clipy/cli
clipy login
clipy agents install claude   # or: codex / cursor / windsurf / opencode

agents install teaches your agent the workflow — when to record, how to mark evidence, what to return — as a skill for Claude Code, Codex, Cursor, Windsurf, or OpenCode. There's also an MCP server (@clipy/mcp) if your tool speaks MCP: it exposes recording control (record, start_recording, add_marker, stop_recording) plus search and reading tools over your whole library.

From then on, the ask is one sentence in any task prompt:

Fix the checkout total bug. When you're done, verify the fix
in the running app and send proof through Clipy.

The agent picks the capture path that fits where it's working. That neutrality is deliberate: Clipy plugs into whatever browser or automation tool the agent already uses — it never requires installing Playwright, Browser Use, or any particular driver just to produce proof.

The three proof paths

1. Screenshots in, recording out: clipy proof --frame

Almost every agent tool can already take screenshots. clipy proof turns them into evidence:

clipy proof \
  --frame before.png --caption "Before: checkout total shows $0" \
  --frame after.png  --caption "After: checkout total shows $49" \
  --title "Verification: checkout total fix" --type bug --json

Clipy stitches the frames into a silent video, places each caption at its moment on the recording clock as narration, uploads it, and prints the watch URL plus the .md context URL. Two to four focused screenshots with literal observed-value captions is usually all a verification needs — and this path asks nothing of the environment beyond ffmpeg for the encoding.

2. The tool already recorded video: clipy proof --video

Playwright can record WebM natively; Browser Use Cloud produces MP4s; plenty of harnesses emit a video artifact anyway. Don't re-record — hand the file over:

clipy proof --video verification.webm \
  --note "0: opened checkout" \
  --note "6: total shows $49 after fix" \
  --title "Verification: checkout total fix" --type demo --json

The video uploads without re-encoding, the notes become timestamped narration, and the same two links come back. The tool that owns the browser keeps owning it; Clipy is the proof sink, not a second driver fighting for the debugger.

3. Record the live session — web, or the real Mac screen

For proof of the whole journey rather than its endpoints, the agent records while it verifies. Headless web:

clipy session start --url http://127.0.0.1:3000 --expose-cdp --json
# drive the page, then:
clipy mark "After fix: total shows $49" --observed "$49" --verdict pass
clipy session stop --json

Clipy launches the browser and exposes CDP; the agent attaches its own driver and works while Clipy records. There's also clipy record --url for a one-shot capture where inline notes become the transcript.

And for anything a headless browser can't see — a native Mac app, an iOS simulator, a desktop flow — the Clipy Mac app records the actual screen: clipy sources --json lists capturable windows, and session start --source mac-screen --window <id> records exactly that window while the agent drives it. The CLI even reports back which window the camera actually resolved so a careful agent can abort if it's about to film the wrong surface. This is the "you don't have to run the thing yourself" mode in its fullest form: the agent operates the real app on a real screen, and the recording is your seat in the room after the fact.

Why a recording, and not just logs?

Because behavior is visual and temporal. "The modal closes when you press Escape" is a claim about pixels over time. Logs can't show a layout shift, a flash of unstyled content, a button that technically fired but visibly didn't respond. Video is the only artifact whose fidelity matches what was claimed.

Because it's asynchronous trust. Watching an agent work live defeats the purpose of delegation — you've replaced doing the work with staring at the work. A recording moves verification to your time: skim the key moments over coffee, jump to the AFTER chapter, done in thirty seconds. Recordings also outlive the session — when someone asks in three weeks whether the fix was actually verified, the answer is a link, not an archaeology dig through terminal scrollback. We've written before about why the AI summary makes async video readable; proof recordings inherit all of that.

Because agents can read it too. This is the part that compounds: the .md twin means proof isn't just human-checkable, it's agent-checkable. A second agent — a reviewer in your CI, a fresh Claude session, your future self's assistant — fetches the context document, reads the marks and transcript, and confirms the verification covered what the ticket asked. The full pattern, including having one agent verify another's proof, is walked through in Your Agent Fixed the Bug. Prove It.

Where this lands in practice

  • Pull requests. A PR that carries a proof link changes review economics: the reviewer reads the diff for design and watches thirty seconds for behavior, instead of pulling the branch. Clipy proof previews even autoplay in GitHub PRs.
  • Overnight and background agents. The whole point of an autonomous loop is that you're not there. Proof links are how the morning-after review takes minutes: each completed task ends in a recording, each recording ends in a verdict.
  • Bug fixes with a before/after. Repro recorded, fix applied, same flow re-recorded — the BEFORE/AFTER chapter pair is the entire argument. (Bug-report recordings also get generous key-moment budgets in Clipy, because a missed repro step costs a debugging cycle — see bug repros that write themselves.)
  • Client and stakeholder updates. "The feature is live, here's it working" as a link that unfurls in Slack beats a paragraph of assurances — no account needed to watch.

What proof of work is not

Boundaries, stated plainly, because trust tooling that oversells itself defeats its own purpose:

  • It is not certification. Clipy preserves the footage as recorded or uploaded and stamps the marks exactly where the driver placed them — it vouches that the driver reported it, not that the claim is true. Whether the verification was the right verification remains a judgment — yours, or a reviewer agent's, made against the footage.
  • It is not surveillance of the agent's every move. The recording covers the verification step, not the whole work session. You're buying evidence, not a wall of footage.
  • It does not replace tests. Tests catch regressions forever; a proof recording documents that the change worked, visibly, at ship time. You want both — they fail differently.

FAQ

What does "proof of work" mean for AI agents?

A verifiable record that an agent's change actually works: the agent runs the real verification on screen, records it, marks timestamped observations with pass/fail verdicts, and returns a watchable link plus a machine-readable context document — instead of just claiming success.

Which agents does Clipy work with?

clipy agents install ships workflows for Claude Code, Codex, Cursor, Windsurf, and OpenCode; the MCP server covers MCP-speaking tools; and the CLI works from anything that can run a shell command — which is to say, effectively any agent.

Do I need Playwright or a specific browser tool?

No. That's the point of the three paths: screenshots from any tool via proof --frame, an existing WebM/MP4 via proof --video, or a Clipy-launched recording session. Clipy never requires installing a separate browser driver just to produce proof.

Can another AI agent verify the proof?

Yes — every recording has a .md twin with the transcript, summary, and marks. A reviewer agent fetches it and checks the evidence against the task. The watch page's "Copy for agents" button hands any agent a paste-ready prompt to read a recording.

Does the person watching need a Clipy account?

No. Watch links open without sign-in, and recordings carry no watermark on any plan.

What does it cost?

The CLI, MCP server, transcripts, summaries, and the .md context documents are free on every plan. Free accounts get a one-time allowance of 15 recordings or 2 hours; Pro lifts the cap.

The one-line habit

Add the sentence to your next agent task: "When you're done, verify the change and send proof through Clipy." Run clipy login and clipy agents install once, and every "done" you receive from then on arrives with its receipts — a link you can watch, and a document your other agents can read. Delegation with evidence is the version of delegation that actually scales.