AI-readiness

Can machines read it the way you intend?

A public institution publishes a new version of a regulation, with a clear note that the previous version no longer applies. A week later, citizens ask an AI assistant about the rules. The answer quotes the old version. In another case, the assistant blends the English page with an outdated translation and presents the result as the institution’s position. In a third, it summarises a draft that was published for consultation as though it were final.

The institution did nothing wrong by the standards of the web. Its pages are accurate, clearly written and easy for people to read. But the machines reading them had to guess which document was current, which translation was equivalent and which text was authoritative. They guessed wrong.

This is the problem we mean by AI-readiness. It is not about producing special content for AI. It is a property of how public information is published: whether a machine can identify what it is reading, which version is current and what the publisher intends, without having to reconstruct it.

For us, that is a publishing problem, and publishers can solve it.

Our position is simple to state. Public information should not make machines guess. The decisions that matter, which resource this is, which representation is authoritative, who stands behind it, how current it is, should move from machine inference into declarations the publisher controls.

The problem is publishing, not AI

Much of the discussion about AI-readiness starts from the model. How do we make our content attractive to AI? How do we optimise for answers instead of search results?

We start from the publisher. Institutions already publish authoritative information through interfaces designed for people and browsers. A person can usually tell which part of a page is the document and which is navigation, which version is current, which language they are reading and which organisation stands behind it.

A machine can extract the same words and still miss every one of those relationships. Two machines reading the same site can reach different conclusions about which address is canonical, whether two pages are the same document, whether one is a translation of the other, and whether what they read is still valid.

None of that is a failure of the model. It is a gap in the interface the institution publishes.

Machines are already your readers

Every public institution now has a new class of routine reader. It did not ask for it and, in most cases, has not adapted its publishing to it.

We consider machine readers first-class clients of public information. That does not mean building a second website for AI, or writing differently for machines than for people. It means publishing a machine-oriented representation as part of the same resource, and making the relationship between the two explicit.

A human page and its machine representation can carry the same content without being the same file. What matters is that the relationship is declared: this is the same logical document, this is its canonical human address, this is its machine address, and this is how the two correspond.

When those relationships are left implicit, every downstream system has to decide for itself. When they are declared, the publisher decides.

What a machine should not have to guess

We use the phrase machine publishing contract for the minimum set of declarations that lets a machine identify and use a public resource without reconstructing the publisher’s intent. In practice, it covers six questions.

Identity. Which logical document is this, independent of the address it was retrieved from, the language it is in and the file it arrived as?

Discovery. Where does the machine representation live? A machine should be able to find it through a declared entry point rather than by trying variations on a URL and hoping.

Provenance. What does the publisher say about how the content was produced and who stands behind it?

Processing scope. What does the publisher intend a machine to do with it: cite, summarise, index, relay, use for training? A public address means a resource can be reached. It does not, by itself, express the conditions the publisher attaches to its use.

Parity. How does the machine representation relate to what a person sees? If it contains material that no human reader will see, that should be declared. Otherwise machine-only content can acquire authority that nobody checked.

Freshness. Is this still the version the publisher stands behind? Has the source changed since the representation was generated? Is it current, superseded or historical?

Each of these can be answered by a publisher in a few declared fields. Left unanswered, each becomes a guess made separately by every system that reads the page.

Clean text is not enough

A common first step towards AI-readiness is to serve clean text, often Markdown, alongside the HTML. It is a useful step. It reduces noise and parsing cost.

It does not answer any of the six questions above. A clean file still does not say which document it represents, whether it matches the human page, whether it is current or what the publisher intends. It makes extraction easier. It does not make the publishing boundary explicit.

The contract around the text is what turns a readable file into reliable infrastructure.

A declaration is a receipt, never a verdict

This is the most important boundary in our work on machine-readable publishing, and the easiest one to lose.

A provenance field records how the publisher describes the origin of a document. It does not prove authorship. A hash shows whether content changed. It does not show that the content is true. A signature shows that a particular key signed a particular file. It does not show that the claims inside are correct. A processing preference states intent. It cannot force a remote system to comply. A validation check can confirm that a file is well formed, current and consistent with the human page. It cannot certify accuracy, neutrality or legal correctness.

A declaration is a receipt, never a verdict. Machine-readable does not mean true.

This matters because the systems that consume public information increasingly act on it. A system that cannot tell a publisher’s declaration from an independently verified fact will pass that confusion on to everyone who relies on its answers. Good machine publishing gives such systems what they need to judge: precise declarations, clearly labelled, with the limits of each signal visible. It does not replace their judgement, and it should not try to.

The same holds for the institutions themselves. An organisation that publishes machine-readable declarations needs people able to judge what those declarations commit it to, and what they do not.

