Part 9 of the “UX × AI” series.

In Article 8, we audited the UX failures of AI products as they exist today—chatbots that fail confidently, error messages that explain nothing, interfaces that collapse the distinction between a well-grounded answer and a fabricated one. I closed that article by naming the frontier where these failures become most consequential: agentic systems, where AI does not just respond to requests but takes autonomous action on a user’s behalf.

This article is about that frontier directly.

Because the shift from generative AI to agentic AI is not an incremental product update. It is a fundamental change in the relationship between a user and an interface—one that breaks design assumptions that have held since the earliest graphical user interfaces, and one that the UX community needs to understand deeply before agentic products become as ubiquitous as the chatbots we examined in Article 8.

Every interface most of us have ever designed or used assumes a specific relationship: the user initiates, the system responds. The user clicks a button, the system performs an action. The user types a query, the system returns a result. This assumption is so foundational to interface design that it is rarely stated explicitly—it simply is how interfaces work.

Agentic systems break this assumption completely. The system initiates actions. It makes decisions. It changes state. It does things the user did not explicitly request, in service of a goal the user did establish—but through a path the user did not specify and may not have anticipated. An interface built on the traditional assumption has no pattern for this. No way to show an unsolicited action. No way to explain why it happened. No established path for the user to intervene before, during, or after.

This is the design challenge of this article, and I believe it is the single most consequential UX challenge facing the profession over the next several years.

Why this is happening now, and why it matters in India specifically

The shift toward agentic AI is not a speculative future trend. It is happening at a pace that should focus the attention of every UX professional reading this series.

Gartner projects that 40% of enterprise applications will integrate task-specific AI agents by the end of 2026—up from under 5% in 2025. This is one of the fastest capability adoption curves in the history of enterprise software, and it means that most product organisations deploying agentic features are doing so without an established design discipline to draw on. The interface layer this requires did not exist a year ago for most of these teams. They are building it now, under deployment pressure, often without the UX involvement that Article 8 identified as the structural cause of so many AI product failures.

In the Indian context specifically, EY’s report on the AI outlook for India in 2026 found that the shift to agentic AI marks a major inflection point, with 24% of business leaders already deploying it. This is not a Western technology trend that India will adopt with a delay. It is happening concurrently, across Indian enterprises, in sectors—financial services, healthcare, government services—where the stakes of agentic failure are not abstract. They are immediate and consequential for the citizens and customers these systems serve.

This timing matters enormously for the Indian UX community specifically. We are not in a position to learn from years of accumulated agentic UX best practice developed elsewhere and then adapt it. We are building this discipline concurrently with everyone else, in contexts—multilingual users, varying digital literacy, infrastructure constraints, trust dynamics specific to Indian institutions—that the emerging global frameworks for agentic UX have not yet adequately addressed. This is both a challenge and an opportunity. The Indian UX community has the chance to shape agentic design patterns that genuinely serve our specific user contexts, rather than inheriting patterns designed for a different population and adapting them after the fact.

“Agent UX is a distinct design discipline requiring specific patterns for transparency, control, status communication, and recovery. The teams shipping successful agent products in 2026 treat the interface as the accountability layer between user intent and autonomous action, not an afterthought applied after the model works.” — Fuselab Creative, 2026

The five patterns every agentic interface needs

There is an emerging consensus, across the design teams and researchers who have been building agentic products seriously, around a core set of patterns that any agentic interface requires regardless of its specific domain. I want to walk through each of these carefully, because they form the practical foundation of this article.

Planning visibility. Before an agent begins a multi-step task, the user needs to see what the agent intends to do—the plan, not just the final outcome. This is fundamentally different from a traditional loading state, which communicates only that something is happening. Planning visibility communicates what is going to happen, in terms specific enough that the user can evaluate whether the plan matches their intent before the agent begins executing it. The agent that says “I will book your flight to Mumbai” without specifying which flight, which dates, which fare class, and what budget constraint it is applying has not provided planning visibility. It has provided a vague intention statement that does not allow the user to catch a misunderstanding before consequential action is taken.

