Accessibility Is the Architecture

A screen reader hits a button and says “button.” Not “blue rounded rectangle near the top right.” Button. It knows because someone, somewhere, decided the button should carry its own meaning instead of leaving that meaning trapped in the paint. Role, name, state. What it is, what it’s called, what it will do if you press it. A blind user has known what that button is for fifteen years, in the dark, without ever seeing a pixel of it.

An AI agent looking at that same button has a version of the same problem, whether it knows it or not. Some agents read the structure underneath. Some just take a screenshot and read the paint, the way a sighted person does. It doesn’t matter which. The moment the meaning lives only in the paint and not in the bones, the agent is guessing at what the thing is. And a machine guessing at what a button does, on a screen where nobody ever wrote down what the button does, is precisely the unreliability the whole industry cannot stop complaining about. The blind user has been routing around that exact gap for fifteen years. The agent just walked into it.

The disability community solved the observation problem for autonomous agents a decade before the AI industry knew the problem existed. That is the whole essay. Everything after this is me showing my work.

The problem everyone names

Ask anyone building with agents right now what the hard part is and you’ll get the same answer in different clothes. The agents are unreliable. They hallucinate. They do the confident wrong thing. They can’t be trusted in the places that matter, which is to say the places with consequences: money, health, records, anything you can’t take back. Nobody argues about this. It’s the one thing the whole field agrees on.

And the fix everyone reaches for lives inside the agent. Better models. More training. More reinforcement, more parameters, more capability. The reasoning is simple and it feels obvious: the agent is doing the guessing, so make the agent smarter and it will guess less.

Watch where that reasoning puts the problem. It puts it in the model. It says reliability is a thing the agent has to grow, like a kid getting taller, and our job is to feed it until it stops making mistakes.

The people who feel this most are the people with the least room to absorb a mistake. Somebody navigating by keyboard and voice, one wrong announcement away from a form that eats their afternoon. The reliability gap isn’t abstract for them. It’s Tuesday.

Hold onto that, because it’s the tell. When the people who depend most on predictability are the ones getting hurt by the machine’s guessing, the machine and the assistive-tech user are having the same bad day for the same reason. Nobody has said that out loud yet. So let me.

The trust problem and the reliability problem are the same problem

The reason nobody trusts these agents is not that the model is bad. It’s that the model is reading a world that was never written to be read.

Most software was built for a person looking at a screen. The meaning lives in the arrangement: this is a button because it looks like one, this is an error because it’s red, this matters because it’s big and at the top. All of that is legible to a sighted human at a glance and completely invisible to anyone or anything without sight. The structure underneath (the actual bones of the thing) is often a pile of anonymous boxes with the meaning painted on top where only vision can reach it.

Hand that to an agent and it has no choice but to infer. Is this a button or a link? Did the page just change or did it only look like it changed? Did my action work? The agent squints at the paint and makes its best call. Every one of those best calls is a place trust goes to die, because a best call is a guess wearing a nice coat.

This is not a smarter-model problem. You can make the guesser a genius and it is still guessing at a thing that was never declared. The button that doesn’t announce itself is invisible to a screen reader and ambiguous to an agent. The dialog that opens without moving focus traps a blind user and blinds an agent to the fact that the world just moved. It is not two problems that rhyme. It is one problem standing at two distances.

Same patterns, second consumer

Here is the part that took me a while to see, and once you see it you can’t unsee it.

The screen reader and the agent are both consumers of structured semantic meaning. Build for one and you have already built for the other.

Go down the list. Real structure: landmarks, roles, a heading order that tells you where you are. Focus you can predict: where the cursor goes, where it comes back to, what it’s trapped inside on purpose and what it isn’t. Declared affordances: this is a button, this is a link, this is an input, and each one says its own name. Observable state: expanded or collapsed, current or not, busy or ready, announced rather than implied. Error meaning that points at the field it belongs to instead of floating somewhere in red. And a running account of what just changed, spoken as it happens.

