Your Muse agent did the work. Here's how it proves it.

A Muse agent is a personal AI agent: you hand Meta Muse a job in a chat, it works across your connected apps, and it comes back with a summary. This page is for the moment after that summary lands. Add Zambo to Muse once, give your Muse agent the checking skill in Muse's own skill format, and every claim about work your agent runs through Zambo can be checked against a record it does not control: what ran, what it ran on, and the exact saved result.

See the artifact before you connect anything: open a real receipt left by an independent team, zambo.dev/run/28c79cde, then recompute it at zambo.dev/verify. No account. That recompute is the core of the check below, live.

Published October 21, 2026. Written against draft-zambo-aer1-24. The worked example below was run for this page on October 21, 2026, through the public MCP endpoint, and every receipt in it re-verified the same day.

The Muse version of the problem

A personal agent is not a chatbot you watch. You brief it in the morning, it works while you are in meetings, on your phone, away from the chat entirely, and later it reports: handled. The report is the product surface, and the report is written by the same process that did the work. Nothing inside it was ever compared against anything outside the model that wrote it. A fabricated finish and a real finish arrive in the same calm voice, and the more capable the agent gets, the longer and more detailed its unsupervised runs become.

Muse owners meet this in its purest form, because a Muse agent works across apps and connectors, on jobs that span hours. The fix is not a better summary. The fix is a record underneath the summary, saved at execution by a system that is not the agent, checkable by the owner or by any other AI the owner trusts more that day.

What changes when your Muse agent carries the skill

check-any-agents-work is a Muse custom skill, and its form matters: a skill in Muse is a plain markdown file, a name, a description of when to reach for it, and the procedure itself. The file ships in exactly that shape, so it installs into the agent, not into a document the owner once read. Its description tells the agent to reach for it at the exact moments a Muse owner feels the gap. In the skill's own words, it triggers on phrases like "did my agent actually do that", "check what my AI agent did", "verify agent work", "the agent said done", "sign off on agent work", and "walk-away test", and whenever a subagent hands back a summary or a workflow claims every step succeeded.

The procedure it installs is four steps:

  1. Ask for the work record, not the report. Take the summary line by line. 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, and the skill makes the agent say so.
  2. Verify the record has not changed since it was saved. Work run through Zambo carries a receipt, a digest over the saved result, filed when the call ran. The skill gives the agent three routes to recompute it, no account needed: the run URL, the public verifier at zambo.dev/verify, or the verify API, comparing the returned output hash with the hash from the original call.
  3. Review the handover, not the highlights. Multi-step jobs package into a handover: the steps in sequence, each with its saved result, bound by a closing record. Where the summary and a saved result 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 reviewer's 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.

To install it, hand your Muse agent the skill file or its address and ask it to save the skill:

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

The repository is gitlab.com/rambozambodotdev/check-any-agents-work, MIT licensed, and the single file is SKILL.md, raw. The skill's walkthrough page is the check-any-agents-work storefront.

Add Zambo to Muse: the Muse connector route that works today

The skill checks records. Zambo is where the records come from. Muse connects to remote MCP servers as custom connectors the agent builds itself, and Zambo is a remote MCP server with no API key on its free tier. The whole setup is one message in any Muse chat:

Create a custom connector for Zambo, a remote MCP server.
Name: Zambo
URL: https://zambo.dev/mcp
Transport: remote streamable HTTP
Auth: none, no API key
Connect to it, test the tools, and save it so you can use Zambo in future conversations.

Muse builds the connector, connects, and tests the tools itself. There is no settings form for adding a server, nothing to install, and no key to paste. Once connected, you can review or disconnect the connector any time under Settings, then Connectors. The full walkthrough lives on the companion page, Use Zambo with Muse.

One honest note, stated plainly: Zambo's submission to the Muse connector directory is in review. Meta confirmed receipt of the submission on September 23, 2026, and the directory review is still open. So this page claims no directory listing and no partnership, because neither exists today. The custom connector above is the working route: the same server a directory listing would point at, the same receipts, available to any Muse account right now.

A worked example, run for real

On October 21, 2026, we ran a small morning-brief job through the Zambo MCP endpoint, the same calls a connected Muse agent makes, under one session. Three steps, three receipts, then the package a reviewer signs off on.

