Precious OkoroWhy designing how AI communicates, behaves, and earns trust may become content design's most important responsibility.
Introduction
An AI agent is about to move money out of your account. Before it does, it shows you one sentence.
Maybe that sentence tells you what it’s about to do and how sure it is. Maybe it gives you a clean way to stop it. Or maybe it just says “Processing” and hopes you don’t panic.
That sentence is the whole product. Every model call, every API, every pipeline the company built comes down to whether you trust one line of text enough to let the thing act on your behalf. Somebody wrote that line. Usually an engineer, late at night, as the last task before shipping.
That is the part of AI not quite staffed correctly. And it turns out to be a Content design problem.
This article makes one claim. Agent experience has been defined as an engineering problem and is now being framed as an interface problem, but the part that actually determines whether people trust an AI agent is Content design, and that part remains unowned. If you build or write for AI products, that gap is the most valuable real estate in the field right now.
The short version: Agent experience is the discipline of designing how AI agents work. Its human half, what the agent says, asks, and admits, is Content design. Nobody has claimed it yet.
What Is Agent Experience, and Who Coined It?
Agent experience, or AX, is the practice of designing products so AI agents can use them well. The term was coined by Mathias Biilmann, the CEO of Netlify, in January 2025. His definition is clean. AX is “the holistic experience AI agents have as users of a product or platform,” meaning how well an agent can discover what your service does, call it, and recover when something breaks.
The idea sits in a serious lineage. User experience was coined by Don Norman at Apple in the early 1990s. Developer experience followed around 2011. AX is the third name in that line, and it hit us fast.
John Maeda, now vice president of design and AI at Microsoft, put the weight of his annual Design in Tech Report behind it. In the 2025 edition, its eleventh, he called the move from UX to AX “perhaps the most profound shift I’ve observed” in the report’s history.
So the discipline is real, it’s serious, and it’s moving quickly. Here’s where it went wrong.
The Human Was Left Out of the Framework
Look at how AX defines its own scope. Biilmann’s framework breaks it into four areas: Access, Context, Tools, and Orchestration. Can the agent authenticate? Does it understand your product? Are your capabilities machine-readable? Can agents be triggered and passed context?
Every one of those is infrastructure. Every one is a machine talking to a machine.
The person is missing. The human the agent is acting for, the one deciding whether to trust it with money or a calendar or a customer, doesn’t appear anywhere in the four pillars. AX was built from the API up, and it stopped before it reached the sentence you actually read on the screen.
That’s not a criticism of Biilmann. He named something important and named it well. It’s a map of where the work is, and the work has moved past where the map ends.
There Are Two Agent Experience Conversations, and Only One Has an Owner
The confusion worth clearing up is that AX is being used for two different jobs.
The first job is AX for machines. Clean APIs, machine-readable documentation, files like llms.txt, authentication built for non-human users, the Model Context Protocol (MCP) that lets agents talk to tools. This is the loud conversation. Engineers own it, it’s well funded, and it matters. When your customer’s agent tries to use your API and fails silently, that’s an AX problem, and infrastructure teams are right to fix it.
The second job is AX for humans. This is what the agent says to the person it works for. What it asks before it acts. What it admits when it isn’t sure. What it does when it gets something wrong.
That second job is being claimed right now, mostly by interaction designers, and mostly framed as an interface problem. Override buttons. Transparency panels. Control toggles. Significant work, and useful. But it describes the container and calls it the contents.
Here’s the tell, and it comes from Maeda again. Previewing his 2026 report, he described AX as moving from crafting interfaces to orchestrating outcomes with “zero visual affordances”.
Sit with “zero visual affordances.” If there’s no interface left to design, what shapes the experience? Language.
The words the agent uses to explain itself, to ask permission, to signal doubt, to recover from a mistake. That isn’t a copy layer sitting on top of the real design. In an agent, that is the design.
I’m not saying the interface designers are wrong. I’m saying they’re solving the visible ten percent and treating the other ninety as decoration.
Look at the Agent Experience Principles Everyone Already Agrees On
You don’t have to take my word that this is Content design. Look at what the field has already decided good agentic UX requires, and notice what those principles are actually made of.
The design studio Fuselab lists four principles for agent interfaces: transparency into the agent’s reasoning, control to override at any step, proactive status communication, and structured error recovery that explains what failed and what to do next.
Read those again as a Content designer.
Transparency into reasoning is an explanation, writing, if you will. Structured error recovery is telling a person what happened, why, and what they can do next. That’s error message design, the oldest craft we have. Proactive status communication is choosing what to say while someone waits. Three of those four principles are language decisions wearing interface clothes.
The designer Alexandra Vasquez, writing on agentic UX, said it more plainly than I could. Transparency, she wrote, “is not about showing everything.” It’s about showing the right thing, in the right place, at the right moment.
That is the definition of Content design. Deciding what to show, where, and when, is the entire job. She was describing our work and calling it something else.
Confidence tells the same story. How sure an agent sounds is a phrasing decision, not a model setting. Watch the difference.
Precious: Send the Meridian invoice”
Before: “Done.”
After: “I found three invoices that match. I’m fairly sure this is the one you meant, based on the project name and date. Want me to send it?”
Same underlying model. Same data. The gap between those two is entirely written, and it’s the gap between a user who trusts the agent and one who just stops using it. Nobody tuned a neural network to produce the second version. Somebody made a content decision.
AI Agent Trust Is Already Breaking, and It’s Expensive
If this were a small problem, you could leave it to whoever sits closest to the code. It isn’t small, and the receipts are piling up.
A 2026 study by the customer communications company Sinch found that 74% of enterprises have had to roll back a live AI customer communications agent. Among companies with the most mature AI guardrails, that number rose to 81%. The better-governed teams pulled back more often, because they were watching closely enough to catch what was going wrong.
What was going wrong usually wasn’t the model. It was a decision nobody made. Nobody had decided what the agent should say when it was uncertain, when a user pushed it, or when it was simply wrong.
The clearest case has a name and a number. In Moffatt v. Air Canada, 2024 BCCRT 149, the British Columbia Civil Resolution Tribunal held the airline liable after its chatbot invented a bereavement refund policy that didn’t exist. Jake Moffatt relied on what the chatbot told him, booked his flights, and was refused the refund it had promised.
Air Canada’s defense is the part worth remembering. It argued the chatbot was, in the tribunal’s paraphrase, a “separate legal entity responsible for its own actions.” The tribunal rejected that flatly and ordered Air Canada to pay $812.02 in damages and fees.
The money is trivial, but the precedent is not. A company does not get to disown what its agent says. In this case, the ruling was Canadian, and the sum was small, so read it as direction rather than settled global law. But the direction is clear, and regulators are moving the same way.
The EU AI Act brings transparency obligations into force through 2026. Telling a user they’re dealing with an AI, what it can do, and how to reach a human stops being a courtesy and becomes a requirement. Every word of that is language. Every word of it is Content design, whether or not a content designer is in the room.
Why Content Designers Weren’t in the Room
Here’s the part I won’t dress up, because pretending otherwise would be easy and dishonest.
Content designers weren’t shut out of AX by some conspiracy. We were often missing from these rooms because we kept describing ourselves as writers. We talked about tone and microcopy while the people building agents talked about behavior, evaluation, and risk. We showed up to argue about button labels and skipped the meetings about what the system should actually do.
The industry didn’t help. AI features get funded through engineering budgets, and content still gets treated as a finishing pass, the polish you apply after the entire work is done or halfway done.
Neither excuse closes the gap. The most consequential writing in the entire product, the sentence that decides whether a person hands an autonomous system their money or their customers, is being written by people who were never trained to write it. That’s not a turf war. It’s a question of quality sitting in plain sight, and it’s ours to fix because nobody else is trained for it.
What Content Design for AI Agents Actually Looks Like
So what does doing this look like? Not “bring empathy.” Something you can put on a project plan. Here are the surfaces content design owns in agent experience, each one a real decision made in language.
Behavior design. Deciding when the agent asks, when it assumes, and when it refuses. A set of rules written before a single line of the agent’s copy exists.
Uncertainty design. Deciding what the agent says when it doesn’t know. Not one fallback line, but a range of honest responses matched to how unsure it truly is.
Confidence calibration. Deciding how sure the agent should sound, and making the language match its real confidence instead of faking certainty. [Read here]
Intent preview and confirmation. Writing the sentence the agent shows before it acts, so a person can catch the mistake before it costs anything.
Error recovery. Writing what happened, why, and what to do next, with no blame and no dead ends.
Escalation and handoff. Writing the moment the agent steps back and passes a person to a human, so it reads as care instead of abandonment.
Tool-use narration. Turning “executing API request” into “I’m checking your calendar,” so the person understands what’s happening in words meant for them.
Evaluation. Deciding how you’ll know any of this worked, and building the rubric that measures whether the agent’s language earned trust or lost it.
Governance. Deciding what the agent must never say, and writing rules that hold under pressure instead of only covering the obvious cases.
None of that is a copy pass. Each one is a decision about how an autonomous system behaves toward a person, made in language, before and during the build. That’s Content design. It always was.
The Standard Isn’t Set Yet
Agent experience is being built from two directions. The machine half, the APIs and protocols, is being handled by people who are good at it. The human half, the part that decides whether anyone trusts these things, is still open.
It’s open because it got mistaken for an interface problem when it’s a content problem. And it’s open right now, which is the detail worth acting on. Most companies haven’t settled their agent patterns. Nobody has locked in what an agent should say when it’s unsure, how it should ask before it acts, or how it should own a mistake.
The people who answer those questions well will define the discipline. Those are content design questions. They were always going to be.
So stop treating the agent’s language as the last thing before launch. Write the behavior spec before the feature ships, not after it fails in public. That single change, deciding the words before the build instead of after, is the difference between an agent people trust and one they roll back.
Key Takeaways
- Agent experience (AX) was coined by Mathias Biilmann of Netlify in 2025 and framed around infrastructure: access, context, tools, and orchestration.
- That framing leaves out the human half, what the agent says to the person it acts for, which is a content design problem, not an interface one.
- Most agreed-on agent design principles, including transparency, confidence, and error recovery, are language decisions at their core.
- The cost of getting this wrong is real: 74% of enterprises have rolled back a live AI agent (Sinch, 2026), and Moffatt v. Air Canada made a company legally liable for its chatbot’s words.
- The discipline’s human half is still unclaimed. Content designers are the ones trained for it.
Frequently Asked Questions
What is agent experience (AX)? Agent experience is the practice of designing products, systems, and language so AI agents can operate them reliably. It was coined by Netlify CEO Mathias Biilmann in 2025. It has two halves: a machine-facing half (APIs, documentation, protocols) and a human-facing half (what the agent says to the person it acts for).
Who designs how AI agents communicate? Right now, often engineers and interaction designers by default. The work itself, deciding what an agent says, asks, and admits, is content design. That responsibility is largely unclaimed in most companies.
How is agent experience different from user experience and developer experience? User experience (UX) designs for humans using a product. Developer experience (DX) designs for developers building on it. Agent experience (AX) designs for AI agents using it, plus the humans those agents act on behalf of.
What should an AI agent say when it doesn’t know the answer? It should signal its uncertainty honestly rather than guess or stay silent. Good uncertainty design gives a range of responses matched to how unsure the agent actually is, which is a content design decision, not a model setting.
Is content design still relevant now that AI writes the words? More relevant, not less. AI can generate language, but it can’t decide what an agent should say when it’s wrong, unsure, or about to act on someone’s behalf. Those decisions are content design, and they determine whether people trust the product.
Why do companies roll back AI agents after launch? Usually not because the model failed, but because nobody decided how the agent should behave in language when things went wrong. A 2026 Sinch study found 74% of enterprises have rolled back a live AI customer communications agent.
If you build or write for AI products, write the agent’s behavior spec before the feature ships. Start with one question: what should it say when it doesn’t know?
Sources
Mathias Biilmann, “Introducing AX” (2025);
John Maeda, Design in Tech Report (2025, 2026);
Fuselab Creative, “Agent UX” (2026);
Alexandra Vasquez, “Agentic UX: 7 Principles” (2026);
Sinch, “The AI Production Paradox” (2026);
Moffatt v. Air Canada, 2024 BCCRT 149;
EU AI Act.