Documentation Is the Contract Surface
For most of software's history, docs were the manual. Now they're the contract surface humans and agents both ground on.
Encyclopedia Britannica stopped printing in 2010.
It survived as a subscription, smaller. The audience for English-language ground truth had been moving to Wikipedia and search for fifteen years; eventually the substrate underneath the company was no longer the substrate the world was using. The function survived: humans still ground factual claims on something. But the form changed, and the model didn’t follow.
Documentation is going through its own version of that shift now.
For most of software’s history, documentation has been a side artifact. A manual the buyer read once, a reference the engineer searched when something broke, a marketing surface the company maintained to look serious. Sometimes good, sometimes neglected, never load-bearing. The product was the product; the docs were the manual.
That has reversed.
Your documentation is the contract surface. Humans land there to decide whether your project is worth their time. Agents ground their next API call on whatever it says, with no opinion about whether it looks trustworthy. Retrieval systems index it silently and answer questions you never see asked. It is the public face of your business the way the API is the public face of your code, except now two different species read it, both assume the contract holds, and each one breaks in its own way when it doesn’t.
The shift is uneven. Most projects do not yet have agent traffic surpassing human traffic. But every project that ships something an agent might use, an API, a CLI, a programmable surface, is already serving a load-bearing autonomous reader. The platform they pay rent on every month was designed before that reader existed.
What changed
Three things changed in the last two years.
Stripe-tier became the baseline for human-readable documentation. Mintlify built a $10M ARR business on that single insight, and the floor for what counts as serious developer documentation went up and has not come back down. Anything that looks worse now signals an unserious project before the reader has clicked past the hero.
The cost of clearing that baseline went up too. GitBook deprecated its open-source CLI and raised prices two to four times. Mintlify Pro is $300 a month. ReadMe starts at $99. The bar to ship beautiful documentation is no longer technical; it is whether you are willing to pay rent on a static directory.
And the audience changed. The same platforms that perfected the hero animation ship llms.txt as a hand-edited afterthought or not at all. The structured index that agents actually read is shipped second-class because the business is built around selling the human-evaluator marketing surface, not the autonomous reader. The pressure to add the agent surface will not override the pressure to keep producing the marketing one, because the buyer paying $300 a month is not the agent.
The three pressures are no coincidence; they are what happens when an industry optimises hard for one audience while another audience walks in the door.
What the field shipped
Every visible platform solves part of the problem and leaves the rest paid-for or impossible.
Mintlify is beautiful, multi-source, and rented. The docs live on Mintlify’s domain, in Mintlify’s MDX dialect, behind Mintlify’s billing. There is no static export that takes Mintlify out of the chain without losing the components Mintlify renders. The contract surface lives on someone else’s terms.
Docusaurus is open source and owned. It also looks like it shipped at the same conference Mintlify’s founders raised their seed round, and then stopped evolving. Default Docusaurus reads as Meta-built because Meta built it, for projects that have spare React engineers to make it stop reading that way.
Doxygen is the inverse of Mintlify. Ugly, owned, and the only tool here that actually parses C++. The C++ ecosystem has spent twenty years concluding there is no escape from Doxygen’s output, which is wrong; “Don’t Replace Doxygen” unpacks the move they have been missing.
pkg.go.dev is excellent at what it does. What it does is be Go’s package index, not your project’s documentation site. Your project’s URL on pkg.go.dev is Go’s URL with your import path stapled to the end. “pkg.go.dev Isn’t Your Docs Site” makes the case for the owned alternative.
Swagger UI is owned, format-specific, and visually frozen in the year SmartBear took it over. The .NET 9 team dropped Swashbuckle as a default dependency in 2024, which is the closest the industry has come to a public admission that the renderer has aged out of relevance. “Stop Renting Your OpenAPI Docs” makes the broader case.
ReadMe, GitBook, and Redocly sell variants of the Mintlify trade. Different price points, same structural choice: rent the contract surface that humans and agents both ground on, in exchange for the convenience of not building it yourself.
The engineers shipping these products are not the problem. The business model is. A subscription priced for human-evaluator marketing surfaces does not produce the structured agent-readable artefacts the next reader needs, because the buyer paying $300 a month is not the agent and never will be. Britannica had the same shape of problem before it stopped printing: the subscribers paid for prestige and reference value while the people who actually used the content had moved to a different substrate entirely. The model could not follow the audience without giving up the model.
What fits
The answer is not a fifth platform built around the human evaluator and a sixth one built around the agent. It is a single renderer that reads every source the project already has, ships static HTML, and produces both surfaces from one build.
Start with ownership. Static HTML, deployable anywhere, no vendor between the project and the surface humans and agents both depend on. When the tool’s company goes away, the docs stay where they were and keep working.
Beauty is the part open source kept conceding by default. Docusaurus looking like Docusaurus was never a law of nature; it was the consequence of nobody bothering, and Mintlify’s $10M ARR is the price tag on how much the bothering turned out to be worth. The bar belongs to the field now, not to a vendor’s pricing page.
One build has to read everything: Doxygen XML, Go packages, OpenAPI specs, MCP schemas, and hand-written Markdown, all from the same repo. The famous four-tool C++ chain (Doxygen, Breathe, Exhale, Sphinx) only exists because docs platforms refused to read native formats. Strip out the refusal and the multi-source build is just the normal case.
Both readers then come off the same source. The human site and the agent surfaces (llms.txt, llms-full.txt, a JSON search index, a sitemap, a stable anchor per symbol) fall out of one render pass instead of arriving later as a separate, upsold product line. The agent gets its schema from the build that drew the hero.
Nothing that ships that list is a documentation platform. It is a renderer.
What we built
Sourcey is the renderer.
Open source. Reads every format. Ships static HTML. Free to run yourself; the hosted tier is convenience built on top of a tool that costs nothing to run.
Icey is a C++ networking library: WebRTC, signalling, TURN, and media encoding in one stack. Its Doxyfile has nothing in it most C++ projects do not already have. Its docs at 0state.com/icey/docs ship from the XML that Doxyfile produces. The modern part is the renderer, not the parser; the deeper argument is at “Don’t Replace Doxygen”.
Scafld is a Go protocol for multi-phase agent work. Its docs at 0state.com/scafld/docs ship from native Go package comments, with llms.txt written from the same build. No Markdown mirror on disk, no second source of truth. “pkg.go.dev Isn’t Your Docs Site” makes the argument.
Cheesestore is the OpenAPI showcase. A clean API-first project rendered from a single YAML spec, same renderer, no platform between the OpenAPI and the site. “Stop Renting Your OpenAPI Docs” makes the argument.
Three projects, three source formats, one renderer. The same build produces the human-facing pages and the agent-readable surfaces in every case.
What comes next
Britannica still exists as a subscription product. It is smaller, and the function it served, being the public substrate for English-language ground truth, moved elsewhere a decade ago. The model could not follow the audience.
The same shift is happening to documentation now, faster, and with two audiences instead of one. None of the 2026 pressures are temporary: agents are not a phase, the rented platforms are not about to roll prices back to 2018, and the bar for human-readable docs only moves one direction. This is the baseline now, not a spike to wait out.
Whoever owns the contract surface in 2026 owns the relationship that runs across it. The rented platforms charge monthly for the most load-bearing artefact in your product, and the model that sets that price is aimed at the one reader who is never going to pay it.
Documentation belongs to the project.