For every one of those, name the screen-reader user and the agent in the same breath. The blind user needs to know the menu expanded. The agent needs to know the menu expanded. The blind user needs focus to land somewhere sane after the dialog closes. The agent needs to know the dialog closed and where the world went. It is not that these needs are similar. They are the same need, read off the same structure, by two different consumers, at two different layers of the stack.

This is not analogy. This is identity.

The accessibility community has been writing the specification for agent-reliable software for fifteen years. They called it accessibility because the reader they had in mind was a person with a screen reader, not a machine with an API. The reader changed. The spec didn’t have to.

The inversion

So flip the story that everyone’s telling.

The story everyone tells: AI is going to help fix accessibility. Accessibility is the patient. The agent is the doctor, arriving with fresh capability to help these poor underserved users at last.

The truer story: accessibility is the architecture the agent needs to be reliable at all. Accessibility is the substrate. The agent is the consumer. The disabled user isn’t waiting to be rescued by the machine. The disabled user’s community already wrote the machine’s instruction manual, years early, and filed it under a different name.

We have watched this exact thing happen before, in concrete. The curb cut got poured for the wheelchair. Then the parent with the stroller used it, and the worker with the hand truck, and the kid on the scooter, and the traveler dragging a suitcase, until the thing built for the margin quietly became the thing everyone walks over without a thought. Build for the edge and the center works better. It is the oldest lesson in design, and the field relearns it the hard way every single generation because it keeps believing the margin is a special case instead of the place the truth shows up first.

The accessibility primitives were reliability primitives the whole time. Nobody hid that. It’s just that the people who needed them were easy to not look at, so the rest of the industry didn’t look, and now the industry needs the exact thing it spent fifteen years treating as somebody else’s compliance chore.

What this buys us

When you move the burden of trust off the agent and onto the substrate, the engineering problem changes shape in your hands.

The agent does not have to be trustworthy. The substrate has to be observable. Those are not the same ask, and the second one is a thing you can actually build.

An observable substrate gives you a floor. Behavior you can inspect with the same structure that makes the thing accessible. State that follows declared rules instead of inferred ones. Change that gets announced instead of guessed at. And autonomy that’s bounded by what the interface has actually declared to exist, so the agent is fenced into the real operations instead of freelancing across a surface it’s hallucinating. You are not asking the model to be good. You are building a room it can’t easily wreck.

Two things fall out of that, and they point in opposite directions from where you’d expect.

The disabled user gets more agency, not less. When the underlying structure is rich enough to be read by a machine, it’s rich enough to be re-rendered on demand. Into speech. Into large type. Into a calmer, slimmer version for a brain that’s out of room today. The same structure that lets an agent act is the structure that lets a person tune the whole thing to the way they actually work. Per-person calibration stops being a fantasy and starts being a query against a substrate that finally holds enough meaning to answer.

And the regulated buyer gets something they cannot currently have: an agent they’re allowed to deploy. You cannot put an unobservable agent into healthcare, or finance, or a classroom, or anything a government signs off on. You can put in an agent whose every move is bounded and announced by the substrate it runs on. Observable is the word that turns “interesting demo” into “thing you’re permitted to ship.”

If you have read anything else I’ve written, you already know the shape of this, because it’s the same conviction wearing work clothes. Build it for everyone or don’t build it. The human stays accountable for what happens. Show the receipts: where a thing came from, how sure I am, what would change my mind. I used to say those as values, the way you say things you believe. It turns out they were an architecture the entire time. Accessibility is what those beliefs look like once you pour them into the foundation instead of printing them on the brochure. What you build reveals what you believe. This is me believing it in load-bearing concrete.

The window

Now the part with a clock on it.