Tool-use disclosure. Agentic systems frequently work by invoking tools—querying a database, calling an external API, executing a calculation, accessing a file. The user needs visibility into which tools the agent is using and why, not as a technical curiosity but because tool use is where agentic errors most frequently originate. The travel chatbot failure we examined in Article 8—quoting flight prices from a learned pattern rather than a live API—is a tool-use failure that disclosure would have made visible before it caused customer harm. If the interface had shown “checking live fares via [airline] booking system” versus showing nothing and simply presenting a number, the user and the system both would have had a clearer signal about the reliability of what was being presented.

Memory surfacing. Agentic systems often retain context across interactions—remembering a user’s preferences, previous decisions, or ongoing tasks. This memory needs to be visible and editable, not a hidden state that silently shapes the agent’s behaviour in ways the user cannot inspect or correct. A user who told an agent three weeks ago that they prefer aisle seats should be able to see that this preference is still active, understand why the agent selected an aisle seat in a current booking, and change the preference if it no longer applies. Hidden memory is one of the most disorienting agentic UX failures—the agent behaves in ways that seem inconsistent or presumptuous, and the user has no way to understand why, because the context driving the behaviour is invisible to them.

Multi-step workflow tracking. For agentic tasks that unfold over multiple steps—sometimes over extended periods of time—the user needs a persistent, accessible view of where the task currently stands, what has been completed, what remains, and what decisions have been made along the way. This is fundamentally different from a single-interaction chatbot exchange. It requires interface patterns more similar to project management tools than to conversational interfaces—a structured, navigable representation of an ongoing process, not a scrolling chat log that becomes unusable as the interaction history grows.

Recovery routing. When something goes wrong in an agentic workflow—and as we established in Article 8, things will go wrong—the user needs a specific, actionable path back to a working state. This is the agentic equivalent of the differentiated error handling we discussed in the chatbot context, but with higher stakes, because the failure may have occurred several autonomous steps into a process the user was not actively monitoring. The interface needs to communicate not just that something failed, but at which step, why, what state the overall task is currently in as a result, and what the user’s options are for correcting course.

The autonomy slider: Why control cannot be binary

One of the most important conceptual shifts that agentic UX requires is the recognition that autonomy is not a binary switch. It is a spectrum, and good agentic design gives users meaningful control over where on that spectrum a given task or a given agent should operate.

The autonomy slider—provide a visible, adjustable control that lets users set how much independence the agent has—is emerging as one of the most important design patterns in this category, and the principle behind it is significant: this control should not be buried in a settings page. It should be a primary UI element, visible and accessible at the point where the user is deciding how much to delegate.

Consider the practical range this spectrum should cover. At one end, the agent operates in a fully manual mode—proposing actions but requiring explicit approval before each one is executed. This is appropriate for high-stakes, infrequent, or unfamiliar tasks, where the user wants maximum visibility and control even at the cost of efficiency. At the other end, the agent operates with full autonomy within defined boundaries—executing a complete multi-step task without requiring approval at each step, appropriate for routine, well-understood, lower-stakes tasks where the user has built sufficient trust in the agent’s reliability.

Many teams hesitate to let AI take action with full autonomy from the start—and the design solution to this hesitation is not to avoid autonomy altogether, but to provide a sandbox mode that lets users safely simulate outcomes before committing to real-world execution. This is especially important in regulated, high-stakes domains like fintech and healthcare, where experimentation without real consequences is what allows trust to be built incrementally, through direct experience of the agent’s reliability, rather than through a marketing promise that the user is asked to take on faith.

This variable autonomy model also directly serves a population that the Indian UX community must take seriously: users for whom trust in autonomous digital systems is not a default assumption. A first-generation digital banking user, asked to delegate financial decisions to an autonomous agent, has every reason to want to start with maximum visibility and approval requirements, and to expand the agent’s autonomy gradually as their own confidence in the system’s reliability grows through direct experience. Designing for a binary choice—full autonomy or no AI assistance at all—fails this user entirely. Designing for a spectrum, with a clear and accessible mechanism for adjusting it, respects the legitimate caution that this population brings to autonomous systems.

