From the field #08 - AX: the agent experience your site is missing

Part 1: your site has a UX, not an AX

Look at your site the way you always have. A human lands, the layout guides the eye, the copy does its job, a button gets clicked. Someone spent real effort making that experience good. That is UX, and it is twenty years of refined practice.

Now land on the same site as an agent.

Not a crawler indexing text. An agent: a system acting on someone’s behalf that needs to know what your site can do, what it can ask of it, and how to connect. It reads the markup and finds a layout built for eyes. No statement of what this site is. No list of what it can answer. No endpoint it can call. It came to act and found a brochure.

That second experience has a name now. Agent Experience, AX, and right now your site almost certainly has none.

Two standards crystallized while everyone watched the chatbots

The interesting shift in 2026 was not a smarter chatbot. It was two plumbing standards quietly hardening underneath the agents, both aimed at the same question: how does an autonomous system find out what something can do and then use it.

The first is MCP, the Model Context Protocol. It is the agent-to-tool standard - how a model connects to a data source or a capability and calls it in a structured way. Anthropic put it out, and through 2025 and into 2026 it stopped being one vendor’s idea and became the default way agents reach tools. The portfolio you are reading already speaks it.

The second is A2A, Agent2Agent. It is the agent-to-agent standard - how one agent discovers another, learns what it is for, and hands it work. It started at Google and moved under the Linux Foundation, which is what happens to a protocol when the industry decides it is infrastructure rather than a product. A2A’s unit of identity is the Agent Card: a small public manifest that says, in machine terms, “I am this agent, here is what I do, here is how you reach me.”

MCP for agent to tool. A2A for agent to agent. Anthropic, OpenAI, Google, the Linux Foundation, all pushing the same direction. These are not speculative. They are shipping specs with version numbers, and they describe a web where the thing arriving at your door is increasingly not a person.

AX is the question UX has not been asked yet

Here is the framing that made this worth an episode. For twenty years the only question that mattered about a site was the human one. Is it fast, is it clear, can a person accomplish what they came for. UX.

The agentic web adds a second question that most sites have never been asked. Can an agent see what you can do. Can it discover your capabilities without scraping a page meant for eyes. Can it connect to the thing you offer and use it. Is there a manifest that tells an agent what you are, or does it have to guess from your homepage.

That is AX, Agent Experience, and the gap between a site’s UX and its AX is, for almost everyone, total. The UX is polished. The AX does not exist. There is no agent card, no discovery manifest, no machine-readable statement of capability. An agent that arrives has the same experience a human would have with the stylesheet stripped out and the text scrambled: technically something is there, practically nothing it can use.

Give it six to twelve months. The way a site gets judged is going to widen. Not only “is this good for a person” but “can an agent do anything with this.” The sites that answer yes will be the ones an agent can find, describe, and act on. The sites that answer no will be invisible in exactly the channel that is growing fastest, and as with everything in this space the failure will be silent. Nothing breaks. An agent simply cannot see you, and you get no signal that it tried.

Invisible to an agent is not the same as broken

Be precise about what missing AX looks like, because it does not look like an outage.

Your site is up. A human uses it fine. But an agent that wants to know what you offer has nowhere to look. There is no agent card at /.well-known/agent-card.json telling it who this agent is and what skills it has. There is no MCP discovery manifest pointing it at a callable endpoint. There is no discovery layer at all, so the agent does what agents do with an opaque site: it guesses from scraped HTML, or it picks a target it can actually read, or it does nothing and moves on.

Every one of those outcomes routes around you. And none of them shows up in your analytics as a problem, because from the human side there is no problem. The site works. It just does not exist for the readers that now arrive without eyes.

Why I went and built it

I build deterministic pipelines for AI-driven QA, and the spine of all of it is one idea: context before the model. You do not drop an agent into ambiguity and hope. You give it clean, explicit, structured context, and then it does the part it is good at. AX is that same principle pointed at my own brand. If the agentic web is going to read my portals, the honest move is to hand the agent exact context about what each one is and what it can do, instead of making it reverse-engineer that from a page built for people.

So I treated the brand the way I treat a pipeline. Not one site - the whole fleet. Six brand portals, each a separate deploy, each needing the same agent-discovery layer: a custom Agent Card, an MCP discovery manifest, capabilities an agent can actually read. The portfolio you are on is one of them. So is the docs site for my testing pattern. So is a private knowledge base that needed a more careful answer than the others.

Arming all six took about seventy minutes of Claude Code time, and at the end every one returned a green probe. Six portals, full agent-discovery layer, seventy minutes. That number is real - it came off a sprint, not a slide - and it is the spine of Part 2.

Part 2 is the build. The exact manifests, what they declare and what they deliberately do not, the one pattern that let a single source file serve two languages without drift, and the portal that got a different answer on purpose because its API is not meant to be public.

From the Field is what I actually build, what breaks, and what I learn. Real projects, real numbers, real bugs. No tutorials.