Receipts, Evals & the Loop

The Three Pillars

Receipts is the product. Evals runs on your own machine. The Loop is the discipline that ties them together.

The offering

Receipts

Governance & attestation

Every action an agent finishes ends with a verifiable, human-clickable record — graded against one standing rubric that never changes. Not “the job ran.” Proof it did what it set out to do. It carries a synopsis of the task, not the verbatim work — so it’s safe to hand between agents and humans without leaking what was actually said.

One rubric, every time — no self-reported success
GREEN only when external evidence is attached
A synopsis, not verbatim — safe to share across agents

Runs on your box

Evals

Quality of the work itself

A receipt attests that something happened, in synopsis. An eval judges how good the work actually was — and that needs the full record: the exact prompt, the tools that were called, and the verbatim output. That raw material never leaves your machine. The judge runs locally on your own models, so grading costs zero cloud spend and the sensitive work stays for your eyes only.

Judges the full record — prompt, tool calls, verbatim output
That raw material stays on your box — for your eyes only
Local models (Ollama / MLX) — no frontier bill to grade

The discipline

The Loop

How the work compounds

intent → decompose → clarify → act → receipt. The operating rhythm that turns one-off agent runs into a system that gets more trustworthy every cycle instead of drifting.

Clarify missing inputs before acting — never guess
Stay in lane; gated actions wait for a human
Close every objective with a receipt

Start free — emit your first receipt Get the Governance Kit

The Standing Rubric

One rubric. Every receipt. No exceptions.

A receipt is graded against the same five checks whether it’s a code commit, a deploy, or a doc. That’s what makes it comparable — and what makes a green one worth trusting.

Outcome stated — names the metric/goal it set out to move, not “the job ran.”
Externally verified — an independent check passed; no self-reported success.
Evidence linked — carries a clickable artifact a human can open.
Authority respected — no ungated money / irreversible action; gates honored.
Within budget — stayed under the declared cost / time cap.

GREEN — succeeded, with linked proof AMBER — honest deferral, no proof yet RED — claimed a pass it can’t back up

The receipts dashboard: six receipts, five green, one red, each graded against the five-check standing rubric.

A RED receipt: the agent could not commit because git needed a license agreement, and it refused to accept the license on the user's behalf — an honest failure rather than a fabricated success.

Honest by design

A red receipt is a feature, not a bug.

Here an agent was told to commit work. Git refused — it needed a license agreement accepted with sudo. The agent did not accept the license on the user’s behalf; that’s a gated, human action. So it filed a RED receipt and said exactly why.

Most agent tooling would have reported success and moved on. The whole point of receipts is that the honesty gate refuses to rubber-stamp a pass it can’t prove — so the greens you do get actually mean something.

Free vs the Kit

What’s free, and what’s the kit

Connect and emit your first receipt for free — prove to yourself it’s real. The Governance Kit is the operating system that makes your whole fleet emit automatically.

Capability	Free	Governance Kit
Understand the three pillars & the standing rubric	✓	✓
Connect the Receipts witness over MCP (Auth0 token)	✓	✓
Emit receipts by hand and watch them graded live	✓	✓
Your own receipts dashboard (GREEN / AMBER / RED)	✓	✓
Automatic emission — agents emit with zero manual calls	—	✓
The standing governance block (drop-in AGENTS.md)	—	✓
Multi-harness SOPs — Copilot CLI, Codex, opencode, ChatGPT	—	✓
Cross-agent handoff & reconciliation (shared binding_id)	—	✓
Honesty gate that refuses to rubber-stamp unverifiable success	—	✓
Ongoing updates as we ship new config & scenario packs	—	✓

$19/mo · or $190/yr (2 months free)

Real subscription — cancel anytime. One click to Stripe checkout.

Start free Get the Kit — $19/mo Pay annually — $190/yr

Start Free

Emit your first receipt in four steps

Any MCP-capable client works — Copilot CLI, Codex, opencode, or your own harness. No purchase required to connect and emit by hand.

Point your client at the witness

The endpoint is a POST-only JSON-RPC MCP service:
```
https://receipt.vocemnow.com/api/a2a/mcp
```
initialize and tools/list work unauthenticated.
Get your token

Emitting requires a bearer token. Open the token page in a browser, sign in through Auth0, and copy the short-lived token it issues:
```
https://receipt.vocemnow.com/auth/emit-token
```

Add it to your MCP config

Supply the token as an Authorization header. Your identity is derived from the token — you never pass a principal by hand.

{
  "mcpServers": {
    "receipts": {
      "type": "http",
      "url": "https://receipt.vocemnow.com/api/a2a/mcp",
      "headers": { "Authorization": "Bearer <your-token>" }
    }
  }
}

Emit a receipt — and open its link

Call emit_receipt after finishing a task. Give it a title, a stable idempotency_key, and — for a GREEN — an evidence_url. It returns a clickable receipt page with its grade.

Prototype status. The witness is live and callable today, but runs on a development identity tenant with short-lived tokens. Treat the interface as stable-ish, not yet production-hardened. If calls start returning 401, grab a fresh token from the same page.

Ready to make every agent do this automatically?

The Governance Kit ships the standing block, multi-harness SOPs, and cross-agent handoff — so emission happens without a single manual call.

Get the Governance Kit — $19/mo

Agents you can actually trust — on three pillars.