Google has published a format for converting a body of information into a folder of linked markup files. It is designed for internal company data, and incidentally, solves a problem with public websites. Right now, the most an AI agent can find on your website is a scan of your pages, one at a time. This format creates a graph of how your ideas connect instead, so I tried it on my website.
Google’s Open Knowledge Format is a Directory of Linked Markdown Files
On June 13, 2026, Google’s data team published the Open Knowledge Format, or OKF, a way to represent a body of knowledge as a directory of markup files with a thin layer of YAML frontmatter. Each concept, table, metric, runbook, API, gets its own markup document. A short YAML block holds the query fields, type, title, description, resource, tags, and timestamp; the body of the markdown carries the meaning, and the concepts connect to each other through standard hyperlinks, which Google says turns the directory into a “relationship graph.” No runtime, no SDK, no build step. Google defines bundle in three phrases: “just put down,” “just files,” “only YAML frontmatter.”
The target is the company’s internal knowledge, content that Google says is “locked behind any site it has created,” and it’s still early, v0.1, which Google calls “a starting point, not a finished standard.” Nothing in the announcement mentions public websites. That gap is what this piece is about.
On a website, an Information Graph Beats Flat Page Copy
The agent-readable version of your website, which is the model or browser it uses, is low. Providing each page as a bookmark, the way Cloudflare does it at the edge of the network, is close to AMP for LLMs: a second, stripped copy of every page for machine reading. It shows what you already have, page by page, and it drops the same thing every copy of the page and page drops, which is how the pages relate to each other.
A knowledge graph stores that layer of relationships. When your concepts connect to each other, the agent not only learns what each one is, but also learns how they live in relation to each other, which is the essence of understanding a website. Two pages can both mean the same thing and never tell the machine that one is a frame below it and the other is a small goal next to it. The graph is direct, in the links the machine follows. OKF is an off-the-shelf way to build that graph: lay down, so it’s cheap, and structured, so it carries relationships.
I tried OKF on the No Hacks website
I wrote a bunch of OKFs for the No Hacks website, one tagging file for each product name, host, Machine-First Architecture, agent web, Agent Experience Design, Response Engine Optimization, llms.txt, and WebMCP. Each one follows Google’s conventions, YAML fields at the top and an empty footer theme at the bottom. The work was more about deciding which concepts were important and how they connected, not writing files.
One file, the concept of Machine-First Architecture, looks like this:
---
type: framework
title: Machine-First Architecture
description: A framework for building websites whose full meaning is available to a machine reading them, with the human experience layered on top rather than the other way around.
resource:
tags: [Framework, Machine-First Architecture, Agentic Web]
timestamp: 2026-06-13
--- Machine-First Architecture is [Sani](./sani.md)'s framework for the [agentic web](./agentic-web.md). The core idea: build the content so a machine reading it gets the complete meaning, the facts, the structure, the relationships, and the human reading gets that same meaning with the design on top. This is why formats that strip a website to plain text, like markdown for agents and [llms.txt](./llms-txt.md), matter. Its capability side is [WebMCP](./webmcp.md), and its measurement side is [Agent Experience Optimization](./agent-experience-optimization.md).
Those links in brackets below are graphs. The agent following them discovers that WebMCP sits under Machine-First Architecture, and llms.txt is the same type of bet, a flat copy of my pages that never mentions it. In all eight files, that’s the whole structure: the concepts, and the relationships between them.
A bundle like this is a second copy of what the website says, and the second copy is the second thing to keep in sync. When a website changes, the batch is not correct until you update it as well. That tax isn’t just an OKF thing: it’s what all the corresponding machine-readable layers, the llms.txt file, the mirror for your page layouts, a bunch like this. The version the agent reads is only as accurate as your instruction to keep it up-to-date.
Google didn’t create an OKF for this. Its purpose is internal company information, and there is nothing in its system that points to public websites, so hosting a large number of visiting agents is not an option, and may remain so. The reader I created for him, the agent that downloads the batch and follows the graph, may not appear again. The reason for doing it should stand apart from that benefit, and it does: writing a bunch forced me to clearly state what No Hacks knows and how their ideas are connected, and those gaps that appeared I wouldn’t have found writing another page. It’s the same discipline as Machine-First Architecture, put your definition in a machine-readable format, and figure out where you were unclear.
Where the Website Information Graph Can Lead
None of the following is a prediction. It’s a guide, and it depends on the agents reading the website’s information graphs, which today, doesn’t exist. The shape is still worth seeing.
An identity file can grow into a graph of information. Today, llms.txt is a single line that declares who you are. A published bundle is a full version of that idea, a map of everything your website knows and how the components connect, so that the thin layer of identity and the structured information framework become one.
Agents can query that map instead of scraping your pages. An agent that pulls your stack and follows its links gets a cleaner, more relational read than one that analyzes your HTML page at a time, and learns more about how your concepts are represented when the AI interprets them.
The map may be a canonical layer. The machine-readable version ceases to be a copy of your website and becomes the source, with human pages as one of its offerings. That’s the first website the agent’s web machine pointed to, accessed through a side door opened by Google for internal data.
Markdown is not new
John Gruber created Markdown in 2004, with Aaron Swartz as his beta tester, and the whole design goal was readability: text that you can read as it is, without rendering it, that still converts cleanly to HTML. Two decades later, it uses GitHub, Reddit, most of the documentation you’ve read, and chat boxes for AI tools themselves. It won for readability without subtraction, which is the property that makes the machine readable.
I’ve been writing most of my writing for 15 years, since iA Writer became my primary writing app in September 2011, so the week that the web readable agent meets markdown is familiar ground to me, not a new trick. Information No Hacks (No Hacks OS project) has worked in the same way for months: markdown files with a structured frontmatter, linked to each other, a shape that can be read and cut by a machine.
Machine-friendly formats always live there, llms.txt, Cloudflare’s markdown, and now OKF. Google itself is not single minded about it. Its Search side is called llms.txt “just a guess” for ranking, its Chrome side has added an llms.txt check to Lighthouse agent readiness checks, and its data team has now published OKF.
If you want to see where your website ranks, it takes thirty seconds. Open your most important page and paste it into a plain text editor, where the links collapse into simple words. Look at the rest and find anything that says how its ideas relate to your entire website, not that one page links to another, but the relationship itself. Usually there is nothing, and that absence is what the infograph fills in, whether you’ve touched OKF or not.
OKF is this week’s news, and its subtext, machine-readable plain text, has been here since 2004. What Google added was a standard and a name.
Additional resources:
This post was originally published on No Hacks.
Featured image: Roman Samborskii/Shutterstock
