The Web Is Getting a Second Interface, and It Isn’t for Humans

The first generation of agents uses the web like we do

Give a modern AI agent access to a browser and it can already do surprisingly normal things.

It can search.

Read pages.

Compare products.

Fill forms.

Navigate dashboards.

Book things.

Operate software.

Sometimes it even manages to accept a cookie banner without spending ten minutes wondering which shade of grey means "reject all", putting it ahead of a meaningful percentage of humanity.

But look at what is actually happening underneath.

The agent is often interacting with a website that was designed for a pair of human eyes and a mouse.

It receives HTML.

It examines the DOM or an accessibility tree.

It tries to understand what the elements mean.

It finds something that looks like a button.

It concludes that this button probably performs the action it wants.

Then it clicks it.

That is technically impressive.

Architecturally, it is slightly ridiculous.

We are making increasingly sophisticated software pretend to be a person using a graphical interface because that is the interface we happened to build.

Imagine having a perfectly good database API and deciding that the most reliable way to query it is to photograph the admin panel and have another computer visually identify the Search button.

It works.

That doesn't make it sensible.

A website knows more than it tells the agent

Take a simple appointment form.

A human sees:

Choose service. Choose date. Choose time. Enter contact details. Book appointment.

The application underneath already understands much more.

It knows which services exist.

It knows which dates are valid.

It knows which appointments are available.

It knows what information is required.

It knows what happens when the booking is submitted.

But an AI agent looking at the page may have to reconstruct all of that from the interface.

That is where the architecture is beginning to change.

Instead of forcing the agent to infer:

"I think this element probably books an appointment."

the website could explicitly declare:

"I provide a book_appointment capability. These are the required inputs. These are the allowed values. This is the result."

That sounds like a small technical improvement.

It isn't.

It changes the website from something software can look at into something software can understand and operate.

WebMCP is an unusually clear example

In May 2026, Chrome documented WebMCP, a proposed web standard for exposing structured tools from websites to AI agents.

The idea is refreshingly practical.

Instead of making an agent inspect a page and guess what a form or button does, a website can expose explicit tools representing those actions.

Chrome describes examples such as checkout, filter_results, submit_application and other structured operations. Tool inputs and outputs can be defined using JSON Schema, giving an agent a much clearer contract than whatever it manages to infer from the visual interface. (developer.chrome.com)

WebMCP is still experimental. It is not some finished universal web standard that everyone should install by Friday afternoon. Chrome currently offers an origin trial beginning with Chrome 149, and the proposal remains under active discussion. (developer.chrome.com)

That distinction matters.

Technology reporting has a bad habit of turning "some engineers proposed something" into "the Internet has changed forever" before lunch.

But WebMCP matters even if its exact implementation changes, because it demonstrates the architectural direction very clearly.

A website can have a graphical interface for the human while simultaneously exposing structured capabilities to the human's agent.

Same application.

Two ways of interacting with it.

This idea is appearing in more than one place

When one company invents terminology, I mostly watch.

When unrelated infrastructure companies, browser teams, standards communities and protocol developers start solving different parts of the same problem, I pay considerably more attention.

That is what is happening now.

The W3C has an AI Agent Protocol Community Group working on open mechanisms for agent discovery, identity, capability descriptions, communication and security across the web. (w3.org)

Another W3C Community Group launched in March 2026 specifically because raw HTML and DOM representations are inefficient ways for AI agents to consume web content. It is exploring a structured representation designed for machine consumption while retaining meaning and interactivity. (w3.org)

An Agent-to-Web Framework Community Group is investigating something slightly different but equally important: machine-readable rules controlling what agents are allowed to do on websites. Crawling is one problem. Allowing autonomous software to fill forms, submit orders and perform authenticated actions is another. (w3.org)

Then, on August 13, 2026, another W3C Community Group appeared around what it calls an Introduction Layer.

Its premise is almost embarrassingly obvious once somebody states it:

A web resource currently has no universal machine-native way to tell an arriving agent what it is, who operates it, what it allows, what its constraints are and whether the agent has correctly understood its purpose. (lists.w3.org)

These are W3C Community Groups, not W3C Recommendations. They are exploratory work, not commandments handed down from Mount HTTP.

Still, look at the problems they are independently trying to solve:

What am I?

What can I do?

How do you interact with me?

What are you allowed to do?

Who are you?