“In traditional AI UX, the user remains firmly in control. The AI assists, recommends, or automates specific tasks, but only when explicitly triggered. In agentic AI systems, that relationship changes—the AI behaves more like a collaborator than a tool. When users are no longer directing every step, the interface must clearly communicate intent, autonomy boundaries, reasoning, and outcomes.” — Onething Design, 2026

Explainability on demand, not explanation by default

A related and equally important pattern addresses a tension that agentic UX design must navigate carefully: the tension between transparency and cognitive overload.

If an agentic system explained every decision it made, in full technical detail, at every step, the resulting interface would be unusable—drowning the user in explanatory text that obscures rather than clarifies the actual progress of their task. But if the system provides no explanation at all, it fails the transparency requirement that this entire article has been building toward.

The resolution is explainability on demand. The interface, by default, shows the user what is happening at a level of detail appropriate to routine confidence—a clear, brief status that does not require deep engagement to understand. But at any point, the user can request a deeper explanation—why did the agent choose this specific action, what alternatives did it consider, what data informed this decision—and receive an answer specific enough to evaluate whether the agent’s reasoning matches their actual intent.

This pattern strikes the balance that good agentic UX requires: routine operation does not demand the user’s full attention, but full transparency remains available the moment the user wants it—particularly important in the moment something feels wrong, where the ability to ask “why did you do that?” and receive a genuine, specific answer is the difference between an agent the user can continue to trust and one whose autonomous behaviour starts to feel arbitrary and threatening.

Fast correction loops: Why undo is the most important feature

Even the best-designed agentic systems make mistakes. This is not a hypothetical risk to be designed around defensively—it is a certainty that good agentic UX must design for directly, through what the design literature increasingly refers to as fast correction loops.

Agentic features like undo, exit, and customisation give users flexible, adaptive control over their interactions, and this control should be treated as a core feature of agentic design—not an edge case bolted on after the primary functionality is complete. Even in highly autonomous systems, users must retain the ability to pause, modify, override, or reverse the agent’s actions, and clear controls for stopping or correcting that behaviour reassure users that they remain accountable and in charge, even as they delegate increasing amounts of task execution to the system.

This principle is vital in exactly the high-stakes workflows where agentic AI promises the most value—financial transactions, healthcare scheduling, legal document preparation—precisely because these are the domains where an uncorrected agentic error has the most serious consequences. The interface that makes “stop this” and “undo that” as fast and as visible as the agent’s forward progress is an interface that earns the right to operate with greater autonomy over time, because the user’s trust is anchored not in a promise that errors will not occur, but in direct experience that errors, when they do occur, can be caught and corrected quickly.

There is a second, equally important principle here: consistency. Agentic AI should behave in ways that are consistent and predictable across similar situations, and UX design plays a critical role in reinforcing this by standardising how actions, decisions, and explanations are presented across every interaction. When users can anticipate how the agent will respond in a given type of situation, they become more willing to delegate responsibility to it. Inconsistent behaviour—even when each individual decision is technically defensible—erodes confidence rapidly and increases the cognitive load of working with the system, because the user can no longer build a reliable mental model of how the agent operates.

Applying LucyUX to agentic design

The LucyUX framework—Listen, Understand, Conceptualize, Yield—provides the structure for approaching agentic design with the rigour this frontier demands.

Listen—to the specific moments where users hesitate to delegate authority to an autonomous system, and to what that hesitation is actually about. Is it a lack of understanding of what the agent will do? A lack of confidence in its reliability for this specific type of task? A cultural or contextual factor—particularly relevant in the Indian market, where trust in autonomous digital systems cannot be assumed uniformly across the population—that shapes how much autonomy a user is comfortable granting? Listening to these specific hesitations, rather than assuming a generic comfort with autonomy, is the foundation of agentic design that actually serves real users.

Understand—building an accurate model of the user’s mental model of the agent’s capability and reliability, and of the gap between what the agent can technically do and what the user trusts it to do reliably. This understanding determines where on the autonomy spectrum a given user, in a given context, should be defaulted to—and it requires research specific to agentic interactions, not assumptions carried over from research on traditional, user-initiated interfaces.

