After the Button: Designing Software for Delegated Autonomy in the Age of Agentic Experience

David Golub
1 day ago
7 min read

For half a century, every workflow in software has terminated in a click. Agentic AI is moving that center of gravity somewhere new.

The button era is ending. The agentic era is here. Build accordingly.

That's not a forecast, it's a description of a paradigm shift taking place in how humans use computers. For decades, software has embraced a logic of graphic controls (from desktops to mobile devices) that is rapidly being upended by AI systems that work even without being asked to do so.

The UX research and design community has started calling this Agentic Experience, or AX, and the framing matters more than it might first appear. AX is not a new visual style or a new framework layered over existing UX, user experience design. Rather, it seeks to answer a different category of problem.

The old model of the so-called Human Computer Interface (HCI) assumed a deterministic contract between user and machine. You look at the display to see what you can do. You do it. The machine executes what was requested (and when it doesn't, we call that a bug).

Agentic AI breaks the grammar of interactive affordances that has defined computer use for half a century. A button does a specific thing. An agent offers a probabilistic attempt at an outcome, mediated by a context that shifts with every prompt.

Agency isn't lost, it changes form. Designing for that requires an emerging toolkit most product teams haven't built yet.

From Visual to Cognitive Affordances

Don Norman's classic formulation held that an affordance is an action possibility perceived by the user. The interface signals what's available; the user acts on the signal.

This formulation has been so successful that it's become invisible: every PM, designer, and founder operates on its assumptions reflexively. Drop shadows, disclosure chevrons, primary CTAs, micro-interactions: the entire vocabulary of "is this clickable?" became the assumed substrate of digital experience.

But what is the perceived action possibility of a chat input box? Infinite possibility, zero indication. The blank prompt is the design equivalent of a wide-open field: technically you can do anything, which in practice means most users do nothing useful.

Researchers now call this the visibility problem. Capability without surfaced capability is, in product terms, no capability at all. Some practitioners go further, arguing chat-first interfaces are the wrong default for agentic work, a paradigm that demos beautifully and disappoints in production.

The solutions emerging in 2026 are not minor tweaks. They are a wholesale reconception of where affordance lives. Capability surfaces not from visual elements but from cognitive signals: suggested prompts that hint at what the agent can do well, dynamic UI blocks that appear when the agent recognizes a relevant task type, ghost text that proposes the next move.

Machine interfaces stop containing the affordances and start negotiating them with the user, turn by turn. The old design question ("Is this discoverable?") gets replaced by a harder one: "Does the user understand what they've just delegated?"

Probabilistic Outputs, Deterministic Clicks

Here is where many agentic products quietly fail. Users have spent decades training on deterministic software. Click Save, file saved. Click Send, email sent. When an agent enters that context, users bring the deterministic expectation with them. And the agent, by design, can't honor it.

"Find me a flight to Boston under $400 that lands before 6 pm" is not a deterministic instruction. It's a constraint set the agent will try to satisfy, with results that may vary by run, by data source, by tool availability. The output requires review. The user has to evaluate not just what was done but whether what was done is what they meant.

This probabilistic gap is not a bug to be engineered away. It's the structural fact of working with intelligent systems. Treating it as a bug (pretending the agent is just a fancier button) produces brittle products that disappoint users in trust-corroding ways.

Treating it as the central design problem produces something different: products where users build calibrated confidence over time, learn the shape of the agent's competence and trust it with increasingly consequential work.

Practically, this means agentic products need to design for verification surfaces alongside execution. Show your work. Surface the reasoning, not just the result. Make it painless for the user to spot-check and steer.

The agent that runs silently and presents a finished outcome is worse, in most cases, than the agent that narrates its plan and pauses at key decisions. Speed without legibility is rarely the right trade.

The Delegation Paradox

There’s a delegation paradox emerging from deployments of agentic systems. As agents become more capable of autonomous execution, human users paradoxically lose the situational awareness required to oversee them effectively.

A coding agent that writes a thousand lines while the developer reads email produces output the developer cannot meaningfully review by the end. A research agent that synthesizes twenty sources into a brief while the analyst takes a meeting produces a synthesis the analyst is no longer positioned to evaluate.

The agent's autonomy and the human's oversight capacity move in opposite directions. The result, at the extreme, is delegation without judgment: the worst of both worlds.

As one recent essay puts it, "bad AI is the new bad UI." The failures look like AI failures, but they're really design failures. When the user can no longer trace why a system did what it did, the entire question of accountability and correction breaks down.

The response in serious product circles is to treat human-in-the-loop (HITL) checkpoints not as a fallback but as a primary design surface, a vision for purpose-driven collaboration between humans and agents rather than a safety harness bolted onto autonomous execution.

HITL means designing the agent's workflow to pause at decision points where human judgment adds irreducible value, and surfacing those moments with enough context that the human can make a real call.

Not "approve this 47-step plan." Rather: "I've narrowed it to these three approaches. Each has these trade-offs. Which fits your situation?"

Practical pattern libraries are starting to take shape for this work: taskboards, start/stop/pause controls, checkpoint gates, the design vocabulary the moment requires.

Designed well, HITL preserves the user's situational awareness without erasing the agent's leverage. Some researchers describe this as a form of attentional synchronization, keeping humans aligned with autonomous systems across long-running tasks. It treats the human as the strategic node and the agent as the execution layer, a configuration that works because each is doing what it does best.

Designed poorly, HITL becomes either a rubber-stamp interface (the human approves what they don't understand) or a friction layer (the human is paged for trivial decisions and learns to ignore the agent entirely). The middle path is the actual design problem.

As HITL matures, the most ambitious version of this pattern evolves into something different: humans not in the loop but on it. Human-on-the-loop (HOTL) describes a stance where the agent operates autonomously by default and the human supervises, intervening when judgment is needed and intercepting patterns the agent shouldn't be left to handle alone.

The transition from HITL to HOTL is not a software upgrade. It's a trust calibration earned over time. Get the foundation wrong and HOTL is impossible. Get it right and the agent does the work while the human does what only a human can do.

Implications for Multi-Step Workflows

The place these patterns matter most is the class of workflows that has always been hardest to automate: multi-step processes that combine judgment, expertise, and execution across hours or days.

Think about sales pipelines. Editorial production. Customer onboarding. Complex research. Legal drafting. Strategic planning.

These are the workflows where graphic-control software plateaued: too much human judgment to fully automate with forms and buttons, too much rote labor to leave entirely to humans.

E-commerce has been the first domain to map this transition systematically (the shift from recommender systems that suggest to delegation systems that execute on the buyer's behalf), but the same pattern is now arriving in every workflow with similar shape.

Agentic systems address this middle layer. But success takes more than racing to autonomy. The next generation of pattern-defining apps will understand where human judgment is irreplaceable, where the agent's execution leverage is highest and how to manage handoffs between them.

In practice, this looks like:

Calibration phases before full deployment, where the system learns the specific user's preferences, constraints, and operational context. A generic agent serving a specific workflow is almost always inferior to a calibrated one.
Autonomy modes that adjust based on the task's stakes and reversibility: high autonomy for low-stakes drafting, narrow autonomy for decisions that are hard to undo. The right level of autonomy is a per-step design choice.
Surfaced reasoning so users can spot-check the agent's logic, not just its outputs. The black-box agent is the agent users eventually stop trusting.
Escalation patterns that recognize when the agent is operating outside its competence and route to the human cleanly, with context. Knowing what it doesn't know is a real design property, not a model property.

Getting this right feels less like "AI features bolted onto SaaS" and more like a new category of working software, one that respects the user's expertise while doing meaningful work on their behalf. The user remains the author of the outcome. The agent does the labor that doesn't require authorship.

After the Button, Press On

The product leaders and founders building in this space face a real choice. The shortcut is to ship a chat interface over an LLM, call it agentic and harvest the demo.

The harder path is to take the AX problem seriously: to recognize that affordance has moved from visual to cognitive, that outputs are probabilistic and need verification surfaces and that human-in-the-loop is a design primitive rather than a safety net.

What’s in play today is the design grammar of the next generation of working software that finally reaches the workflows the graphic-control era could never quite address. Failing to adapt means shipping chatbots that demo well and underwhelm in production, undone not by their models but by the affordances they failed to design.

The button changed everything. Now, everything is changing again.