Open by design, not a new gatekeeper

An institution is not AI-ready if its machine interface depends on one model vendor understanding a private convention, or on one service provider checking its files.

The contract has to be open and usable independently of any particular consumer. That is why our approach to standards follows a fixed pattern: identify the missing piece, publish an open specification, build a reference implementation, run it on our own infrastructure, and make the result inspectable.

It also shapes how we think about validation. Independent checks are valuable: whether a file is well formed, whether it matches the human page, whether it is still current, whether a citation resolves. But a publisher must be able to publish a valid machine representation without asking anyone for permission, and a reader must be able to use it without calling any central service. Validation should produce a record of what was checked, not authority over the source.

We are not working alone in this space. robots.txt has long expressed crawling preferences. The llms.txt proposal offers a lightweight entry point for language models. TDMRep provides a protocol for expressing the text and data mining reservation that European copyright law allows rights holders to make by machine-readable means. RSL offers a way to publish licensing terms for AI use. Work at the IETF on AI preferences aims at a common vocabulary for usage preferences. C2PA defines content credentials for the provenance of media. Each addresses part of the problem.

Our work sits at two levels. Its scope is a machine publishing contract: identity, representation, publisher declarations and discovery, with processing scope as one part of it. Its contribution is the part the others leave least defined: the declared relationship between a human page and its machine representation.

A machine publishing standard should not create a new gatekeeper in the name of removing an old dependency.

Machine-readable must not become a back door

A representation designed for machines can also be used against them.

Structured metadata can carry instructions. Machine-only sections can contain text that no person ever sees. A publisher acting in bad faith can try to steer a consuming system through the very interface meant to make it more reliable.

We therefore treat anything a publisher says to a machine as intent, not command. A consuming system should be able to read a publisher’s instruction while keeping its own security rules and its operator’s priorities above it. Parity declarations exist partly for this reason: content that only machines can see should be visible as such.

Machine-readable publication must not become a prompt-injection privilege.

What we have built

Machine Page Format (MPF) is our implemented expression of this position.

A page publishes an MPF companion alongside its HTML. The companion carries structured declarations and a clean body: identity, language and translations, provenance, a fingerprint of the source, parity with the human page, processing scope, freshness signals and a pointer to the specification it follows. A site publishes a machine-readable index so that companions can be discovered without guessing.

MPF is published as an open specification with a reference implementation. We publish MPF on our own web estate, including this site, and use its output ourselves. The specification, publishing conventions and the register of inspectable implementations are documented under Machine Page Format (MPF).

MPF began with static pages deliberately. Static output can be inspected, cached, archived and served by simple infrastructure without a proprietary client. It is not the answer for every kind of resource. Datasets, live services and media raise different questions, and a new resource class should get its own contract when its meaning genuinely differs, rather than stretching one format until it becomes vague.

How we work on it together

Our work on AI-readiness with a partner begins with its publishing, not with any particular AI system.

Read the site as a machine does. Identify where identity, currency, translations and authority are implicit, and where machines are likely to guess.

Decide what the institution wants to declare. Which documents are authoritative, which are drafts or historical, what processing it intends to allow, and who stands behind the declarations.

Publish the contract. Using open formats, generated as part of the normal publishing process so that the machine representation cannot drift silently from the human page.

Leave the ability to judge. The institution should end with people who understand what its declarations commit it to, and who can assess the next tool, standard or vendor proposal on its own.

When we look at a publishing estate together with a partner, these are the questions we typically work through:

Question	What it reveals
Which documents must machines never get wrong?	Where precision matters most.
How would a machine know which version is current?	Whether freshness is declared or guessed.
How are translations related to the original?	Whether equivalence is explicit.
Who stands behind each declaration?	Provenance and accountability.
What processing does the institution intend to allow?	Whether scope is stated or left to interpretation.
Can the machine version drift from the human page unnoticed?	Where silent divergence can occur.
What depends on a single vendor or service?	Whether the interface itself is open.

Where we are careful

We hold ourselves to a few commitments about what we claim.

We do not present AI-readiness as AI safety. It does not measure how robust a model is, whether an AI system is lawful, or whether its answers are correct.

We do not claim that metadata enforces anything. A declared preference states intent; it does not bind a remote system or replace the law.

We do not treat a declaration as proof. Provenance, confidence and scope fields are what a publisher says, and we label them that way.

We do not claim capabilities for MPF that its implementation does not have. The specification describes what the reference implementation actually produces, and nothing more.

And we do not ask machines to trust us automatically. Our aim is narrower: to make the publishing boundary explicit enough that a machine does not have to invent it.

Changes to this position

24 September 2026 — First published.

Material changes are listed here with their date. Corrections of wording or links are not.