## The Interface Problem That Didn’t Exist Five Years Ago
When I began my career building digital interfaces, the user was always a human. Predictable in some ways, surprising in others — but always a person in front of a screen, making deliberate decisions.
That assumption is breaking down. And **designing for AI agents** — interfaces that must serve both human operators and autonomous systems simultaneously — is the most intellectually demanding problem I’ve worked on in 20+ years of UI/UX practice.
At [Validera](https://www.validera.io), where I currently work as Senior UI/UX & AI Product Engineer, my primary challenge is designing interfaces that serve two kinds of users at once: human compliance operators who need oversight and control, and autonomous AI agents — Anthropic Claude, Microsoft Copilot, OpenAI Operator — that are taking financial actions on those humans’ behalf.
This article documents what I’ve learned. The principles, the patterns, and the places where conventional UX wisdom fails entirely when applied to agentic systems.
—
## Why AI Agent UX Is Fundamentally Different
Traditional UX assumes a tight, synchronous feedback loop: user acts → system responds → user sees result → user decides next action. The loop is fast, explicit, and human-controlled at every step.
Designing for AI agents breaks this loop in three critical ways:
**Actions are asynchronous and multi-step.** An AI agent may execute a dozen sub-tasks over several minutes before surfacing a result. The human isn’t in the loop for each step. Designing for visibility without overwhelming the operator is a non-trivial structural challenge.
**Actions can be irreversible.** At Validera, we specifically protect against AI agents executing financial transactions that cannot be undone. The consequences of UX failure aren’t user frustration — they’re financial loss or compliance violations.
**Trust must be actively calibrated.** With human-controlled software, trust builds through repeated use. With AI agents, both over-trust and under-trust produce dangerous outcomes. The interface must actively support appropriate, situationally-aware trust — not just feature adoption.
—
## Principle 1: Make Agent Actions Legible
If operators can’t understand what an AI agent is doing — and why — they cannot provide meaningful oversight. Legibility is the first design obligation in any human-AI interface.
Legibility in practice means:
– **Real-time state indicators.** Is the agent thinking, waiting for data, executing, paused, or done? Users should never have to wonder if the system is working or frozen.
– **Human-language audit trails.** Every significant agent action should appear in a log phrased in plain language: *”Sent approval request to finance@company.com”* not *”POST /api/notifications/send 200 OK”*.
– **Selective reasoning transparency.** For high-stakes decisions, surface *why* the agent chose a particular path. Not chain-of-thought dumps — the one or two decision-relevant factors that matter.
At Validera, we built a **validation feed**: a real-time, conversational log of agent actions, human approvals, and system events. In every user session we observed, this was the feature operators pointed to when describing why they trusted the system enough to delegate tasks.
—
## Principle 2: Design Guardrails, Not Just Warnings
A warning tells users something might go wrong. A guardrail prevents it from going wrong in the first place.
In traditional software, warnings work because the human is always the final actor. With AI agents, the *system* is the actor. Warnings alone are insufficient.
Guardrails in AI agent UX look like:
– **Scope constraints.** Explicit, configurable rules defining what an agent can and cannot do autonomously. At Validera, operators set these in a no-code admin panel: transaction limits, approved counterparties, permitted action types.
– **Confirmation gates.** For high-impact actions, require explicit human confirmation before execution — regardless of agent confidence. The sub-300ms verification layer we built at Validera enforces this without adding perceptible latency on low-risk operations.
– **Rollback affordances.** Where technically possible, design agent workflows so actions can be reversed. Communicate the reversal window clearly and prominently — especially for financial actions where the window is narrow.
—
## Principle 3: Design for Calibrated Trust
One of the most counterintuitive lessons in designing for AI agents: designing for *too much* trust is as dangerous as too little.
If the interface presents AI agents as infallible — smooth animations, confident language, zero visible uncertainty — operators stop applying their own judgment. They approve things they shouldn’t, because the system projected certainty.
Conversely, constant warnings and confirmation dialogs cause alert fatigue. Operators approve everything reflexively. Same outcome, different route.
Calibrated trust design in practice:
– **Surface confidence selectively.** Don’t show a confidence percentage on every agent output. Show it when confidence is notably low, or when the stakes are high enough to matter.
– **Use language that signals honest uncertainty.** *”Based on available data, the recommended action is X”* is more accurate than *”The action is X”*. Both are honest; one acknowledges fallibility.
– **Make past errors visible.** A transparency feed that includes corrections — *”Agent suggested X; operator approved Y instead”* — helps operators build accurate expectations about where the system is and isn’t reliable.
—
## Principle 4: The Interface Is the Control Plane
In agentic systems, the interface isn’t just how users observe what’s happening. It’s the primary mechanism through which they *govern* the system. This reframes the entire design problem.
At Validera, the admin panel where operators configure agent rules is architecturally as important as the real-time validation feed. More important in some respects — because the rules determine what the feed ever needs to surface.
Control plane design requirements:
– **No-code configuration.** The people who should be setting agent boundaries — compliance officers, finance controllers, operations managers — are not engineers. If configuring guardrails requires JSON or SQL, the guardrails will be misconfigured or not configured at all.
– **Auditable change history.** Who changed which rule, when, and why. Not a nice-to-have: a compliance requirement in virtually every enterprise context where AI agents touch financial data.
– **Policy language, not code language.** *”Transactions above $10,000 require two-person approval”* is a policy. Expressing it as a natural-language rule in the UI — and having the system parse it into executable logic — is fundamentally more usable than a form with fields for `threshold: number` and `approvers: array`.
—
## What Traditional UX Principles Still Apply
Not everything is new. Core UX fundamentals hold:
– **Progressive disclosure** is still essential — in agent UIs, this means surfacing the summary and letting operators drill into details on demand. Don’t expose all 47 sub-actions the agent took; surface the three decision points that mattered.
– **Error recovery over error prevention** — agents will fail. The UX question is how gracefully the system supports recovery when they do.
– **Accessibility** is non-negotiable regardless of interface novelty. Enterprise agent UIs are used by people with visual impairments, motor limitations, and cognitive differences who need reliable, accessible tooling to do their jobs.
—
## Where the Field Is Going
We are early. The conventions governing AI agent interface design in five years likely don’t exist yet. Directions I’m watching:
– **Shared context panels** — a canvas where both agent and operator see and annotate the same information simultaneously
– **Regulation-driven transparency requirements** — the EU AI Act and emerging Australian AI governance frameworks will likely mandate specific transparency features in AI agent interfaces
– **Agent capability profiles** — legible representations of what a specific agent is and isn’t capable of, helping operators build realistic mental models before delegating tasks
—
## Closing Thoughts
Designing for AI agents is the hardest UX problem I’ve worked on. It combines information architecture, interaction design, systems thinking, compliance, and ethics — and forces you to question assumptions that have held since the early days of the web.
The fundamentals still apply: make what’s happening legible, make control intuitive, and always design for the human who ultimately has to trust — or override — the system.
—
*Related reading: [AI-Powered UX Analysis Using Mobile App Store Data](/blog/2026/06/12/ai-powered-ux-analysis-mobile-app-store-data-guide/) · [What Is a UI/UX Architect?](/blog/2026/06/16/what-is-a-uiux-architect/)*
*Designing an AI-powered product and wrestling with these challenges? I’m available for [architecture reviews and consultancy](https://www.gokhanmeric.com/#contact).*