Tech Navigator: How to build the best agentic experience for humans

Insights

• In 2026, we are moving away from clicking through static menus and toward a world where humans orchestrate goal-oriented software agents.
• This new agent-human partnership is core to the idea of agentic experience (AX).
• Here, the AI is the user interface. Good AX design is no longer about reducing clicks but reducing cognitive uncertainty.
• Every new screen or UI status element should help the user, with the agentic system working in the background to interpret messy situations and help resolve ambiguity.
• By leveraging thought and reasoning traces for transparency, and metadata-inherited context for safety, notifications from the system aren’t just alerts but pivotal to the success of the workflow.

Software has long been a passive tool that waits to be used. Agentic systems break this wait-for-command cycle, completing tasks with high degrees of autonomy, acting within carefully mandated operating procedures, and only reaching out to humans when they get stuck or need confirmation that they are on the right track.

This new agent-human partnership is core to the idea of agentic experience (AX). In 2026, we are moving away from clicking through static menus and toward a world where humans orchestrate goal-oriented software agents, often through natural language — the more invisible, the better.

The challenge is to balance this digital momentum with human governance, ensuring the agent remains a useful presence directed by and under the control of humans, not a black box operating in a vacuum.

Why good AI-driven experiences are needed in business

As we wrote in AI as new UI: Driving agentic process automation at enterprise scale, agentic AI can bring a new and personalized approach to user engagement. Independent agents can handle user queries by routing them autonomously and working with each other to understand, gather, and validate the information needed for a response.

An employee checking the status of their pension and updating their monthly contribution is important but can be taxing. Traditionally, this could require multiple searches and menu clicks on an intranet, as well as reading documents and guidelines to understand which policy applies in their region. In a good experience, an employee could simply type “increase my pension contribution by 2%” into a chat box. The system would then ask any necessary follow-up questions before finalizing the task. This increases user satisfaction, productivity, and economies of scale, especially in core business processes.

How to build AX to reduce cognitive uncertainty

Here, the AI is the user interface. But that doesn’t mean the experience is all plain sailing. Too many notifications, sloppy agent executions, governance bottlenecks, decision fatigue, and no clear preview of the AI’s actions lead to poor business outcomes and poor AI adoption.

The shift from simple user experience (UX) to AX might represent the most significant change in interface design since the transition from command line (CLI) to graphical user interface (GUI). In an AX environment, the user no longer operates the software — this is done in the background. Rather, users define the preferred workflow skeleton and boundaries enforce policies, monitor execution, and orchestrate the high-level flow or blueprint. Agents then take these guardrails and adapt workflows within this frame, choosing the tools, actions, and reasoning loops needed until success or escalation.

This requires a transition from setting up user-facing capabilities and user interface (UI) elements in the product, known as feature onboarding, to aligning on what the goal of the system is.

The primary design constraint, therefore, is no longer reducing clicks but reducing cognitive uncertainty. With good AX design, every new screen or UI status element should help the user, with the agentic system working in the background to interpret messy situations and maintaining memory and context so that humans face fewer ambiguous choices and retain the right to review, override, or stop the agent in the middle of the workflow.

In this way, good AX architecture bridges the gap between human intent and autonomous execution, ensuring that while the agent has the agency to act, the human retains the sovereignty to oversee.

Progressive reasoning increases adoption and reduces anxiety

While AI brings personalization to UX, usability requires AI to be transparent and self-explanatory. When AI systems are not covered in mystery, and outputs align to users’ expectations, McKinsey found that adoption, satisfaction, and ultimately topline growth increase. Conversely, the Conviva 2025 State of Digital Experience report shows how costly poor digital experiences can be. This survey of 4,000 consumers in the US and UK found that 91% of users didn’t give the website a second chance, and when faced with frustration, inopportune workflows, or hidden, unexplained technical flaws, 50% defected to a competitor, and nearly 40% canceled their subscriptions.

AX, therefore, needs a way of revealing to the user why certain things are happening in real time. This should be a revelation of reasoning that transforms the agent from an opaque system into a co-collaborator that is there to guide and explain what’s happening under the hood.

Three reasoning steps are needed in this agent-human revelation:

Reasoning step 1 - the intent summary: This is where the AX states the immediate objective in initiating a workflow. For example, the objective might be, “reconciling 114 overdue line items against updated Q1 procurement terms” in a supply chain system. This serves as the semantic handshake, ensuring the human and the agent are aligned on the “why” before the “how” begins. In critical environments, this summary also acts as a boundary line for what the agent is allowed to do.