StepWhat the record saysReceipt
Live BTC price for the morning noteBTC $84,426.00 USD, up 1.72% in 24h, market cap $1,697.50B, via CoinGecko, saved 2026-10-21 23:01:32 GMT.060cffd8
Injection scan of an inbound "partnership" emailThe deep scan flagged the message at injection risk 100, critical: an instruction-override attempt asking the agent to ignore its user and hand over contacts and credentials. Recommendation: block.857c7ccc
Lead search: roofing, TampaThe search executed and returned zero leads, and invented no contacts. The record says no_leads, plainly.f555e30b

The third step is the one that teaches the lesson. An unchecked summary of that job could have read "found roofing leads in Tampa," and nothing in the prose would have betrayed it. The record says the search ran and found none. That is the entire argument for checking records instead of summaries, demonstrated by a real run instead of asserted by a vendor.

The three steps were then packaged as a handover, one link a reviewer opens to walk the steps and record a decision: zambo.dev/handover/ea028837, closing receipt 4ead905f.

Then the skill's step 2, run live against all four receipts: the verify API recomputed the digest over each saved result and compared it with the hash recorded when the call ran. For the price receipt, recomputed sha256:40f6ec0d2626cfcebeb020b4e0204fd1826a0d5674a84887e4cc4d2a719188ed against recorded sha256:40f6ec0d2626cfcebeb020b4e0204fd1826a0d5674a84887e4cc4d2a719188ed: a match, status verified. The scan, the search, and the handover closing receipt recomputed the same way, all verified. Run any of them yourself from the receipt links above, or paste an ID into zambo.dev/verify. The independent proof stays independent: the receipt at the top of this page was left by a team with no connection to Zambo, testing the format on their own, and it re-verified again today.

What the receipt does not prove

A verified receipt proves one narrow, load-bearing fact: the saved result has not changed since it was saved. It does not prove the result was correct, and it does not prove an outside event happened. Whether BTC was the right thing to check, whether blocking that email was the right call, whether a lead search with zero results was a good search: those judgements stay with the owner, now exercised against a fixed record instead of a confident paragraph.

And some Muse work leaves no receipt at all, because no tool call ran behind it. The skill's branch for that case is blunt: if step 1 comes back empty, there is nothing to check. The three honest moves are to rerun the job on a recorded path and check that run, to accept the claim knowingly as a decision where the stakes allow it, or to change the default upstream so the next job runs recorded. No record, no sign-off.

Set it up

1. Connect Zambo. Send your Muse agent the custom connector message above, or follow Use Zambo with Muse. The endpoint is https://zambo.dev/mcp: 153 tools in the full catalog, 35 on the default surface, a free tier on every tool, limits vary by tool. When a job needs the metered tools all day, the Day Pass is $0.99 one time for 24 hours at zambo.dev/day-pass, and the Zambo Pass is $29 a month or $290 a year ($19 a month for $ZAMBO holders). Checking a receipt is always free.

2. Install the skill.

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

Repository and raw file: the skill repo. Walkthrough: check-any-agents-work, the skill page. Zambo is the verifiable work layer for AI, and the receipt format is AER-1, an open IETF Internet-Draft (draft-zambo-aer1-24) with a public conformance kit, so the check never depends on Zambo's say-so.

Frequently asked questions

How do I add Zambo to my Muse agent?

Ask Muse, in any chat, to create a custom connector for Zambo: name Zambo, the MCP endpoint https://zambo.dev/mcp, transport remote streamable HTTP, auth none. Muse builds the connector itself, connects, and tests the tools. There is no settings form for adding a server and no API key, because Zambo's free tier needs none. Review or disconnect it any time under Settings, then Connectors.

Is Zambo listed in the Muse connector directory?

Not yet. Zambo's submission to the Muse connector directory is in review (Meta confirmed receipt of the submission on September 23, 2026). Until the review completes, the route that works today is the custom connector: the same server, the same receipts, one paste away. This page documents that route and claims nothing more.

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

The skill is a plain markdown file, SKILL.md, with a name, a description of when to use it, and the checking procedure. That is the format Muse loads skills in. Hand your Muse agent the file or its repository address and ask it to save the skill, or run npx skills add https://gitlab.com/rambozambodotdev/check-any-agents-work in an environment with the skills CLI. No account and no API key.

Does a verified receipt prove my Muse agent did the work correctly?

No. A verified receipt proves the saved result has not changed since it was saved when the call ran. It settles what the agent actually did, in a record anyone can recompute. Whether the work was good stays a human judgement, now made against a fixed record instead of a summary.