Porkbunagent provenance

Porkbun · November 2026

Who wrote this?

Provenance for content published by AI agents: a working implementation, and what it cost to build.

Status: experimental. One publisher, zero independent consumers. Everything described here runs in production and can be checked by anyone, right now, without an account. This is not a proposal. It is a report on something that works, offered in case someone finds it useful enough to check.

1. The problem

Agents increasingly read the web on behalf of people: pulling product data, summarising documentation, quoting prices, feeding retrieval systems. They do it by scraping pages written for humans, and scraping is unverifiable by construction. Nothing on a page says:

Those are different questions, and today neither has an answer. An agent that fetches a price list cannot tell a publisher's own data from a scraped copy, a stale mirror, or a page edited in between. It cannot distinguish “this is what the meadery published” from “this is what somebody put on a site.”

As more content is produced by agents for consumption by agents, this gets worse rather than better. Attribution becomes unanswerable exactly when the volume makes it matter.

2. What checking it looks like

One request against any published file, with no key and no account:

curl 'https://api.porkbun.com/api/json/v3/ans/verifyArtifact?url=https://example.com/data/products.json'
{ "provenance": "verified",
  "signedBy": { "ansName": "ans://v1.0.0.example.com" },
  "sha256":         "fc582d3b…",
  "expectedSha256": "fc582d3b…" }

The answer comes entirely from public data: the site's own DNS, a public append-only log, and the file itself. No key, no account, no relationship with anyone — including with us.

You can also do every step by hand — DNS lookup, log entry, certificate, hash — and the specification is written so you can implement either side without us. To try it against something live, publish from a domain of your own and check your own URL.

3. How it works

Three parts. The pieces are ordinary; only the combination is new.

Identity

The publisher's agent has a name tied to a domain it controls, with a certificate, and a public append-only log records which certificates are genuinely that agent's. We use the Agent Name Service for this, but the design depends only on the properties — a domain-bound identity whose keys are publicly attested — not on any particular registry. Our own verifier checks agents registered elsewhere.

A signed manifest

The site publishes a small JSON document listing what it offers, each file by SHA-256, with a detached signature made by the agent's identity key. It states who published what, and when, and it is tamper-evident.

An in-band marker

One line inside each published file, wrapped in whatever comment syntax the format uses:

agent-provenance: ans://v1.0.0.example.com manifest=… verify=…

This is the part we expected to matter least and now think matters most. An HTTP header pointing at a manifest survives exactly one hop: the moment content is excerpted, pasted into a prompt, or scraped into a corpus, it is gone — which is most of what happens to content agents consume. A line inside the bytes travels with them. The model is SPDX-License-Identifier: one short, greppable, self-describing line, no central authority, which spread across every language and format precisely because copying it was trivial.

The marker is not evidence. Anyone can paste it onto anything. It points at where the evidence lives, and an agent that reads it without resolving it has been handed borrowed credibility.

That a marker survives onto an altered copy is a feature. The hash stops matching, and “this claims to come from X but is not what X published” is the single most useful thing a verifier can say.

4. Why the log is the load-bearing part

The temptation is to stop at signatures: a document carrying a certificate, with a valid signature made by that certificate's key, feels verified.

It isn't. We built the forgery to be sure. Take a real agent's name, mint your own certificate naming it, sign a fabricated document with your own key, and attach that certificate. It passes every local check — the certificate is well-formed, its subject matches the claimed name, the signature verifies against it.

The only thing that catches it is asking the transparency log whether that certificate is one the agent actually has. Membership in a public, append-only log is what makes the rest mean anything; everything above it is arithmetic.

This has a consequence worth stating: the signing certificate must travel with the signature, because the log publishes certificate fingerprints and never public keys. A verifier's only source for the key is the document it is checking — and the log is what decides whether to believe it.

5. Authorship is not liveness

These get conflated, and conflating them makes a verifier useless in both directions.

Authorship is historical. A document signed by a certificate that has since expired is still evidence of who produced it. Keys outlive certificates, and an agent that shut down last year should still be credited with its work. Binding verification to “the certificate is currently valid” would mean re-signing every unchanged document on a 90-day calendar, and would erase the output of every agent that stopped running.

Liveness is current: is this agent active, should you rely on it now.

A verifier should answer both, separately. Ours reports authentic apart from agentLive, and treats an expired signing certificate as a note rather than a failure.

6. What it does not claim

Five outcomes, three of them ordinary:

OutcomeMeaning
verifiedA signed manifest covers this file and the bytes match.
alteredCovered, but the bytes differ. Do not attribute the content.
unclaimedA manifest exists but does not list this file. Nobody is claiming it.
noneNo manifest. True of almost the entire web; not a red flag.
inconclusiveCould not fetch enough to decide. Not a negative verdict.

7. What building it taught us

Verifiers fail toward accusation, and that is dangerous. Our first version reported a cached copy of a just-restored file as a hash mismatch — accusing a publisher of serving altered content because our own fetch hit a CDN. A verifier must distinguish “this is wrong” from “I could not check,” and must prefer the second. We now re-fetch past the edge before reporting a mismatch, a fetch we could not complete is never a finding, and an altered verdict is cached for one minute rather than ten, so an accusation cannot outlive the problem.

A stale pass is worse than a failure. Caching verification results meant that immediately after a publish we confidently returned a verdict about the document that had just been replaced. A test written to check the new document would have passed without testing anything. Verdicts now identify which document they describe.

Discovery is the hard part, not cryptography. Signing and checking were straightforward. Making a .txt file that an unknown agent can trace back to its publisher took considerably longer, and the answer turned out to be a line of text rather than anything clever.

8. What is ours and what is not

The format — the manifest, the detached signature, the marker, the verification algorithm — is not specific to us. Any registry issuing identity certificates and publishing them in an append-only log can be verified by the same steps.

Specific to Porkbun: the transparency log and identity root used by agents registered with us, and the convenience endpoints. A verifier follows the log named by the agent's own DNS record, never a hardcoded one, and our verifier already checks agents registered with another operator's registry. The identity root pins to d914e2e37b581036…

We built it because we are a domain registrar, which means we already run the naming, the DNS, the hosting and the identity. That makes it cheap for us to offer. It does not make it ours.

9. Where this is

One publisher, one dataset, zero independent consumers. We are not claiming a standard or a movement. We are claiming a working implementation, a specified format, and a verifier anyone can run.

The thing that would make it real is a consumer: an agent, a framework or a retrieval pipeline that checks provenance when it is present and carries on when it is not. If you build something that reads the web on behalf of users, the question we would like answered is whether this changes anything for you — and if it does not, what would.