---
altdown: 1
canonical: https://www.vivekchopra.com/posts/altdown
title: Introducing Altdown
published: 2026-10-31T00:00:00Z
updated: 2026-11-04T00:00:00Z
lang: en
author: Vivek Chopra
description: Altdown lets publishers declare a verifiable Markdown copy of each page for AI agents: one link element, one static file, no intermediary.
generator: vivekchopra.com-gen
---
# Introducing Altdown

Altdown lets any site, on any host, publish what agents read, in a form they can check against the page, carrying the site's own terms, with no intermediary speaking for it.

## Key takeaways

- Altdown lets a publisher decide what agents read from each page, with a Markdown copy that any agent can check against the page.
- Its principle is that agents see what people see: a copy says only what the page says, and no converter, proxy or wrapper can stand in for it.
- Usage stays where crawlers already look. robots.txt, Content Signals and licenses apply to a copy exactly as they apply to its page.

*Updated November 4, 2026: the draft no longer has usage signals of its own, adds rules for hosts and CDNs and a digest for every copy, and has a companion draft for services. The [changelog](https://altdown.org/changes/) lists every change.*

An agent reading a web page gets the same HTML a person does: the nav bar, the cookie banner, the related-posts rail, the analytics scripts. It pays for all of it in tokens and then runs a heuristic to decide which part was the article. Sometimes the heuristic keeps the footer and drops the code sample. The publisher knows exactly which part is the article and has no way to say so.

[Altdown](https://altdown.org/) (short for *Alternate Markdown*) gives the publisher that say. A site publishes a Markdown copy of each page's main content as a static file next to the page, and the page announces it with one line in its `<head>`, like this one from [altdown.org/example/](https://altdown.org/example/):

```html
<link rel="alternate" type="text/markdown" href="/example/index.md">
```

The [specification](https://altdown.org/spec/) is short, and there is a [Markdown version](https://altdown.org/spec/index.md) to hand to an agent. The rest of this post explains why it exists when other ways to get Markdown out of a page already do.

## Publisher control

Altdown saves agents tokens, but that is a side effect. Publishers decide two things about their content: what they expose, and how it is represented. The first already has standards. `robots.txt`, [Content Signals](https://contentsignals.org/), robots meta tags and licenses say who may fetch a page and how its content may be used, and a publisher can set them without touching a CMS. The second has none, and that is the job Altdown takes on.

Today an agent's extraction heuristic, or a CDN converting the page in transit, decides what a page says to an agent. With Altdown the publisher decides. The copy is a file the publisher produces, usually from the page's own source, so it can be reviewed, diffed, and versioned with the page, and when it is wrong the publisher fixes a file instead of filing a bug against someone else's converter.

That control only matters if agents can trust it, so the spec makes the copy checkable. It may contain only text a person can see on the page, the page and the copy point at each other, and any failed check falls back to the HTML. The rules are below. None of this needs new infrastructure: a folder of static files and one `<link>` element works on GitHub Pages or an S3 bucket. Nor is it a separate version of the page for bots, the objection usually raised against serving Markdown to agents. A faithful copy is the page in another form, which is exactly what lets an agent check it.

Altdown has no usage rules of its own. A copy is the page in another form, so the page's rules apply to it, and a CDN that enforces them against badly behaved bots enforces them on the copy too.

## Extraction and publication

There are two ways to get a Markdown version of a page. Someone can derive it from the HTML, or the publisher can write it.

Cloudflare's [Markdown for Agents](https://developers.cloudflare.com/fundamentals/reference/markdown-for-agents/), launched in February 2026, is the best version of the first approach. An agent sends `Accept: text/markdown`, and Cloudflare's edge converts the page on the fly. The publisher does nothing beyond turning it on. If your site is on Cloudflare and the output looks right for your pages, it is a reasonable choice.

Conversion is still extraction, though. A better converter guesses better, but it is guessing, and a publisher who disagrees with the result has nothing to edit. With Altdown, the publisher writes the file the agent reads.

The spec now says what a host should do when a page has a copy. A host or CDN that answers a request for Markdown must return the publisher's copy, unchanged, rather than its own conversion. CDNs keep their role enforcing access and usage; they just do not get to decide what the page says.

They are not exclusive. The spec tells agents to send `Accept: text/markdown`, and any host that can route on that header (Vercel rewrites, Cloudflare rules, Apache `mod_rewrite`) can return the publisher's copy instead of a conversion. An agent asking for Markdown does not need to know which approach produced the answer.

## llms.txt points to the same file

In August 2026, [llms.txt v2](https://llmstxt.org/changes) added page-level discovery using the same element shown above: `rel="alternate" type="text/markdown"` from a page to its Markdown version. So Altdown's discovery mechanism is not new, and it does not need to be. Two proposals settling on one `<link>` element is how a convention forms, and an agent that follows it works with both. The same `.md` files and the same link element can serve both proposals.

Discovery is not the hard part anyway. llms.txt is on roughly 8 to 10% of the top 10,000 sites ([Rankability](https://www.rankability.com/data/llms-txt-adoption/)), and server logs show AI crawlers rarely fetch it: one study across 83 sites counted 7 fetches of llms.txt by OpenAI's crawlers against 3,990 of robots.txt ([EZY](https://www.ezy.ai/research/do-ai-bots-read-llms-txt)). A file that nothing checks is easy to ignore.

What llms.txt v2 leaves open is what the file at the other end of the link may contain, and how an agent decides whether to believe it. That is most of the Altdown spec.

**The copy may contain only text a person can see on the page.** No added summaries, keywords, or instructions to software. Nothing hidden with `display: none` or white-on-white text. Nothing left out of the main content. Even the optional `description` field must match the page's own meta description, so it says nothing the page does not.

**Text that qualifies the content stays with it.** A disclaimer, a risk warning or a sponsorship label is part of the main content, even when the page sets it in small print. A copy of a financial page without its risk disclaimer says something the page does not.

**The page and the copy must point at each other.** The page links to the copy, the copy's `canonical` field names the page, and both are on the same origin. A third party cannot publish a copy for a page it does not control, and a stale copy the page no longer links to is ignored.

**The spot check.** Pick five pages at random, reduce the HTML and the copy to visible text, split the copy into five-word sequences, and count how many appear on the page. Below 0.90 the copy is rejected. If more than one sampled copy fails, the agent reads the whole site as HTML. A publisher cannot know which pages will be sampled, so cloaking a few pages is a bad bet.

**Copies are data.** Agents must never treat text in a copy as instructions, however it is phrased.

**Every failure falls back to HTML.** A site that adopts Altdown badly loses nothing it had before.

A site can also publish an index of every copy as a JSON Feed 1.1 document, announced with an `Altdown:` line in `robots.txt`. An agent reading a whole site syncs it the way a feed reader syncs a feed: it reads newest first and stops at the first date it has already seen. Each entry carries a SHA-256 digest of its copy, so an agent can tell when a cache or proxy changed it, and a removed page stays listed as a tombstone so agents know to forget it. This is the part of Altdown that resembles RSS. The copy itself is closer to reader mode, except that the publisher writes it.

## What the check does not prove

A passing spot check means the copy is verifiable against the page, not that it is correct. The check tests containment, whether the copy's text appears on the page, which is a much easier problem than deciding what the main content is. Five-word overlap catches padded copies, cloaked copies, and copies that have drifted badly out of date. It will not catch a dropped "not" or a changed number in a copy that otherwise matches. The 0.90 threshold has not been tested against real sites yet.

Altdown is not always cheaper per request. Reading one page means fetching the HTML to find the link, then fetching the copy, unless the host answers `Accept: text/markdown` directly. The savings show up when an agent reads many pages from a site, or reads a whole site from the index and only fetches what changed.

It also will not change how a site ranks in search, and is not meant to.

## Beyond content

Two companion pieces are goals, not finished work.

[Altdown Services](https://altdown.org/services/), a 0.1 draft, applies the same rules to what agents can do on a site. A pricing page links to its quote API, a docs page to the MCP server that searches it, and a service counts as the site's own only if the site links to it or lists it. That gap is already being exploited: in September 2025 a squatted `postmark-mcp` package posed as Postmark's connector and quietly copied users' email to an attacker ([The Hacker News](https://thehackernews.com/2025/09/first-malicious-mcp-server-found.html)). Services also adds a parity rule: a service must offer an agent the same price, availability and terms that the page shows a person, and an agent can spot-check it.

An access profile, to be written with the groups behind RSL and Web Bot Auth, would say how the existing standards for identity, terms and payment work together: which an agent checks first, which wins when they disagree, and how an agent's identity links to its license. It would add no vocabulary of its own.

## Design choices

Altdown optimizes for making the existing web work well for *both* humans and agents, instead of a parallel web built for machines. That only happens if publishers can get there without rebuilding their sites or routing content through someone else's pipeline. Hence, Altdown reuses what already exists (`<link>` autodiscovery, `robots.txt`, JSON Feed, CommonMark) and adds the smallest set of rules that makes the result checkable. This website's generator writes each copy straight from the post's Markdown source, the approach the spec recommends. Sites without a generator can extract copies from their finished HTML instead.

The scope is deliberately narrow. Altdown covers what a site says to agents: its pages now, its services next. Access and usage stay with `robots.txt`, Content Signals and licenses, and proposals like WebMCP cover how agents act on a page. Summaries and structured facts belong in other formats. The faithful-copy rule only works if the copy is nothing more than the page.

## What is missing

Altdown solves the publisher's side of the problem. But a standard is only useful if someone consumes it. For Altdown to succeed, agents must know how to discover, request, and validate Altdown content. That requires three things that do not exist yet.

The first is an agent-side library that implements the spec's reading procedure: find the link, fetch the copy, check the round trip, run the spot check, and fall back to HTML. The second is a measured comparison of raw HTML, edge-converted Markdown, and Altdown copies on real pages, covering token counts, missing content, and errors. Until that comparison exists, the claims about cost and accuracy in this post are reasoned, not measured. The third is uptake upstream: the content rules proposed to llms.txt, and the precedence and identity rules to RSL and the Web Bot Auth group. If those groups adopt them, the rules will matter more than the name.

## Status and feedback

Altdown Content is version 1.0 in draft, published under CC BY-SA 4.0, and it will be marked final once its rules are tested on real sites. Besides the threshold, the rule for metered articles (copy only what an anonymous visitor sees) has not been tried with a real publisher. Once 1.0 is final, the format will be frozen the way RSS 2.0 was, with new ideas going into extensions. Altdown Services is a 0.1 draft, and the access profile is a proposal.

[altdown.org](https://altdown.org/) publishes every page in the format it describes, and the [For agents](https://altdown.org/agents/) page shows the head, the copy, the `robots.txt` line, and the index for the spec itself, with `curl` commands to check them.

I would like to hear from publishers who try it on a real site, from people building agents that read the web, from anyone working on llms.txt, and from the RSL and Web Bot Auth groups about the access profile. [Open an issue](https://github.com/agentwebcommons/altdown/issues) with your feedback or comments.