Conceptualize—designing the planning visibility, tool-use disclosure, memory surfacing, workflow tracking, and recovery routing as core architecture from the beginning of the design process, alongside the autonomy slider and the explainability-on-demand pattern that allow users to calibrate their relationship with the agent over time. This is the conceptualisation work that Article 8 identified as missing from most current AI products—UX involvement at the architecture stage, not the polish stage, applied here specifically to the unique demands of autonomous systems.

Yield—measured in the user’s growing willingness to delegate appropriately, calibrated against the agent’s actual reliability—not in the raw amount of autonomy a system has been granted to exercise. An agentic product that has earned a user’s trust to operate with significant autonomy in well-understood, lower-stakes tasks, while appropriately retaining tighter user control in higher-stakes or less familiar situations, has achieved the yield that genuinely good agentic UX is designed to produce: a relationship between user and system that is honest about risk and genuinely calibrated to earned trust.

Your action this week

If you are working on or adjacent to an agentic AI product—or anticipate that you will be within the next year, given the deployment pace this article has documented—audit it against the five core patterns: planning visibility, tool-use disclosure, memory surfacing, workflow tracking, and recovery routing.

For each pattern, ask a specific question. Can the user see what the agent intends to do before it acts? Can they see which tools or data sources the agent is using and evaluate the reliability of that source? Is the agent’s memory of past context visible and editable, or is it a hidden state shaping behaviour invisibly? Is there a clear, navigable view of where a multi-step task currently stands? And when something goes wrong, is there a specific, actionable path back to a working state—or only a generic error?

If you are not yet working directly on agentic products, use this week to study one that you encounter in your own life—a travel booking assistant, a scheduling agent, an automated customer service system that takes action rather than merely answering questions. Apply the same five-pattern audit. The gaps you find will be instructive, and they are very likely to be common across the category, because this is a discipline the industry is still building.

My perspective: What I actually believe

I believe agentic AI represents the most significant interface paradigm shift since the graphical user interface replaced the command line. That is not hyperbole. The assumption that the user initiates and the system responds has held for forty years of interface design. Agentic systems break it. And the design community has perhaps two to three years—based on the deployment pace this article has documented—to establish the design discipline that will determine whether this paradigm shift serves users well or repeats, at greater scale and higher stakes, the trust-collapsing failures we examined in Article 8.

The patterns in this article—planning visibility, tool-use disclosure, memory surfacing, workflow tracking, recovery routing, the autonomy slider, explainability on demand, fast correction loops—are not exhaustive, and they will continue to evolve as the discipline matures. But they represent the foundation that I believe every UX professional working anywhere near agentic AI needs to internalise now, not in two years when the failures have already accumulated and the trust has already collapsed.

This is the moment to get it right. The interface has stopped waiting for the user. The design discipline that makes that change trustworthy rather than alarming is being written right now, by the practitioners willing to take it seriously before the deployment pressure outpaces the design rigour. I want the Indian UX community to be among those practitioners—shaping these patterns for our specific users, not inheriting them after the fact.

I have spent 25 years watching interface paradigms shift—and I have learned that the shifts that matter most are rarely the ones that generate the most initial excitement. They are the ones that quietly redefine the basic contract between a user and a system. Agentic AI is redefining that contract right now, faster than most product organisations are prepared for. The UX professionals who take the time to understand this shift deeply—not just its technical mechanics but its specific implications for trust, control, and accountability—will be the ones shaping how an entire generation of digital products earns or loses the confidence of the people who use them.

Up next in the “UX × AI” series: “Who Owns the Design When AI Made Half of It?” We close this series with the question the industry has been avoiding. As AI becomes a genuine co-creator in the design process—generating layouts, copy, even strategic recommendations—the questions of authorship, credit, and accountability become urgent and unresolved. In the final article, we examine what ownership means when a design is the product of human judgment and AI generation working together, and why the design community needs to lead this conversation rather than wait for it to be settled by default.

References & further reading