HTML Is the Format AI Agents Want

On May 8, 2026, Thariq Shihipar, an engineer working on Claude Code at Anthropic, published a personal site collecting 20 HTML artifacts an agent produced across nine categories of knowledge work, with one argument: when the answer carries spatial structure, interaction, or visual evidence, HTML beats Markdown.¹²

HTML beats Markdown for agent output because spatial structure, interaction, and visual evidence carry information that prose flattens. The format the agent emits is the control surface the human inspects, not a wrapper around it.

The post landed six days before a May 14 arXiv paper showed agent search quality lives in the runtime, not the retriever.³ The same pattern appears: format and runtime are the substrate, not the wrapper. The component matters only after the surface around it turns model output into something a person can verify.

TL;DR

Thariq Shihipar shipped a companion site with 20 HTML examples spanning code review, design systems, prototyping, exploration, diagrams, research, reports, and editor surfaces.¹ The thesis: Markdown linearizes information that arrives spatially. Diffs, call graphs, side-by-side comparisons, and interactive prototypes carry meaning that prose flattens. The 8K-token GPT-4 launch era pushed Markdown as a token-efficient default; current Claude context-window documentation lists 200K-token and 1M-token models, changing the trade for many artifact sizes.⁴⁵ For server-rendered, no-build web stacks like FastAPI plus HTMX, the post supplies the agent-side argument: HTML is the format the model wants to produce and the format the browser already renders. Routing through Markdown adds a translation step that drops fidelity at both ends.⁶

Key Takeaways

For agent builders: - Stop defaulting to Markdown for agent output when the answer is a comparison, diff, flow chart, or navigable structure. Request HTML and let the agent commit to spatial layout.¹ - Treat the model’s output format as part of the tool surface. A single rendered artifact is more inspectable than a transcript that scrolls past.⁷

For interface designers: - HTML is the medium your design system already ships in. Routing through Markdown introduces a translation step that loses fidelity, then a second translation step on render.¹ - The control surface is whatever the agent produces. If the human cannot see what the agent saw, the surface is broken.⁷

For teams running server-rendered no-build stacks: - The bet on HTML over a build pipeline now has the agent-side validation. The format the model wants to produce and the format the browser already renders are the same.⁶ - A server-rendered site removes a translation layer twice: once at the build step, once at the agent-output step. Both removals compound.

What Thariq Actually Argued

Shihipar works on Claude Code at Anthropic; the post is on his personal site, not Anthropic’s official blog.² The companion gallery contains 20 self-contained HTML files an agent produced, grouped into nine categories of work where HTML structurally beats Markdown.¹

His core claims:

The second claim is the load-bearing one for anyone building web infrastructure. If the design system ships HTML, the agent should produce HTML. Anything else introduces a lossy round trip.

The 20 Examples Are the Argument

The categories on Shihipar’s gallery cover the work most people now hand to a coding agent:¹

• Code review: annotated diffs with severity-coded inline notes; module maps with highlighted call paths.
• Exploration: side-by-side code approaches; visual design options laid out for selection rather than read sequentially.
• Design: living design system pages; component variant sheets that render the variants.
• Prototyping: animation sandboxes with real easing curves; interactive flows that respond to clicks.
• Diagrams: inline SVG figures; annotated flow charts; box-and-arrow architecture sketches.
• Research: collapsible sections; interactive concept explainers with live demonstrations.
• Reports: formatted timelines and charts where the structure carries the meaning.
• Editors: custom interfaces with export functionality embedded in the artifact.

Each one is an HTML page the model produced in one shot. The shared pattern: the answer is spatial or interactive, and the rendered artifact preserves what a Markdown response would have to describe in prose.

Why The Default Was Markdown

Markdown won the agent-output default for two reasons that no longer apply.

First, the GPT-3.5 and GPT-4 generation hit context windows in the 4K to 8K range during the period when the chat-output convention solidified.⁴ Markdown’s terseness was a real forcing function: a token spent on <div class="..."> was a token unavailable for analysis. Claude’s current context-window docs list 200K-token contexts for many models and 1M-token contexts for Opus 4.1 and Sonnet 4.6.⁵ The token-efficiency argument has decayed for many inspection artifacts.

