The Second Reader
The moment it clicked, I wasn’t thinking about agents at all. I was deep inside a Copilot Studio surface, arranging the things a person would see and tap, the labels, the order, the small decisions about what to show and what to tuck away. And it slowly landed on me that the most important reader of the thing I was building would never look at it. It would parse it.
For the entire history of our field, the word user has quietly meant a human at a screen. Every heuristic, every journey map, every usability test assumes a person on the other end, looking. That assumption just broke, and most of us haven’t noticed because the break is invisible by design. There is a second reader now. It doesn’t see your interface. It reads underneath it.
This isn’t a metaphor. When an agent encounters a product, it has a few ways in. It can take a screenshot and try to interpret the pixels, which is slow, expensive, and prone to guessing which cluster of text is a date and which is a button. Or it can read the structured layer beneath the visuals, the same machine-readable representation that screen readers have used for years, which is cheaper and far cleaner. Or it can skip the surface entirely and pull straight from the data. Two of those three paths never touch the thing we spend most of our time designing. They touch the structure we usually treat as an afterthought.
So we have a second audience whether we planned for it or not. The only question is whether we designed for it on purpose.
The fix is older than the problem
Here’s the part that should feel like vindication if you’ve ever had to fight for it. The way you design for this second reader is not new. It’s accessibility.
The structured layer an agent reads cheaply is the same one a screen reader has navigated for years. Clear labels instead of icons that mean nothing out of context. Predictable patterns instead of clever one-offs. A structure that actually reflects how things relate, rather than relationships that only exist in the visual arrangement. The agent needs exactly what a person using assistive technology has always needed: a product that still makes sense when you can’t see it.
We knew this. We just kept treating it as a checkbox, the work you get to if there’s time, the thing legal asks about and no one champions. The designers who treated semantic structure as design rather than compliance looked like they were over-investing in something abstract. They were just early.
And being early feels like being wrong, right up until it doesn’t. What changed is that the ethical case for accessibility quietly grew a business case bolted to its side. The same structure that made a product usable for someone with a screen reader is now the cheapest, most reliable way every agent in the world will understand it. The work didn’t change. The stakes did.
There’s a number that makes this concrete. When an agent reads your product as a screenshot, it can burn tens of thousands of tokens just working out what it’s looking at, which text is a date, which box is a button, how any of it connects. When it reads the structured layer instead, that drops to a fraction. Same task, far less effort.
That gap is the whole argument in miniature. Good structure means the agent does less guessing. Less guessing means fewer tokens, less compute, less latency, and fewer chances to get it wrong on the way to the human waiting on the other side. You’re not only making the product legible to the second reader. You’re making it cheaper for that reader to be right.
Get Ana Sofia Gonzalez’s stories in your inbox
Join Medium for free to get updates from this writer.
And at scale, that efficiency stops being just a performance number. Every redundant inference an agent makes because a surface was ambiguous is compute spent recovering meaning that should have been there to begin with. Designing the structure well is one of those quiet places where the careful thing and the efficient thing turn out to be the same thing.
The reader has a name
Everything up to here assumes the second reader is a stranger. An agent shows up, reads the structure, finishes the task, leaves. Anonymous traffic. That’s where the comfortable version of this story ends, and it’s where most of the conversation stops.
But the agents that matter don’t pass through once. They stay. They come back tomorrow, acting for the same person again and again, and somewhere in that repetition they stop being traffic and start being someone. They get a name. Scout.
The moment the reader has a name, legibility isn’t the whole job anymore. You’re designing an identity. An autopilot like Scout has a scope, the things it’s allowed to reach and the things it isn’t. It has a way of announcing itself, or it doesn’t and that silence becomes its own design decision. It carries memory from one task into the next. And when it acts, someone is accountable, which is exactly where the name earns its keep. You can’t govern a stranger. An anonymous agent gives you nothing to scope, nothing to log, nothing to hold responsible when a task goes sideways. The moment that reader has a name, all of it becomes possible: you can grant it permissions, trace what it did back to a single actor, and draw a clear line of responsibility through it. Identity is what turns an agent from loose traffic into something a product can actually govern. The name isn’t a personality choice. It’s the hook every guardrail hangs on.
This stopped being hypothetical while I was writing it. Ten days ago, at Build, Microsoft introduced a new category of agent it calls an Autopilot: always-on, working in the background, acting on your behalf under its own identity rather than borrowing yours. The first one is named Scout. And the reasoning behind giving it a name is the argument I’d just made. An agent with its own identity means its actions trace back to a known actor instead of disappearing into some shared, anonymous account. Identity first, then access, then accountability. The name was never decoration. It’s the foundation an entire system is being built on, this month, in production.
None of that fits on the surface we usually design. It lives in the same structural layer we just spent the last section talking about, except now the structure isn’t only describing what the product is. It’s describing who is allowed to act inside it, and on whose behalf. That’s not interface work anymore. That’s closer to governance, quietly wearing a designer’s hat.
This is the turn the comfortable version misses. The first reader you couldn’t see. The second one you can’t see has a name, a history, and standing in your product. Designing for it isn’t accessibility plus a little extra. It’s deciding how much of a person’s intent you’re willing to hand to something that will keep acting after they’ve looked away.
Landing
Back to that Copilot Studio surface, the one I was arranging when this whole idea clicked. I’m still arranging labels and order, but now I know there are two readers waiting on the other side. One looks. One parses. And lately, that second one has started showing up with a name, a scope, and a place on the org chart, exactly like the people I’m designing for.
That’s the part that still surprises me. I used to think designing for a screen reader and designing for an agent were different problems wearing the same clothes. They’re not. They’re the same problem, arriving in a different order. The structure that makes a product legible to someone who can’t see it is the same structure that makes it legible to something that was never going to look. Accessibility wasn’t preparation for this moment. It was already this moment, we just didn’t know who else was reading.
So the question I keep coming back to isn’t really about agents at all. It’s the same question design has always asked, just with a wider answer than it used to have. Who is this for, and have I actually designed for them, or only for the version of them I assumed would show up. The first reader is still there. But the second one isn’t a stranger anymore. It has a name, it acts on someone’s behalf, and increasingly, it’s the one deciding whether the thing I built ever gets used at all.
I didn’t plan for that reader. None of us did. But it turns out the work we already knew how to do, clearly, structurally, accessibly, was the work that was waiting for them too. We just have to mean it for both readers now, not just the one we could see.










