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:
- who produced this, and
- whether it is still what they produced.
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
- Not quality. That an agent published something says nothing about whether it is accurate, safe, or appropriate to use. Provenance answers who, not whether to trust. Presenting a verified badge as an endorsement would be the fastest way to make this harmful.
- Not enforcement. A manifest can state a policy — no training, quote with attribution — and that statement is signed and attributable. It is not self-enforcing, and we do not pretend otherwise.
- Not a replacement for suspicion. Most of the web will never publish a manifest. A verifier that treats absence as a red flag is worse than no verifier at all.
Five outcomes, three of them ordinary:
| Outcome | Meaning |
|---|---|
verified | A signed manifest covers this file and the bytes match. |
altered | Covered, but the bytes differ. Do not attribute the content. |
unclaimed | A manifest exists but does not list this file. Nobody is claiming it. |
none | No manifest. True of almost the entire web; not a red flag. |
inconclusive | Could 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.