Second, terminal renderers and chat windows render Markdown trivially, while HTML requires a webview or a browser tab. The surface convenience kept Markdown as the path of least resistance even after the token argument died.

Shihipar’s post carries weight because the author works on Claude Code at Anthropic. The 20 examples are concrete artifacts, not abstract claims.² Simon Willison’s coverage on the same day reproduced the pattern with a Linux security exploit explainer rendered as an interactive HTML page rather than a Markdown writeup.⁸

What HTML Preserves That Markdown Drops

Four properties carry the argument:

Each property maps to a class of agent task that gets harder when you flatten the output to prose. A diff is a spatial comparison; a flow chart is a graph; a design system review is a visual judgment. Forcing those through Markdown asks the reader to reconstruct what the renderer could have shown.

The Runtime Connection

Agent search quality lives in the runtime, not the retriever. That post argued the retrieval method matters less than the harness around it: prompt shape, tool surface, transcript formatting, result delivery, retry behavior.³

The HTML argument extends the same frame to output. The model can produce the right answer in any format. The format you ask for is part of the runtime contract. Different formats produce different verifiable surfaces:

• Markdown delivery: the user reads top to bottom, decides what matters, and reconstructs structure mentally.
• HTML delivery: the model commits to a structure, the renderer makes that structure scannable, and the user inspects rather than reads.

Same data, different control surface. Agentic design is control surface design. The format the agent emits is part of that surface, not packaging around it.⁷

What This Means for the No-Build Stack

The FastAPI plus HTMX guide on this site makes the case for server-rendered HTML over a JavaScript build pipeline.⁶ Shihipar’s post supplies the agent-side argument:

• The model wants to produce HTML.
• The browser wants to render HTML.
• Inserting Markdown or JSX between them adds two lossy translation steps.

A no-build server-rendered site removes the build-time translation. Producing HTML directly from the agent removes the output-time translation. The compounding payoff: the same format runs from the model through the route through the browser without intermediate forms.

The point does not claim React or Markdown are wrong everywhere. The point says the cost of the translation steps is now visible from both ends, and a stack that avoids both ends gets simpler in proportion.

Format Matters. Runtime Matters. Both Are the Substrate.

The agent-search paper and the HTML post arrived eight days apart and argue the same shape:¹³

• The retriever is a component. The runtime is the substrate.
• The model is a component. The output format is the substrate.

Component thinking keeps offering local upgrades: switch the retriever, add memory, swap the model, refine the prompt. Substrate thinking changes the surface that the user sees and the surface that the agent produces. Both this week’s findings push the work toward the second frame.

The practical move: when an agent answer carries spatial information, ask for HTML. When the agent runs in a harness, instrument the harness before instrumenting the model. Both moves compound. Neither is a silver bullet on its own.

FAQ

Did Anthropic publish this post?

No. Thariq Shihipar published it on his personal site, thariqs.github.io/html-effectiveness/.¹ He works on Claude Code at Anthropic, so the authority signal is strong, but the post is not an Anthropic publication.²

Does the argument apply to every agent task?

No. The post explicitly targets work where spatial structure, interaction, or visual evidence carry meaning. For short factual answers or terminal-bound output, Markdown remains a fine default.¹

What about token cost?

The cost case for Markdown was tied to small context windows. Claude’s current context-window docs list 200K-token and 1M-token models, which changes the HTML verbosity trade for the artifact sizes the post showcases.⁵

Does this break Claude Code’s existing Markdown defaults?

No. The argument is about output you ask the model to produce on demand for inspection, not about the transcript or terminal output. You can still ask for HTML in a single prompt and get a self-contained artifact back.¹

How does this connect to the agent-search runtime paper?

Both arguments point at the substrate around the model rather than the model itself. Search quality depends on the harness; output quality depends on the format. The component is necessary; the substrate is what makes the component dependable.³

What should a FastAPI plus HTMX team do with this?

Treat HTML as a first-class output target for any AI feature you ship. The same format runs from the model through the route through the browser, and the no-build stack already optimizes for that path.⁶

References