TL;DR

  • MCP, llms.txt and AREC are often lumped together as "AI standards". They solve three different problems and none of them substitutes for the others.
  • MCP is a transport: how an agent calls a tool. llms.txt is a site map for models: what a domain contains. AREC is a document format: what one artifact means.
  • A format is the thing that survives the transport changing. An MCP server that returns unstructured blobs has moved the problem, not solved it.
  • The test for whether something is a format rather than an output convention: can a third party implement it from the specification, and check their implementation without asking you?
  • AREC 1.3 passes it: alongside the specification it ships a JSON schema, an MIT-licensed validator, conformance fixtures and a public repository for filing defects.

Three things that get confused

If you build anything agent-facing you have been asked some version of: "you support MCP, so why do you also need a format?" It is a fair question, and the answer explains why the last two years produced so many integrations that work once and then quietly rot.

Put the three side by side.

MCP answers how does an agent reach my tool. It standardises the connection, the handshake, tool discovery, the shape of a call and the shape of a response. Before MCP, every integration invented its own. It is genuinely a big deal, and it is a transport concern.

llms.txt answers what does this domain contain and which URL should a model read. It is a curated map at a well-known location, in the tradition of robots.txt and sitemap.xml. It is about discovery.

A document format such as AREC answers a third question that neither of the others touches: when the agent gets the thing, what does it mean? Which fields exist, what they are allowed to contain, what a consumer must do with them, and what the producer is promising.

These compose. You can discover a resource through llms.txt, fetch it over MCP, and have it be an AREC document. They are not competing.

Why the transport is not enough

Here is the failure mode, and it is extremely common right now.

A team builds an MCP server. It exposes get_recording. The tool returns a large text blob: some summary, some transcript, a few URLs, arranged however the implementation happened to arrange them that week. It works. The agent calls it and usually does something reasonable.

Then one of these happens. Someone changes the blob layout and every prompt tuned against the old shape degrades silently, because nothing declared what the shape was. Another team wants to produce compatible output and has nothing to implement against except reading your responses and guessing. A user wants the same data without MCP, over plain HTTP, and now there are two subtly different representations. Nobody can tell whether a document is missing a section because it was not captured or because the producer omitted it.

That last one is the important one, and no transport can fix it. If an agent receives a recording document with no console errors listed, does that mean there were none, or that diagnostics were not captured? Those imply opposite conclusions. A transport delivers the bytes either way. Only a format can require that the difference be stated.

This is why we treat "make the recording readable" as a format problem rather than an integration problem. The integration surface changes. Ours has already changed: a skill, a CLI, MCP over stdio, MCP over HTTP, plain URL fetch. The document has to mean the same thing across all five, or the meaning lives in five places and drifts in four.

The test for whether you have a format

Here is the test, and it is uncomfortable if you have been calling something open:

Can a third party implement this from the specification, and verify their implementation, without asking you a question?

Not "is it documented". Not "is the output human-readable". Not "is the licence permissive". Can someone who has never spoken to you produce a conformant document and know that it is conformant.

By that test, most "open formats" announced with a blog post are output conventions. They describe what one tool currently emits. That is fine, but it is not a format, and calling it one sets an expectation that the first outside implementer discovers is false.

AREC is built to pass it. Version 1.3 has a published specification, a licence and producers across Clipy's recorders, and it gives an implementer things to run: a JSON schema to code against, a validator to check output, fixtures to test a reader against, and a public repository at github.com/arecformat/arec, home of arecformat.org, where anyone can file a defect against the format itself.

That is what makes a format open in a checkable sense: anyone can implement it and confirm conformance without asking the authors.

What makes it checkable

Four artifacts, none of them large, in rough order of how much they matter.

A validator. The single highest-leverage thing. It has no dependencies and no build step, so anybody can run it against a document in one command. A specification tells you what the rules are; a validator tells you whether you followed them. Until one exists, "conformant" is an opinion.

Conformance fixtures in both directions. Documents that must pass, and documents that must fail, one violation per file. The negative fixtures are the ones that do the work. It is easy to write a reader that accepts valid input. The interesting question is whether it rejects a document whose pointer coordinates are outside the unit interval, or whose diagnostics carry a cookie.

A machine-readable schema. AREC is Markdown, so a schema covers the structured parts: the identity header, the key-moments array, the diagnostics array. It deliberately covers only those parts, because the format is Markdown rather than JSON.

A changelog. Boring and load-bearing. A format with no visible history reads as abandoned the moment a version number moves, and an implementer has no way to tell whether a rule they read last month still holds.

The rules a schema cannot express

Writing the validator turned out to be the part that taught us the most, because the rules that matter least to a parser matter most to an agent.

A JSON Schema can say a coordinate is between 0 and 1. It cannot say missing capture must be stated. But that rule is the one preventing an agent from concluding that no click happened when the truth is that click telemetry was unavailable. So the validator checks for a completeness statement directly, and a document that stays silent about a gap fails.

Same with the untrusted-evidence notice. A recording can contain anything that was on screen, including text shaped like an instruction. Every conformant document must mark recording-derived content as evidence rather than direction. That is unexpressible as a data constraint and non-negotiable as a rule, so it is checked.

And the one that matters most for portability: evidence references must point at precomputed artifacts. The rule is that a consumer must never have to ask a server to extract a frame on demand, because a format whose documents are only useful while the origin server is healthy and willing is not really a document format.

Relative paths inside a portable bundle are precomputed, so they pass; a URL with a timestamp query parameter is an extraction endpoint wearing a URL costume, so it fails. Clipy's published benchmark bundle uses relative paths for exactly that reason.

The validator runs against Clipy's real production output as well as the fixtures, and that habit is worth copying: validate your own production artifacts, not only your fixtures, because fixtures written by a spec author encode that author's assumptions.

Forward compatibility is a conformance rule

One design decision worth arguing for, because it is counterintuitive.

AREC requires consumers to ignore sections they do not recognise and keep reading. That means the validator must not fail on unknown content, which feels like a validator that is not doing its job.

It is the opposite. The format is stable and will still gain sections. If a v1.3 reader rejects a v1.4 document, every producer is frozen until every consumer upgrades, and that is how a format dies before its second version. HTML and HTTP both made this choice. A consumer that refuses unknown content is the thing breaking compatibility, not the producer that emitted it.

The corollary is that an unfamiliar spec_version is a warning, not an error. The document says what rules it was written against; read the parts you understand.

What this means if you are building something agent-facing

Not everything needs a format. If your integration returns a number, return the number. Formats earn their weight when an artifact is complex, when evidence and absence of evidence both matter, and when more than one surface has to deliver the same meaning.

If you are in that situation, this is the ordering we recommend:

  1. Write the specification, and test it before you announce it.
  2. Write the validator before the marketing page. It will find rules you stated ambiguously.
  3. Run it against your real output as well as your fixtures. Real output surfaces assumptions that fixtures miss.
  4. Publish negative fixtures, so an implementer can prove their reader rejects the right things.
  5. Then say the word "open", and mean something checkable by it.

The specification for AREC, including the schema, the validator and the conformance suite, is at clipy.online/spec, with version history at the changelog. If a rule in it is ambiguous, that is a defect in the specification rather than a question for support.

Clipy is the agent-readable screen recorder: one link gives a person a video player and an agent a structured document. The format is open and checkable.