Who are you acting for?

Those are not chatbot problems.

Those are infrastructure problems.

HTML is not going away

There is an easy mistake to make here.

If agents prefer structured data, perhaps websites become APIs and the visual web disappears.

I don't think so.

Humans still want to browse.

We want typography, photographs, brand, storytelling, comparison, exploration and context.

Sometimes we don't know exactly what we want until we see it.

That is one reason graphical interfaces exist.

The machine does not necessarily need all of that.

And this is where ordinary HTTP suddenly becomes interesting again.

Cloudflare launched Markdown for Agents in February 2026. Websites using the feature can respond differently when a client sends:

Accept: text/markdown

Instead of returning the complete HTML representation of a page, Cloudflare can produce a structured Markdown version intended for AI consumption. (blog.cloudflare.com)

This isn't a new Internet protocol.

It uses an old and very normal web idea: content negotiation.

The client tells the server what representation it prefers.

Human browser:

Give me the normal website.

Agent:

Give me the same information in a cleaner machine-readable representation.

That is elegant because it doesn't require building two separate websites.

There is still one source of truth.

The representation changes according to who, or increasingly what, is requesting it.

Readable is only the beginning

Cloudflare recently described its view of an "Agentic Internet" using four useful words:

Readable. Discoverable. Callable. Payable. (blog.cloudflare.com)

I think that is a useful framework, even if we ignore the branding around it.

Readable

Can an agent efficiently understand your information?

Not just scrape text, but understand products, prices, documentation, policies, availability and relationships between things.

Discoverable

Can an agent find out what services and capabilities you provide?

Today we expect users to find pages.

Tomorrow their software may need to discover functions.

Callable

Can the agent actually do something?

Search inventory.

Request a quote.

Book an appointment.

Configure a product.

Create a support request.

Buy.

Payable

Can an agent complete an economic transaction under authority given to it by a person or organization?

That final step introduces an entire collection of problems involving identity, permission, fraud, limits, receipts and accountability.

And people are already working on those too.

The protocol layer is forming underneath this

The Model Context Protocol, or MCP, started as a convenient way of connecting AI systems with tools and data.

It is becoming considerably more infrastructural.

The July 28, 2026 MCP specification changed the core protocol toward stateless request-response operation, making remote MCP servers easier to scale using normal HTTP infrastructure. (blog.modelcontextprotocol.io)

Its roadmap, updated only days ago on August 22, now explicitly prioritizes HTTP-native transport, agentic messaging and agent identity, including situations in which an agent operates as a cloud workload or acts for a user who is not currently present. (blog.modelcontextprotocol.io)

Agent2Agent, or A2A, tackles communication between agents rather than simply connecting an agent to a tool. It originated at Google and now operates as a Linux Foundation project. By April 2026, the project reported support from more than 150 organizations and production use across several industries. (linuxfoundation.org)

Commerce is developing its own layer as well.

Google's Universal Commerce Protocol is designed to expose commerce capabilities across consumer surfaces, businesses and payment providers while working with APIs, MCP and A2A. (developers.googleblog.com)

The Agent Payments Protocol addresses the uncomfortable but necessary question of how an agent proves that a human actually authorized it to perform a transaction. (cloud.google.com)

None of this proves which protocols will win.

Some will merge.

Some will disappear.

Some will become the Betamax of autonomous software and be fondly remembered by seventeen people on Hacker News.

The important thing is that the problems being standardized are real.

The important shift is from navigation to intent

The traditional web is organized around navigation.

A person wants shoes.

They search.

Open a website.

Select Men.

Select Shoes.

Select size.

Filter by price.

Open several products.

Compare them.

Add one to the cart.

Enter shipping information.

Choose payment.

Confirm.

The user's real intent was never:

"Please allow me the privilege of navigating eleven interface states."

The intent was:

"Find me waterproof walking shoes in size 44 under €150 and buy the best suitable pair, but ask me before paying."

Until recently, computers were terrible at handling an instruction like that.

So we decomposed human intent into screens, buttons, menus and forms.

Agents potentially reverse that relationship.

The human provides the intent.

Software negotiates the interfaces required to accomplish it.

That means the unit of the web starts moving from page toward capability.

Not everywhere.

Not immediately.

But enough that anyone building web systems should notice.

This changes what a website actually is

For a long time, I've mentally separated a web project into roughly three things:

content,

