The unreasonable effectiveness of HTML

Every artifact an AI employee produces in Winsen One is an HTML page. The credit memo is HTML. The reconciliation summary is HTML. The audit finding with its page-level citations, the quality deviation report, the freight bill dispute file: all HTML, rendered in an auth-wrapped sandbox, exportable to PDF, PowerPoint, or Excel when someone needs to carry it somewhere else. Not markdown. Not a proprietary document object. This looks like a small implementation choice. It is one of the most load-bearing decisions in the product, and this post is the argument for it.

The title is borrowed twice over. Eugene Wigner used the phrase in 1960 for his essay on the unreasonable effectiveness of mathematics in the natural sciences, and this May, Thariq Shihipar of Anthropic's Claude Code team used it for an essay arguing that AI agents should produce HTML instead of markdown, which landed hard enough that half the industry now has an opinion. We agree with him, and our reasons are more specific than taste. When your artifacts are memos that a named person signs, the format is a governance decision.

First, what an artifact is

A definition before the argument. In Winsen One, everything an AI employee produces is an artifact. A credit review memo is an artifact. A monthly portfolio pack is an artifact. A reconciliation break report, a supplier scorecard, the dashboard a manager opens on Monday morning: artifacts, all of them. Each one renders as an HTML page inside an access-controlled viewer, where opening it requires login and every view is logged. Each one exports to PDF or slides when it has to travel. And each one is source-inspectable, because the page is its own source code. The reviewer who signs it can read exactly what they are signing.

So this essay is not arguing about a rendering detail. Artifact generation is the product. An AI employee's entire output surface is the artifacts it submits for approval, which means the format those artifacts take decides what can be governed, exported, inspected, and retained. Every argument below about durability, structure, export, and trust is really an argument about that one decision.

Here is one, live. A portfolio review dashboard of the kind Vera, a credit file review employee, closes each month with. It is a single HTML file. Scroll it, open it full screen, view source.

Thirty-five years of not breaking

HTML came out of CERN in 1991 as an informal document describing roughly eighteen tags. The first website, info.cern.ch, is still online in restored form, and it renders in any modern browser without a converter, a plugin, or an apology. A page built in 1995 displays today essentially the way it did in Netscape. The people who maintain the HTML Living Standard treat backward compatibility as a hard constraint: changes must not break the existing web. No other document format has that record. Word processor formats churned through generations. PDF needs a reader. Every proprietary document object ever attached to a SaaS product died with the product.

Durability matters more in our industries than in most. Financial services, manufacturing, and logistics all carry retention obligations measured in years. A credit decision file may need to be produced, and readable, seven years after the employee that drafted it was decommissioned. An HTML artifact makes that promise cheaply. It is a text file. It is self-describing. The only runtime it needs is a browser, which is to say the one piece of software that exists on every machine your auditor, your regulator, and your successor will ever touch. Zero installs, zero licenses, zero vendor left to call.

What markdown cannot carry

Markdown is a fine format for what it was designed for. John Gruber released it in 2004 as a shorthand for people writing prose for the web, and for prose it is still the right tool. But it is deliberately minimal, and the minimalism is lossy. Pandoc, the standard converter between document formats, says plainly in its manual that conversions from formats more expressive than markdown can be expected to lose information. Tables are the sharpest example: standard markdown tables have no merged cells, no nested tables, and no lists or code blocks inside a cell. The moment a document needs real structure, markdown's answer is to escape into raw HTML. At that point you are writing HTML with extra steps and none of the guarantees.

Our artifacts need real structure, every day. An audit memo carries a findings table where a category header spans four columns. Every number in it carries a provenance link back to the exact page of the source document it came from, which means anchors, stable element ids, and links that survive export. The layout separates the finding from the evidence from the recommendation, because a reviewer reads those three things differently. A print stylesheet controls what a regulator holds in their hands. Markdown can carry almost none of this. HTML carries all of it natively, in the format's own vocabulary, with nothing bolted on.

One render pipeline, three outputs

