Give the agent a timestamping tool through an MCP server, the standard way a client such as Claude Code, Claude Desktop or Cursor connects an agent to outside tools. To show what the agent did, keep a separate run receipt: a chain of fingerprints of each step, with the end of the chain recorded on a public blockchain.

The two answer different questions. The tool shows that a file existed by a certain time. The receipt shows that a recorded sequence of steps existed by a certain time and hasn't changed since. Neither shows that the agent was right.

Giving the agent a tool that can timestamp a file

The verify-proof package ships an MCP server with twelve tools. They include hashing a file, submitting a proof, checking a proof and verifying a proof bundle offline.

A hash is a short fingerprint calculated from a file's bytes. Change one byte and the fingerprint changes. The agent hashes the file with SHA-256 on your machine and sends only that hash. The file never leaves the machine, whatever its type or size.

ProofLedger then records the hash on Polygon, a public blockchain, in its own public transaction. That usually takes under a minute.

Claude Code

Install the plugin from the verify-proof repository:

/plugin marketplace add Fulcrum-Enterprises/verify-proof
/plugin install proofledger@proofledger

This gives the agent the MCP tools plus two commands, /proofledger:anchor and /proofledger:verify. The agent can then anchor a release or a document and save its bundle in one step.

The plugin installs from that repository. It isn't listed in Anthropic's plugin directory.

Cursor

Use the one-click install link. It needs uv, the Python tool runner, on your machine. The server isn't listed in Cursor's marketplace or on cursor.directory.

Claude Desktop

Add the server to your MCP configuration using this command, which also needs uv:

uvx --from verify-proof[mcp] verify-proof-mcp

The API key

Submitting a proof takes a ProofLedger API key, which you create under Account > API Keys. ProofLedger keys have no scopes, so an agent holding one has the same access as anything else using that key. Keep it out of prompts and out of files the agent might share.

What the agent's timestamp proves

A proof shows that this exact file existed no later than the moment the hash was anchored. That's the whole claim.

It doesn't show who made the file. It doesn't show when the file was first created, only the latest time it could have been created. It also confers no legal right. If an agent generates a report and anchors it, the proof fixes the report's bytes and latest possible date. It says nothing about how the report was produced, which is the job of the receipt.

Every proof gets a public verify page, which looks the proof up in ProofLedger's records. To check without ProofLedger, use the bundle, a small file holding the hash, chain, transaction id and anchor time. The verify-proof package compares the file with the bundle on your own machine, with no network call. Anyone can then look the Polygon transaction up on a block explorer.

Keeping a receipt of the agent's run

An agent run receipt uses the format proofledger-agent-run-receipt/1. It records each step of a run, such as a prompt, a tool call or an output, as a salted SHA-256 fingerprint of that step's content. Salting mixes extra data into the hash, so someone can't work out short or predictable content by hashing guesses and comparing the results.

Each entry also carries the step's type, its time and, if you want one, a short label. The content itself isn't stored in the receipt. That's what lets you prove what an agent did without storing what it saw. Labels are readable text, so keep sensitive details out of them.

The steps are hash-chained, meaning each link depends on the one before it. Edit, reorder or remove a step and the end of the chain, called the head, no longer matches. Only the head needs anchoring, and it goes on chain as one ordinary proof, so each run counts as one API proof. There's no separate endpoint or price for receipts. Current plans and limits are on the pricing page.

The bundle for that proof is saved into the receipt. From then on, the receipt verifies offline:

verify-proof receipt verify

Receipts are available through the verify-proof CLI and MCP tools. The Python and Node clients carry RunReceipt, and there's a LangChain callback example for recording steps from a LangChain agent. The format is documented in the receipts reference.

What a receipt can't tell you

A receipt proves that these steps existed in this order no later than the anchor. Several things people may want from it are outside that claim:

  • Whether the agent behaved well. A run full of wrong answers and bad decisions produces a receipt that verifies perfectly.
  • What the data contained. A fingerprint reveals nothing about the content on its own. The receipt doesn't store the prompt, the output or anything else the agent saw.
  • Who ran it. Nothing in the receipt identifies the person or the organization behind the run.
  • Whether every step was recorded. The chain covers the steps that were written into it. A step that was never recorded leaves no gap to detect, so the receipt shows that the record is unchanged, and doesn't show that the record is complete.
  • When each step really happened. The anchor time is the part a third party can check on the chain. The time on each step is part of the recorded data. The anchor shows it hasn't changed since, which isn't the same as showing it was accurate.

If you need to show that a particular output came from a run, keep that output somewhere you control, along with what's needed to match it to its step. If you discard it, the receipt still shows that a step existed, but you'll have nothing to show for what the step contained.

Can I create a receipt for a run that's already finished?

Not one that carries the same weight. A receipt has value because the head was anchored soon after the steps happened. If you build a chain today from last month's logs and anchor it, you've shown that those logs existed in that form by today. That can still be worth doing if the logs matter, but it says nothing about last month.

The same goes for a file. Nothing can be anchored retroactively, and an anchor can't establish a date that was never recorded. If the run might matter later, the recording has to be running while the agent works.

Which one do you need?

If the question is "did this file exist by this date, in this exact form?", the tool is enough. The agent hashes the file, submits the hash and saves the bundle.

If the question is "what sequence of steps did this run record, and has that record changed?", you need the receipt. It answers that question without you having to retain the run's content in the receipt, and without giving the content to ProofLedger.

They also work together. An agent can anchor the files it produces with the tool, and the run that produced them can have its own receipt. Those are separate proofs answering separate questions.

Setup details for all of this, including the MCP tools and receipts, are at proofledger.io/agents.