Reasoning step 2 - creating a plan-first interaction: Before agent execution, the AX should present the agent’s proposed reasoning chain to the user, a sort of draft proposal that doesn’t just list steps but highlights specific points at which the agent, in its analysis, chose one path over another. For example, it might say, “choosing the standard discount API because the premium waiver has expired.” By reviewing the plan here, users can understand the logic and catch hallucinations before they impact production data.

Reasoning step 3 - the audit trail: This is an accessible but nonintrusive log of tool calls, API responses, and confidence scores. For subject matter experts, this enables decision-making to be grounded in verifiable data. Instead of forcing an administrator to sift through raw system logs, the AX should present an execution map so that if the agent fails, the trace can pinpoint exactly which tool call returned an error, reducing the mean time to resolution for agent debugging.

In all of this, a critical AX principle is that the thought or reasoning trace shouldn’t be static. For our client implementations, we use risk-based scaling. Here, for high-risk transactions, for instance, such as approving a $50,000 purchase order, the AX mandates a full disclosure of the thought trace, requiring reasoning acknowledgement from a human before the final API is committed by the system.

However, for this to work, agents must understand the business context and need to be taught the business environment and user personas particular to a function, known as metadata-inherited context. A good place to start is the package world, where agents working with, say, Salesforce Agentforce or ServiceNow, inherit the user personas, sharing models, and field-level security that is already embedded in the software package. The AX then becomes an extension of the existing enterprise architecture, and is aware that, say, a sales representative can’t view payroll data, making the thought chain compliant with enterprise policies.

In good AX, trust is a sliding scale

Regardless of whether the enterprise chooses custom development or packaged software, a good AX also views the amount of trust a user gives to the agentic system as a nonbinary input. Rather, trust is a sliding scale, where the user can adjust the agent’s locus of control based on both task complexity and risk. Infosys defines three modes of agentic presence, moving from agents shadowing workflows to those that have almost complete autonomy, notifying the human only when necessary.

• Watch mode or shadowing. Here, the agent observes human workflows and learns the physics behind business processes, suggesting optimizations without acting.
• Assist mode or copilot. Here, the agent generates drafts, plans, and summaries, but requires explicit human-in-the-loop approval for every outbound action.
• Autonomous mode or digital labor. Here, the agent executes tasks within predefined guardrails, notifying the user only when exceptions are triggered, such as an invoice discrepancy that exceeds a 5% threshold.

When things go wrong, describe it clearly

Another innovation we are working on with clients is the situation brief. In most implementations of AX, the real problems occur when the AI doesn’t know what to do and must tag a human to act instead.

Instead of just overloading the user with a raw chat transcript of proceedings, good AX hands over the reins through a condensed, well-formulated, and high-impact summary of the story so far. In this way, human-agent collaboration is enhanced, especially in complex workflows that involve multiple agents.

The situation brief puts humans and agents on the same page so that the human doesn’t duplicate unnecessary work. The agent should also give a clear reason why it has stopped mid-flow — for example, it reached a credit limit — before providing a recommended next step so that the human can jump in when they are needed.

Multiagent AX, from directing to conducting

In complex workflows, there isn’t just one agent acting, but a mesh of specialized agents, each with its own goal and specific tasks. The AX challenge here is to overcome orchestration fatigue, where, say, a procurement agent, legal agent, and logistics agent all require user validation at once. In this situation, the experience becomes a bottleneck and humans become frustrated.

Good AX enables swift conflict resolution here. For instance, if two agents propose conflicting actions based on different data siloes, so that a logistics agent wants to ship the product now, but the finance agent says there’s a credit limit that’s been breached, the AX must surface this clash as a single decision point for the user, rather than two separate alerts.

Another good AX design consideration is the lead agent paradigm. Here, to simplify the interface, a coordinator agent acts as the single point of contact for the user, hiding the complexity of the underlying subagents.

Finally, we recommend that organizations creating their agentic enterprise use cross-agent lineage in their AX design. This means that the thought or reasoning trace also provides evidence of how information has been passed from one agent to another, ensuring the user can easily see the chain of custody for a specific piece of data.

The future of AX

The goal of interface design is to create a flow that is so intuitive and perceptive that agents transition from actively interacting with the user to a state of passive oversight.

That chat interface that enabled the employee to update their personal information and pension should all be available on a single chat window, with the system behind the scenes pulling data from across the enterprise and agentic know-how redefining the role of the human operator.

By leveraging thought and reasoning traces for transparency, and metadata-inherited context for safety, notifications from the system aren’t just alerts but pivotal to the success of the workflow, where the user is the final arbiter and orchestrator.

This then represents the ultimate realization of the agentic enterprise, a world where software has the momentum to act, but humans retain the sovereign right to lead.