The Agentic Interface Has Two Faces. We're Building the Easy One.

a16z put "the agentic interface" on its 2026 list of big ideas, and they're right. Software is being rebuilt for a new kind of user. When an agent is the one reading your product, the old assumptions about screens, clicks, and human attention stop holding. Interfaces have to become legible to machines that act on a person's behalf. That shift is real, and it is already underway.

But agent-readable is only half of the agentic interface, and it is the easier half. I learned that building BiModal Design, an open framework for interfaces that serve a human and an agent at the same time. Designing for the agent is the tractable part. Designing for the human on the other side is not.

There are two faces here. The first is the one the industry is racing to build: making your product usable by an agent. Clean APIs, structured outputs, machine-readable state, the plumbing that lets an agent operate your software instead of a human. That is a real problem, and it is largely an engineering one. It will get solved, because it is specifiable and everyone can see it. You can write a ticket for it.

The second face is the one almost no one is building: how the agent behaves toward the human on the other side. When an agent does the work, the human's entire experience of your product collapses into the agent's behavior. Not the screen. The behavior. How it expresses confidence. When it acts on its own and when it stops to ask. What it does the moment it is wrong, because it will be wrong. Whether the second interaction earns more trust than the first, or less.

That is the behavioral layer, and it is the new UX. In an agent product, behavior is not something layered on top of the experience. It is the experience. And it is the part that does not show up in a mockup, does not get owned by a team, and does not get specified before someone ships. It falls through the gap between design, engineering, and product, and lands on whoever wrote the prompt last.

This is why so many agentic products are impressive in a demo and untrusted in production. The demo shows capability. Production reveals behavior: the hedge that should have been there and wasn't, the escalation that never came, the confident wrong answer that cost someone real money. Capability gets you the meeting. Behavior decides whether anyone keeps using the thing. The trust layer is the moat, and right now it is being left to chance.

I have spent the last few years treating that layer as something you can design and engineer rather than hope for. The method is plain: write the behavior down. A behavioral contract is a set of numbered, testable clauses that specify how a system is allowed to behave.

A clause looks like this. When the agent's confidence in an answer drops below a set threshold, it does not present the answer as fact. It says so in plain language, shows the source, and lets the user decide whether to proceed. That is one clause. It is something an engineer can verify, a test can cover, and a user can feel. Escalation triggers are clauses. Failure states are clauses. The path back to trust after an error is a clause.

The point of writing it down is not documentation. It is survival. Behavior that lives in someone's head gets cut the first time a deadline arrives. Behavior that lives in a numbered contract becomes a requirement, with the same standing as latency or uptime. It moves behavior from opinion to specification, which is the only form it survives in.

I have also been designing for both faces at once, because they are not separate problems. An interface in an agentic product serves a human and an agent at the same time. Designing for both, rather than bolting one onto the other, is its own discipline. I open-sourced a framework for it called BiModal Design. In testing, designing for both raised agent task completion by 40 to 75 percent. The human-trust half is harder to put a number on, but it moves for the same reason: behavior is the surface the two of them meet on.

So a16z is right that the interface is being rebuilt for agents. I would add the half that is getting skipped. The agent-readable face is a plumbing problem, and plumbing problems get solved. The behavior-trustworthy face is very clearly a UX problem, and it is the one no one owns.

The companies that win the agentic era will not be the ones whose products agents can read. Everyone will have that. They will be the ones whose agents behave in a way people can trust, on the second interaction and the thousandth.

That is the new UX. Someone has to own it.