Google shipped two specs in as many weeks, and suddenly your Slack feed is full of alerts like "Markdown is the new HTML!" and "LLMs.txt will replace your sitemap." kabir_joshi wants you to pause. Because no, your content team doesn’t need to scramble for a markdown compiler yet, and yes — the foundation still lives in well-structured HTML.
The real story is quieter, more layered, and far less disruptive than it sounds. What’s emerging isn’t one replacement protocol, but a parallel machine-readable infrastructure — think of it as an add-on deck bolted onto the existing web frame, not a new house altogether. OKF and ARD, along with LLMs.txt and MCP, each serve a distinct layer: discovery, navigation, tooling, and knowledge sharing. Miss the distinction, and you risk over-engineering your site just as Google’s own engineers are warning against. Miss the pattern, and you’ll miss the real signal hiding in plain sight: structured data 2.0.
So what are OKF and ARD, really? How do they compare to the specs we’ve already been testing? And why should SEOs care if they’re not yet ranking signals? Let’s unpack it without the hype.
The Agentic Stack Isn’t a Replace Button
Here’s the thing everyone skips over when they say "the web is getting a third layer": the new specs don’t replace what’s there; they stack. And stacking implies layers that play nicely — not competing file formats or confusing redirects.
The original web was built on HTML. That’s still the bedrock. It tells crawlers where to go, humans how to read, and search engines what things are. Without semantic HTML — proper headings, internal links, landmarks — nothing else matters. So before you draft a markdown spec for your product page, go check Google’s John Mueller on Search Off the Record: he’s clear. Crawlers rely on HTML structure to navigate your site. Strip that out, and you’ve just broken discovery for everyone.
Schema.org came next — a vocabulary layer on top of your HTML. Think microdata, JSON-LD, structured data in headers. It gave engines explicit hints: this is a product, that is an event, over there is a person named Alice. For years, schema’s role shifted — from ranking boost to verification hint. Google scaled back some rich results when the signals got gamed, and today it’s less about a direct bump and more about helping engines understand your intent.
Now, the agentic layer adds two more steps: navigation and coordination. LLMs.txt is essentially a site map for agents — it doesn’t change your content; it tells an AI which pages matter most once it’s already on your domain. Think of it like highlights in a book — useful, but not the text itself.
Then there’s MCP (and its browser cousin WebMCP), which standardizes how agents talk to your services. Before MCP, every agent integration was custom plumbing — one-off connections between tool A and endpoint B. Now there’s a shared interface, so an agent that knows MCP can slot into your system without building a special bridge each time.
OKF and ARD complete the picture. But they’re not yet another format for your homepage. They serve completely different needs — one for internal knowledge sharing, the other for real-time tool discovery.
OKF: Not a Public SEO Tactic (Yet)
Open Knowledge Format hit the scene quietly, wrapped in Google’s Dataplex rebrand. It looks simple — a folder of markdown files, each with a tiny YAML header for type, title, description, resource links, and tags. Link them like you would any doc, and you’ve got an OKF bundle.
Google calls it "just markdown." That’s technically true, but the why matters more than the what.
OKF was built for data teams — internally. Think runbooks, metric definitions, table schemas: knowledge that lives inside an organization and needs to move between AI agents seamlessly. It’s not a public-facing SEO format. And that’s okay.
The confusion arises when people assume OKF replaces crawling or ranking signals. It doesn’t. It’s an additive layer: a higher-signal input in retrieval pipelines, yes — but only if the rest of your stack is solid. You still need HTML pages, proper internal links, and content that loads for humans.
There’s another point worth stressing: OKF isn’t a knowledge graph. Not even close. A real KG has typed, queryable relations — explicit edges between entities. OKF just ships Markdown files with links. An LLM still has to infer semantics every single time it reads a file. So if you’re banking on OKF to power your semantic search, you’ve swapped parsing complexity for inference risk.
For SEOs, OKF is best viewed through the lens of structured data. Early adoption can give you clearer signals and reduce parsing cost for agents, but over time, engines will learn to infer meaning directly from your HTML. So don’t rush to convert your blog posts — test OKF in developer docs, internal wikis, or product metadata areas where precision matters more than broad discoverability.
ARD: The Coordination Layer You Didn’t Know You Needed
While OKF focuses on packaging what you know, ARD — Agentic Resource Discovery — answers the question: how do agents find what they can do?
Here’s the problem ARD solves: right now, if an autonomous agent wants to book a flight, check inventory, or run a report, it needs to be pre-wired to every tool and API it uses. That works fine for one or two services. It collapses the moment you have hundreds of endpoints, each with its own auth, schema, and error handling.
ARD moves discovery from setup time to runtime. Instead of hard-coding tool connections, the agent queries a catalog (think ai-catalog.json on your domain) when it needs something new. That catalog lists available capabilities — MCP servers, A2A agents, OpenAPI endpoints — and the domain ownership acts as cryptographic proof of identity. The agent fetches the catalog, verifies it, and plugs in without your help.
Google launched ARD just days after OKF. They’re clearly part of the same design sprint — one spec for packaging knowledge, the other for advertising capabilities. Already, companies like Hugging Face are experimenting with ARD’s Discover Tool to surface integrations at runtime.
The really interesting bit is the metadata: ARD catalogs include version, permissions, and other checks before an agent commits to calling a tool. That trust layer is what makes autonomous workflows safer and faster.
What does this mean for SEO? Not much, at first. ARD is about tool discovery, not content ranking. But the implications are real: as agents get better at navigating APIs and toolchains, they’ll demand richer endpoints — including content-rich ones. So while ARD itself won’t move your rankings, it will raise the bar for what “useful endpoint” means in an agent’s world.
The Gap That Matters: Media Types and Trust
There’s a tiny but telling gap in the OKF/ARD rollout — no agreed media type for an OKF bundle.
Why does that matter? Because a catalog can list a bundle, but without a standardized type (like application/json), an agent can’t reliably recognize it as OKF until it sniffs the contents. In practice, publishers are already shipping interim types — which means different systems will disagree on whether a file is OKF, ARD metadata, or plain text.
Google could’ve stalled until IANA approved a formal media type. Instead, they shipped fast and patched later — a familiar pattern. Even JSON didn’t get an official type until years after it became widely used.
But OKF is different. A malformed JSON parser might just skip an object; a misidentified OKF bundle could let an agent act on untrusted data in an ARD-driven workflow. So while delaying adoption for full agreement would stall progress, leaving this gap too long introduces trust risk.
In practice, expect catalogs to label bundles with custom types for a few months while the ecosystem settles on an agreed convention. For SEOs and content teams, this means: watch for consistency in how catalogs identify knowledge files before treating them as primary sources.
What SEOs Should Actually Do Right Now
Here’s the honest list:
- Keep HTML as your primary format. Don’t chase markdown ports for public pages.
- Focus on schema that matches your content type (product, article, FAQ). Think of it as the first signal layer.
- Consider LLMs.txt only if your site already ranks and you want to help agents navigate internal depth. It won’t move the needle on discovery.
- Test MCP for tool-rich pages — especially if your team builds APIs or custom functionality. That’s where interoperability wins fast.
- Treat OKF as internal or dev-facing: documentation, runbooks, metric definitions. Keep it behind authentication if possible.
- Ignore ARD for now — unless your site functions as a platform. It’s more relevant to infrastructure engineers than content creators.
The pattern we should watch is the same one structured data followed: early adoption gives clearer signals, then engines learn to infer meaning directly from HTML. OKF and ARD are just the latest iteration of that cycle.
If you’re optimizing for humans — clean hierarchy, semantic HTML, clear calls to action — the agents will follow. The ones that don’t are building shadow sites for machines, doubling your maintenance and creating a debugging nightmare nobody wants.
So breathe. Your content still matters. You’re just adding rooms to the house, not tearing it down.