The counterintuitive part is export. HTML is how you get to PDF and PowerPoint, not what you give up to have them. Print output from HTML is a solved, standardized problem: the CSS Paged Media spec defines page boxes, margins, running headers, and page numbers, and mature engines implement it. WeasyPrint honors the paged media spec and renders HTML straight to print-ready PDF. Paged.js does the same job in the browser. Chromium's own print pipeline, driven by tools like Puppeteer, turns any page the browser can show into a PDF. Entire book publishing toolchains run on this stack today.

Slides are the same story one step over. PowerPoint's file format is OOXML, which is zipped XML, and open libraries like PptxGenJS build decks programmatically, including turning HTML tables directly into auto-paginated slides. So one artifact, one source of truth, feeds three surfaces: the sandbox on screen, the PDF for the regulator, the deck for the Monday meeting. The alternative is three generators producing three near-copies of the same content, and near-copies drift. When the number in the deck has to match the number in the memo because both were signed, drift is not a cosmetic bug. It is a finding.

The format the models grew up on

There is also a plainer reason the artifacts come out well: HTML is the format the models have read the most. The pretraining corpora behind modern language models are built overwhelmingly on web crawls. Common Crawl alone is petabytes of HTML, and it is the de facto foundation of essentially every large training set. A model asked to produce correct, deeply nested, semantically sensible HTML is working squarely inside its training distribution, in a way no proprietary document format can match. This was the core of Shihipar's observation, and it matches what we see in production: employees emit valid, well-structured pages with a consistency that would be remarkable in any other rich format. We did not have to teach the workforce the house format. The house format is the one they grew up on.

A page can be governed

Everything an AI employee produces has to live inside an approval loop, and here the choice pays off twice. First, access. Because artifacts are just pages, our auth wrapper is just authentication in front of pages, the most battle-tested pattern on the web. An artifact can require login, log every view, expire, or be revoked. A binary attachment forwarded over email can do none of those things. The moment it leaves, it is gone, and so is your access record.

Second, inspection. An HTML artifact is its own source code. The reviewer who signs a memo can open the source of the thing they are signing and see every citation link, every table cell, every element, with nothing hidden inside a binary blob. Semantic markup keeps the page navigable to screen readers under WCAG, so the approval queue is not quietly closed to a reviewer using assistive technology. And the auditor who opens the archive three years later gets exactly the transparency the approver got on the day it was signed.

A reviewer should be able to read the source of anything they sign. HTML is the only document format where that sentence describes normal behavior.

The honest tradeoffs

The decision has costs, and we will not pretend otherwise. HTML is heavier to diff than markdown. A one-word change in a paragraph is one clean changed line in markdown and can be a tangle of markup in HTML, so review tooling has to render differences instead of just printing them, and we spend real effort keeping generated markup boring, consistent, and diffable. Markdown also remains better at the job it was built for: quick notes, readme files, prose a person edits by hand. We still use it for all of those. The claim is not that markdown is bad. The claim is that it is the wrong container for signed evidence.

The bigger cost is that HTML can execute, which makes it an attack surface, and that is exactly why the sandbox is not optional. A page can carry scripts, event handlers, and javascript URLs, and the industry's answer is layered: sanitize untrusted markup, which is why OWASP points at DOMPurify, a library that parses HTML into a DOM and strips anything unsafe, then lock the page down with a content security policy and render it inside an isolated frame. We treat every artifact as untrusted at render time, even though our own employees wrote it, because a sandbox that trusts its authors is not a sandbox. This is real engineering spend. It buys a format that will outlive every component around it.

Wigner's original essay marveled that mathematics keeps working in places it has no obvious right to. HTML has earned a small version of the same wonder. A markup language sketched at a physics lab in 1991 turns out to be the most durable, most renderable, most inspectable, most exportable document format available in 2026, and the one the models speak most fluently. Our AI employees produce work that people sign their names to. We put that work in the one format where anyone, on any machine, this decade or next, can open it and read exactly what was signed.