business logic,

interface.

Most visitors only see the last one.

AI agents make the separation much more important.

Consider a WooCommerce store.

To a person, it is:

product pages, filters, cart, checkout, account.

But underneath, the business really exposes capabilities:

find products,

compare attributes,

check stock,

calculate shipping,

apply discounts,

create an order,

take payment,

retrieve order status.

The HTML interface is only one representation of those capabilities.

An agentic interface could become another.

That is why I don't think the agentic web means "put AI on your website."

That is almost backwards.

The larger change is making the website itself understandable and operable by AI.

Search may change with it

There is another consequence.

The web business model has spent decades assuming that discovery eventually produces traffic.

Google discovers your content.

Google shows your link.

The person clicks.

Your analytics sees a visit.

Your business gets an opportunity to sell, advertise or at least establish its brand.

Agents can interrupt that chain.

An agent might discover ten providers, query their capabilities, compare prices, check availability and recommend one without visually visiting any of their homepages.

The business may still win the customer.

But it may win without receiving anything resembling a traditional session.

That means our current obsession with pageviews will become increasingly incomplete.

SEO will not vanish.

But machine discoverability begins sitting beside human search visibility.

I suspect we will eventually spend much more time discussing whether a business is represented correctly inside agent decision systems, not merely whether its homepage ranks number three for a keyword.

That deserves its own article.

Security gets much harder

There is one reason I would not rush into exposing every website operation as an AI-callable tool tomorrow morning.

Agents do things.

And software that does things needs authority.

Reading a public article is one level of risk.

Changing an address is another.

Cancelling a subscription is another.

Sending a message, deleting information, purchasing something or transferring money is another entirely.

Once agents become active participants on the web we need reliable answers to questions browsers could previously avoid:

Who is this agent?

Who owns it?

Who authorized it?

What exactly was it authorized to do?

For how long?

Can the permission be revoked?

Who is responsible when it performs the wrong action?

NIST clearly considers these real infrastructure questions. In February 2026 it launched an AI Agent Standards Initiative focused specifically on secure interoperability, identity and authorization for agents operating on behalf of users. (nist.gov)

So no, I would not give an AI agent an admin password and congratulate myself on achieving digital transformation.

There is engineering left to do.

Quite a lot of it.

What I would actually do today

This is the part I care about most.

The agentic web is real enough to prepare for.

It is not mature enough to rebuild your business around every new protocol.

So if I were designing or rebuilding a website today, I would concentrate on fundamentals that are useful regardless of which standards survive.

Keep content semantically clean

Correct HTML structure, meaningful headings, useful metadata and structured data already help search engines, accessibility tools and AI systems.

Bad information architecture does not become good because somebody added an LLM.

Separate business logic from presentation

If an important operation can only be performed by reproducing seventeen JavaScript clicks in exactly the right order, that architecture will age badly.

Important business capabilities should have clean internal boundaries.

APIs where they make sense.

Clear inputs.

Clear outputs.

Predictable errors.

Make important information machine-readable

Products.

Prices.

Organizations.

People.

Events.

Locations.

Policies.

Availability.

Documentation.

Structured data is no longer only an SEO checkbox.

It increasingly becomes part of the interface between your organization and machines representing other people.

Experiment, but label experiments as experiments

I would absolutely test things such as Markdown representations, MCP integrations and WebMCP.

I would not promise a client that one experimental proposal is now "the new standard."

There is an important difference between being early and being gullible.

Start thinking about agent permissions now

Any system exposing actions should understand which actions are harmless, which require authentication and which require explicit human confirmation.

That design question will survive regardless of which protocol eventually carries the request.

We are not replacing the web

I don't think the web is turning into one giant invisible API.

I think something more subtle is happening.

The web was built around documents.

Then applications grew on top of those documents.

Now we are adding another participant.

Software that can read, reason, decide and act.

For that participant, our beautiful responsive interface is often packaging.

It needs meaning.

Capabilities.

Permissions.

Identity.

And increasingly, a way to transact.

So I wouldn't describe the agentic web as the next version of the website.

I'd describe it as a second interface to the Internet we already built.

The first interface lets humans operate software.

The second will increasingly let software operate software for humans.

And if that continues, web development is about to become a considerably larger discipline than designing what appears inside the browser.

Next in the series: Stop Making AI Click Buttons: Why Websites Are Becoming Callable