Why Did We Ignore the Web? Rethinking MCP and the Reinvention of HTML
As large language models (LLMs) grow more powerful and start to interact with tools, services, and user interfaces, a new wave of protocols like MCP (Machine Callable Protocol) has emerged. MCP aims to describe APIs and functions that an LLM can discover, reason over, and call — much like how a browser interprets and interacts with web pages. But here's a question that more people should be asking:
Why exactly did we need a new protocol at all?
The Web Was Already Made for Machines
Before the AI boom, the web wasn't just designed for humans. It was, from the start, also a machine-readable platform:
- HTTP is stateless, cacheable, and uniform — perfect for machine-to-machine communication.
- HTML isn't just a display language. It's a semantic structure with headings, sections, forms, inputs, and links — all designed to convey meaning, not just appearance.
- Forms and links are universal interaction mechanisms, able to describe everything from search queries to file uploads to data submission.
- Standards like microdata, RDFa, and ARIA provide structured metadata.
- Protocols like JSON-LD, HAL, and Hydra attempted to push hypermedia APIs even further, making interactions self-discoverable and semantically rich.
If you're thinking, "Wait — all of this sounds like what MCP is trying to do," you're not wrong.
So Why Reinvent the Wheel?
There are a few reasons, and while some make sense, others are more about expediency than necessity.
1. LLMs Aren’t Browsers
While LLMs can parse HTML and follow links, they don’t render HTML the way browsers do. They don’t run JavaScript (at least not natively), and their interaction model is different:
- LLMs prefer structured JSON input/output.
- They benefit from explicit parameter definitions, types, and constraints.
- Simplicity improves accuracy, predictability, and safety.
HTML is expressive, but it can also be noisy and inconsistent. Many real-world websites break accessibility rules, misuse tags, and offer poor semantic hints. LLMs need clean, parseable, and consistent structures — something JSON-based schemas (like those used in MCP) provide more easily.
2. Developer Convenience and Adoption
One reason HTML-based APIs never took off is developer culture. Despite decades of pushing REST and hypermedia:
- Most APIs today are still RPC-style JSON endpoints.
- Developers often ignore HATEOAS principles in favor of simpler, faster solutions.
- Few people ever embedded proper microdata or ARIA tags, let alone full RDFa.
MCP is built in that spirit: it’s simple, opinionated, and LLM-native. That makes it easier to adopt for the current generation of developers, even if it ignores lessons from the past.
3. Business Strategy and Ecosystem Control
Let’s be honest: new protocols are branding opportunities.
- MCP gives companies a way to create walled gardens, ecosystems, and tooling lock-in.
- JSON schemas can be optimized for LLM performance, logged, metered, and monetized.
- A new protocol makes it easier to create hype: "Look, a whole new way to build AI-native apps!"
This isn't necessarily malicious — but it's a far cry from the open web ideal where any machine can interact with any other using open standards and shared protocols.
But Here’s the Risk: Reinventing HTML, Poorly
We're already seeing this happen.
- Developers want ways to describe how tools should be presented — layout, grouping, ordering.
- Soon they’ll want conditional inputs, nested forms, validation hints, help tooltips, etc.
- We may end up creating a JSON-based rendering language, then bolt on templating, then accessibility, then styling…
Sound familiar?
It’s the path to rebuilding HTML, CSS, and maybe even a subset of JavaScript — but without the decades of hard-earned lessons that the web has already internalized.
Is There a Smarter Path Forward?
There might be.
1. Marrying MCP with HTML Semantics
Why not embed HTML in MCP responses for display? Or use HTML microdata inside LLM-parsable documents? Let HTML handle layout, and MCP handle execution.
2. Encourage AI-Readable HTML Standards
Imagine a curated HTML subset — like LLM-safe HTML — that’s clean, semantic, and designed for machine interpretation. Combine that with JSON overlays and you might get the best of both worlds.
3. Revisit Hypermedia Principles
HATEOAS (Hypermedia As The Engine Of Application State) was hard for humans to adopt. But AI assistants thrive on discoverability. Perhaps LLMs are the agents we were always waiting for — ones that can truly leverage hypermedia links, semantic input types, and linked data.
Finally
We didn’t need to throw the web away.
Yes, HTML isn’t perfect. But it’s battle-tested, extensible, and built for interoperability. Ignoring it entirely in the rush to build MCP and similar formats may be short-sighted.
Rather than building another fragile stack that slowly regains HTML’s strengths through trial and error, we should be asking:
What does the web already give us, and how can we extend it for AI — not replace it?
Comments ()