The comprehensive standard for the hardest, most human parts of this (the cognitive stuff, the qualitative stuff, the making-it-genuinely-usable-for-a-struggling-brain stuff) does not exist yet in any testable form. The destination has a name and no road. The pieces of accessibility that hardened into shipping requirements are exactly the pieces that became machine-legible: a declared state, a consistent structure, a checkable fact. The pieces still stranded in draft are the qualitative ones nobody has managed to reduce to an observable check. That’s not a hole in the argument. That is the argument. Accessibility becomes a standard precisely where it becomes an observable primitive. The rest is waiting for a vehicle. Agents reading these primitives are that vehicle.

Meanwhile the rules for how autonomous systems have to behave are being written this year, in real standards bodies, by real people, right now. I have gone looking for accessibility in those documents. In the corpus defining how agents should interoperate, the word shows up once, and it’s about captioning the humans in the room, not about how a machine reads an interface. The reliability substrate is missing from the specification of reliability. The regulation raising the bar on high-stakes autonomy comes into force this year with accessibility nowhere near the table where it’s drafted.

I’m not going to dress the dates up. They don’t need it. The decade of how agents and software live together is being shaped this year, by whoever is writing the words. The words about the substrate are not written yet. Whoever writes them gets cited by the next standards cycle, the next rulemaking, the next room where this gets decided.

The category is unclaimed. Not the idea that accessibility and agents touch. Plenty of people are circling that. The specific protocol pattern (how an agent consumes accessibility primitives as its reliability substrate) is the part still sitting on the table with nobody’s name on it.

What I’m doing about it

I’m writing it down. I’m currently developing a methodology for speaking to two types of users at the same time, every time: those who take the page in visually, and those for whom the visuals are unavailable… so the page itself has to carry the structure, the context, and the intent that sight would otherwise supply.

And by those without sight I don’t mean just humans. It’s for agents, too.

At the heart of it is a checklist for how AI agents consume the accessibility primitives that have been quietly solving the observation problem for fifteen years. Five marks, and every one of them points the same way: in the open, for the human and the agent alike, instead of buried in a system watching you back. Declared, not inferred.

The order is the argument. Observable, Verifiable, Explicit, Recoverable, Typed. An interface whose state you can see, whose outputs you can check against their source, whose actions declare what they’ll do before they do it, that lets you back out when something’s wrong, and that never hands you an ambiguous control.

The full technical shape is its own piece, coming next. This piece is the claim that it needs to exist… and the signature on it.

The practice is already in the world, which is the only credential I care about. I’ve built with people who use assistive tech instead of building for a version of them I imagined. There’s a dark-mode agent one of them and I worked out together that taught me more about action semantics than any spec did, because she caught the thing that only breaks if you can’t see it. I’ve pushed the same structural pattern out through voice, through glasses, through ambient surfaces where there’s no screen to hide the meaning behind, and it held. Different consumption, same substrate. That’s not a slide. That’s a thing that shipped and kept working.

And this is not a pitch. There’s no waitlist and nothing to buy. It’s an invitation, to the people who’d actually move this: the accessibility engineers who wrote these patterns, the AI architects who need them and don’t know they exist yet, the design-system people who maintain the substrate, the standards folks already in the rooms. The window is open. It closes when someone publishes. I’d rather it were a lot of us.

One more thing, and it isn’t decoration. Nothing about the disability community without the disability community. Whatever this becomes gets built with the people whose fifteen years of work it stands on, and they get paid for their time and named for their contribution, or it isn’t worth building. The whole point is that the margin was right first. You do not get to prove that by talking over it.

Closing

A screen reader hits a button and says “button.” It has been saying it, patiently, correctly, in the dark, the whole time the rest of us were staring at the paint.

The disability community solved this before the industry knew there was a problem to solve. The work now is not to invent anything. The work is to use what they already built, to write down the pattern that was there all along, and to do it before the rooms where this gets decided finish writing everyone else’s version.

Accessibility was never the thing the architecture would eventually get around to helping.

Accessibility is the architecture.