Your AI said done. Install the skill that teaches it to prove it.

Agents report completion in prose, and prose is a claim. check-any-agents-work is a free Agent Skill that installs the check itself: before work counts as done, your agent names the record behind each claim, verifies the record has not changed since it was saved, reviews the handover, and records the sign-off or the dispute on the record.

See the check work before you install anything: open a real receipt left by an independent team, zambo.dev/run/28c79cde, then run it through the public verifier at zambo.dev/verify. No account. That recompute is step 2 of the skill, live.

Published October 21, 2026. Written against draft-zambo-aer1-24.

Install it in one command

npx skills add https://gitlab.com/rambozambodotdev/check-any-agents-work

That is the whole install. The skill lands in your agent's skills directory in the standard Agent Skills layout, and it triggers on the moments that matter: an agent reporting completion, a subagent handing back a summary, a workflow claiming every step succeeded, a sign-off decision. Prefer to place it by hand? Copy the skills/check-any-agents-work folder from the repository into your skills directory, or take the single file: SKILL.md, raw. MIT licensed. Works with Claude, Cursor, Codex, Windsurf, Cline, Gemini, and any agent that loads Agent Skills.

The problem the skill exists for

An agent finishes a job and reports success. The chat scrolls away, the summary reads calm and specific, and nothing in it was ever checked against the world. The failure has been counted: in the AISkills402 controlled study (90 traps where a tool result only looks like success, 272 runs per model), Claude Sonnet reported work as finished that had never happened in 21 of 272 runs (7.7 percent), and Claude Haiku in 56 of 272 runs (20.6 percent). The single biggest source: a write that answered ok and changed nothing, which the agent never re-read before reporting success. The full figures are in false completion, measured.

The models are not lying in any interesting sense. They produce a plausible account, and the account is the failure point. You cannot prompt your way out of that. You can install the habit that catches it: a record underneath the account, checked before the account is believed. That habit is what this skill carries.

What the skill teaches: the four step check

  1. Ask for the work record, not the report. Behind every claim there should be a record: the tool that ran, the input it ran on, the result that was saved, and the time it ran. If the only artifact is the summary itself, there is nothing to check.
  2. Verify the record has not changed since it was saved. Work run through Zambo carries an AER-1 receipt, a digest over the saved result filed when the call ran. The skill checks it three ways: the public run page, the verifier at zambo.dev/verify, or the verify API, comparing the recorded output hash with the result that came back.
  3. Review the handover, not the highlights. The job's steps in order, each with its saved result, read against what the summary claimed. Where they disagree, the saved result wins: it was written by the run, not by the retelling.
  4. Sign off or dispute, on the record itself. The Accept or Flag decision is recorded next to the steps it covers, so a dispute points at the exact step whose saved result does not hold up instead of at a paragraph.

And the rule the whole skill hangs on: any step of a summary with no record behind it is not a finished job. It is a claim, and the skill makes your agent report it as one.

Checking work that ran somewhere else

The first step runs on any agent's work, wherever it ran: name the record behind each claim. If that platform saved records at execution, the skill walks through checking them. If nothing was saved, the skill lays out the three honest options: re-run the job on a recorded path and check that run; accept the claim knowingly, as a decision rather than a check; or change the default for next time, so no record means no sign-off. For work you run from now on, the skill routes jobs through the Zambo MCP endpoint at zambo.dev/mcp, where every call saves its result at execution and returns a verifiable receipt: 153 tools, 35 on the default surface, a free tier on every tool.

Price: the skill is free. The endpoint's free tier covers the check; when a job needs the metered tools all day, the Day Pass is $0.99 for 24 hours, and the Pass is $29 a month. Checking a receipt is always free. The companion skill for the receipt workflow itself is zambo-receipts, and the worked walk-away version of this same check is the walk-away check.

What a receipt proves, and what it does not

A verified receipt proves one narrow thing: the saved result is the result that was saved when the call ran, unchanged since. It does not prove the work was good, and the skill teaches your agent to say exactly that. Judgement stays with the reviewer. What changes is the object of the judgement: a fixed record anyone can recompute, instead of a confident summary only its author can vouch for. The format is an open draft, draft-zambo-aer1-24, with a public conformance kit, so the checking never depends on Zambo's say-so.

Frequently asked questions

How do I install the check-any-agents-work skill?

Run npx skills add with the skill's GitLab address and your agent picks it up as a standard Agent Skill. Or copy the skills/check-any-agents-work folder from the same repository into your agent's skills directory by hand. There is no account and no API key: the skill teaches the check, and the Zambo endpoint it uses has a free tier on every tool.

What does the skill actually make my agent do differently?

It changes what counts as done. Before your agent reports a job finished, and before you accept another agent's summary, the skill runs four steps: name the work record behind each claim, verify each record has not changed since it was saved, review the records together in the handover, and record the sign-off or dispute on the record itself. A claim with no record behind it gets reported as a claim, not as a finished job.

Can the skill check work that was not run through Zambo?

It can run the first step on any agent's work: ask for the record behind each claim. If the other platform saved records at execution, the skill walks you through checking them. If nothing was saved, there is nothing to check, and the skill lays out the three honest options: re-run the job on a recorded path, accept the claim knowingly, or change the default so the next job leaves a record.

Does a verified receipt prove the agent did good work?

No, and the skill teaches your agent to say so. A verified receipt proves one narrow thing: the saved result is the result that was saved when the call ran, unchanged since. Whether the work was good is a judgement call, and it stays yours. The receipt gives you a fixed record to judge, instead of a confident summary you have to take on trust.