AX: The Rise of Agentic Experience

01

01 — Extending UX for the AI Age

AX is not a replacement for UX but an evolution of it: the move from interface design to relationship design, for software that listens, remembers, and acts.

AX is not a replacement for UX, it's an evolution of UX. The core principles of UX still matter: understanding user goals, mapping intent, designing clear flows. AX extends that foundation into a new era where software collaborates with users. It's a new frontier of UX for software that listens, remembers, and acts. You still need empathy and structure, but now you also need initiative, judgment, and trust.

A product with memory, initiative, and judgment is a collaborator not a tool. And collaborators don't live in workflows, but they exist within the context of relationships, both individually and organizationally. That's the shift.

We’re moving from interface design to relationship design

From static affordances to dynamic partners that help users reach goals. Most UX patterns were designed for a world where every click, text field, and scroll were defined as part of a fixed system, meant to guide users on rails to their end state.

Now, not only can it gather and remember context, it can act on it in ways we didn't explicitly ask for. If we don't rethink how we design that power, we risk creating agents that feel clumsy and controlling. And once you lose trust, you don't get it back.

The idea of a product relationship isn't new. Every company had a slide about loyalty, trust, and connection. But the infrastructure to actually build that relationship has never really existed. What was once done through heartfelt ad campaigns, guerilla stunts, a punch-list of high profile influencers, or public persona CEOs, can now be done through the product.

Agentic AI systems make it possible to design software that builds memory, adapts continuously, and acts on your behalf with nuance and care. But they also require a new mental model. You can't bolt AI onto old UX patterns and expect magic. That's why we're proposing an evolution of the discipline: Agentic Experience (AX).

AX is about designing enduring, adaptive relationships between users and systems. It's about longevity more than novelty, focused on building software that becomes more useful, more personal, and more trusted with time.

The future is already here, it's just not evenly distributed yet. That's normal. But businesses are adopting new technology faster than ever before, and the teams that start designing with AX in mind now will shape entirely new categories.

Why Classic UX is Hitting Its Limits

Teams are shipping faster than ever, but something still feels off. Everyone's talking about AI, but few know how to apply it beyond a chatbot or autocomplete box. AX gives the expansion of UX principles a name and a lens to see the future through.

AX also brings clarity to trends you're already hearing about: natural language interactions, generative and invisible UI, personalized software. At LCA, our work with dozens of frontier companies has taught us that these aren't disconnected innovations – they're all part of the same shift. This is a new product mindset.

If you try to bolt AI onto old UX patterns, things can backfire. Traditional UX principles like reducing clicks, minimizing friction, and optimizing for speed were built for tools, not teammates. Apply those same instincts to agentic products, and you get agents that act too quickly, assume too much, and erode trust in the process.

Take “speed” as an example. In a classic app, fast load times and deterministic flows are signs of quality. But with agents, rushing from Point A to Point B can feel jarring if the user isn't aligned on the destination. Trust often requires dialogue before resolution. A quick answer that ignores context or skips consent can feel reckless. In the same way mobile-first redefined product design around ease and frequency, AX will redefine it around trust and alignment. That means a new sense of what “good” feels like.

Customers will still care about speed and predictability. But increasingly, they'll care more about whether a product knows them, learns from them, and helps them get where they're going, without starting over every time. As a product or business leader, your job is to design for that future.

That means asking two questions early and often: 1. How can we use AI to help users reach their goals faster than before? 2. How can we build trust so the product becomes irreplaceable? AX gives you the framework to answer both.

And while not every company is ready to implement AX today, every product leader should begin designing with AX in mind. As user expectations shift, the gap between “usable” and “agentic” will grow. What feels cutting-edge now will soon feel like table stakes, and what earns trust today will define category leaders tomorrow. This is your chance to lead.

02

02 — Why AX? Why Now?

Traditional UX hit a local maximum. Brains became cheap, features became commodities, and expectations skyrocketed — so software must move from usable tool to trusted teammate.

Traditional UX isn't broken, but it hit a local maximum. For years, it did exactly what it promised: helped users complete tasks faster, more predictably, and more intuitively, but now expectations have changed.

Today, users are used to the power of ChatGPT and other AI tools. They expect answers, in detail, and action taken on their behalf. They want technology that helps them achieve goals, not just narrow tools that they can use. And increasingly, they expect the product to help them do that, even if they don't know exactly how to get there.

Classic UX was designed for discrete tasks. AX designs for relationships.

Agentic Experience is the discipline of turning software from usable tools into trusted teammates: systems that remember, adapt, and act in ways that support a user's long-term intent. It anchors every interaction in the arc of a relationship.

But why now? What changed?

1. Brains became cheap. Large language models can now reason, riff, and recall on demand. When software can think, users expect it to collaborate. “Smart” is expected.

2. Features became commodities. Anyone can rent cutting-edge AI by the token. The real edge has moved up-stack: from what the model says to how the product behaves over time. Intelligence is accessible; trust and continuity are not.

3. Expectations skyrocketed. ChatGPT reset the baseline. Users now expect every product to be context-aware, conversational, and continuously improving. Static flows and brittle interfaces feel like relics.

Over the last two years, product headlines have started to converge around these changes: “Natural language as the new default input.” “Personalized apps and experiences.” “Interfaces that generate themselves.” “The new interface is no interface.”

These are all signals of a deeper shift toward interfaces that are no longer fixed. The product is now in motion, adapting to the user, not the other way around. Cool, but what's the catch? When software starts to act, learn, and initiate on your behalf, it enters a new contract. It stops being a tool and starts being an agent. And agents must be trusted.

That's the crux of AX. It's about trust. Trust that the system understands your intent. Trust that it remembers what matters. Trust that it will act in ways that help, and that you'll understand how and why. And once trust is lost, it's hard to win back.

So the real work of AX is designing trust into every layer: 1. Transparency in how the system learns and acts. 2. Thoughtfulness in how it balances initiative with user control. 3. Memories that deepen the experience without crossing the line.

This is the unifying principle. AX is a design framework that helps us make sense of these trends. It’s a way to build products that feel more like partners than portals and to compete on relationship depth, not just surface polish.

03

03 — The AX Evolution Curve

Products evolve from reactive assistants to collaborative partners across four levels — Conversational, Task-Aware, Personally Intelligent, Socially Embedded. You can’t skip steps.

If UX was about affordances, AX is about alignment. At the core of every great agentic experience is context: the ability of a product to understand who you are, what you’re trying to do, and how best to help you do it.

The more context a system has, the more useful it becomes. But more importantly, the more aligned it feels. The AX Evolution Curve maps how products evolve from reactive assistants to truly collaborative partners, by progressively deepening their understanding of the user and their world.

It's a curve for a reason: you can't skip steps. Each level builds on the last, compounding intelligence, context, and trust.

1. Conversational. Your product knows how to listen. It can understand natural language and follow basic instructions. Every interaction starts from scratch, but at least the system doesn’t feel rigid – you can just talk to it.

2. Task-Aware. It can now do things for you. It watches how you interact, what you click, when you hesitate, and adjusts accordingly. It's not truly remembering you yet, but it's learning how to be useful in the moment.

3. Personally Intelligent. Now it starts to remember your preferences, your tone, and your goals. The agent carries that knowledge across sessions. It doesn't just respond anymore; it helps, nudges, and adapts like a thoughtful collaborator.

4. Socially Embedded. The product is situational. It understands your team, your role, your shared vocabulary and cultural context. It behaves differently in a startup than in a law firm. It's part of how you and your people get work done.

As a product leader, you can't fake it. You can't jump from prompts to social context without building trust and memory first. You have to earn your way up. That's why AX favors small beginnings. Products that start with a tightly scoped, deeply understood user community have an advantage. They can embed real context early and grow outward from a place of alignment.

Broad, generic tools might reach more people faster. But AX-native products? They build moats through memory and cultural fit. In a world where anyone can rent the same models, trust is the differentiator. The next chapter breaks this down into actionable principles: how to design for memory, initiative, and alignment, without losing user trust along the way.

04

04 — AX Patterns

Six foundational interaction patterns behind agentic products that feel like teammates: Intent Handshake, Confidence Cues, Adaptive Canvas, Escape Hatch, Memory in Motion, and Generative Momentum.

AX is defined by behavior. You earn trust through clarity, responsiveness, and alignment over time, across tasks, and in every interaction.

Great agentic products feel like teammates.

They ask smart questions and adapt in real time. They remember what matters and know when to act or when to pause. This kind of experience is shaped by repeatable patterns of interaction that help teams deliver agentic behavior with precision and consistency.

In our work at LCA, we've come across quite a few of these patterns, and we've been lucky enough to pioneer some of our own. Here are six foundational patterns we've seen emerge across the most effective AX-native products. They aren't exhaustive, but they're reliable. Together, they offer a practical sample view toward designing products that feel alive, trustworthy, and worth coming back to.

Pattern 1 — Intent Handshake

Every great collaboration starts with shared understanding. So should every agentic interaction. The Intent Handshake is a short exchange that clarifies the user's goal before the system takes action. It might ask a follow-up question, offer scoping choices, or rephrase the task to confirm intent.

This avoids the trap of one-shot prompting, where agents jump to conclusions, act prematurely, and erode trust (while burning tokens). Instead, the handshake establishes a rhythm of mutual alignment. It says: “I'm listening. Let's get this right.” And once the user sees that the system understands them, they're more likely to lean in.

String is an agentic workflow builder from Pipedream. After you give it your task, String thoughtfully plays back what you asked along with a gameplan and a request for approval. This is building trust in a new relationship. We don't know each other yet, and String is building my confidence in its abilities to understand what I want and go execute. This is an opportunity to steer if it's wrong or approve if it's right. Win-win.

Pattern 2 — Confidence Cues

Smart isn't enough. If users don't know why an agent made a choice, they won't trust it, even if it's right. This is likely part of why most people still would likely prefer to consult with a trusted expert than ChatGPT.

Confidence Cues make reasoning visible. They expose sources, uncertainty, and logic in ways that are digestible but not distracting. This might look like inline “why” toggles, short rationales, or confidence levels that guide user judgment. These cues help users calibrate trust. They also make agents feel more human, not in personality, but in self-awareness. Without them, even the best outputs can feel generic, mysterious, or worse, suspicious.

Perplexity pioneered the sourcing behavior with a familiar footnote-like pattern. Not only can you verify sources at a glance or in-depth on the sources tab, but you can directly verify at the answer/text level, allowing you to verify if what's being said is legit. This follows the human behavior pattern we're used to, and helps build trust as your relationship with a product evolves.

Pattern 3 — Adaptive Canvas

Context changes, so your interface should too. An Adaptive Canvas reshapes itself in response to evolving tasks, surfacing the right tools, previews, or modes as the user moves forward. Instead of forcing people into fixed layouts, it adjusts based on situational needs.

Done well, this reduces friction and makes the product feel alive. Not distracting, which can be a tough line to toe. Importantly, a good adaptive canvas maintains spatial memory. It adapts without disorienting. It feels like the product is thinking alongside you.

Pattern 4 — Escape Hatch

Autonomy is powerful, but only if the user can opt out. Every agentic system needs obvious, usable escape hatches: ways to undo, revise, or override what the agent does. These can be confirmation steps, back buttons, or visible states that invite correction.

These features provide psychological safety. When users know they can recover from a bad suggestion, they engage more deeply. They’re willing to try more, explore more, trust more. Without escape hatches, even helpful initiative can feel like overreach.

Bolt, and many other vibe-coding tools, allow you to revert changes or undo with a simple CTA baked into the accordion tiles in the chat thread. Moreover, at any point, you're able to roll back what you've done via natural language, or even jump right into the code to change things yourself.

Pattern 5 — Memory in Motion

An agent that forgets isn't an agent, it's a parrot. Memory in Motion means recalling not just facts, but contextual relevance across time. Past decisions, preferred formats, recurring tasks – when surfaced at the right moment – can make an experience feel deeply personal and efficient.

This memory must be transparent and editable. Users should know what's remembered, how it's used, and how to revise it. Get this right, and you shift from convenience to continuity. The user stops starting over.

In ChatGPT, you can explicitly ask to add information to memory in the natural flow of the conversation. It’s like reminding a colleague or friend “don’t forget this, it’s important.” Moreover, you can modify how ChatGPT leverages those memories, and even surgically delete memories that are no longer relevant, or go full Men In Black and wipe ChatGPT’s memory completely.

Pattern 6 — Generative Momentum

Sometimes, the best way to clarify a thought is to see it half-written. Momentum begins with AI taking the first stab. Cooperative Drafting is a pattern where agents initiate a task – like composing a message, writing a query, or outlining a plan – and then invite the user to shape it. It’s more like co-authorship.

This creates momentum without locking users into fixed outputs. It also lowers the barrier to creativity, helping users articulate goals they couldn't have typed in a single prompt. It's one of the fastest ways to move from assistant to collaborator.

Each of these patterns brings the core principles of AX to life. They're architectural choices that you can layer, remix, extend. And as your product matures, these patterns become the scaffolding for relationship depth. They turn generic model outputs into durable value. And they help ensure that, as your agent gets smarter, your users stay in control.

AX is about re-thinking how your product behaves. These patterns are the place to start.

05

05 — Natural Language as the Interface

For forty years we taught people to speak computer; now computers are learning to speak human. Natural language becomes the universal translator between intent and action.

For forty years, we've been teaching people to speak computer, but now computers are learning to speak human. The shift to natural language has unlocked a level of intent that was previously too expensive to capture.

When someone says “schedule a follow-up with the design team for next week, but not Friday,” they’re expressing nuanced preference in a single breath. Building a traditional UI for that interaction would require multiple screens, dropdowns, and validation flows. Natural language collapses that complexity into conversation.

This isn't a replacement for all interfaces, but it's the fastest path to expressing complex, conditional, or contextual intent.

Where traditional UI optimizes for repeatability, natural language optimizes for expressiveness. And as AI gets better at understanding ambiguity, the cost of that expressiveness approaches zero.

The Modality Mix. Different inputs excel at different tasks. Voice is fastest for dictation and hands-free contexts. Touch remains unbeatable for spatial manipulation. Visual interfaces still win for data comparison and layout control.

But natural language emerges as the universal translator — the interface that bridges intent and action when the task is too complex, too novel, or too contextual for predefined controls. The real power comes from combining modalities fluidly. “Show me last quarter’s performance, but focus on the regions that missed targets” might generate a dashboard while simultaneously filtering and highlighting specific data points. AX allows for you to become the conductor of the interface.

Implications for Product Teams

This changes your design calculus. Instead of mapping every possible user path upfront, you design for intent recognition and graceful interpretation. Your information architecture needs to be machine-readable.

For product teams, this means rethinking feature discoverability. When users can describe what they want instead of hunting through menus, your job shifts from organizing options to teaching the system what's possible.

This is an example leveraging a more AI-native browser (in this case, Dia) versus a traditional publishing site that doesn’t allow for natural language search, does not have conversational UI, and is missing the essence of Agentic Experience.

If a user is thinking “who is injured on [insert favorite hockey team],” they should be free to explore that in the way they think — not be forced to follow traditional UX and site architecture norms that make people think like computers: NHL → Montreal Canadiens → Players → Injuries.

Where we’re seeing this applied first

Professional tools with high complexity and expert users will see the earliest adoption. Think legal research, financial analysis, or clinical decision support – domains where the cost of learning traditional interfaces is already high, and the value of natural expression is immediate.

Consumer products with high personalization potential follow close behind. Fitness coaching, travel planning, and creative tools – areas where every user's needs are meaningfully different, and the interface should adapt accordingly. The pattern is clear: natural language thrives where the intent is complex, the user is motivated, and the cost of traditional UI development exceeds the value it delivers.

06

06 — Generative UI as the Opportunity

Now that software can think, why design every screen in advance? Generative UI is about precision — interfaces tailored to the moment, generative within guardrails.

Static interfaces were built for a world where software couldn't think. Now that it can, why are we still designing every screen in advance?

Generative UI is about precision. Instead of building one interface that serves everyone poorly, you can build systems that generate interfaces tailored to the moment: the user's role, their current task, their available screen space, their expertise level, and their immediate context.

Windows, icons, and menus made sense when every interaction had to be explicitly designed and rigidly structured. But in an agentic world, interfaces can be shaped by understanding, not just layout.

The question isn’t “where should this button go?” but “what does this user need to see right now?”

The Predictability Problem. The most common criticism of generative UI is valid: users want consistency. Every time they open an app, they want to know where things are. Muscle memory matters.

But this assumes generative UI means arbitrary UI – it doesn't. The best generative interfaces are more predictable than static ones because they're contextually aware. Instead of showing you the same overwhelming dashboard every time, they show you what matters for your current situation. Instead of burying relevant actions in nested menus, they surface them prominently.

The trick is generative within guardrails. Core navigation remains stable and primary actions stay consistent, but the content, layout, and secondary features adapt based on what the system knows about your needs.

When to Generate, When to Stay Fixed. If your product can be entirely expressed through static UI, it's probably not defensible in an AI-native world. Static interfaces work for simple, predictable tasks, which are exactly the kind of work that AI can automate away entirely.

The products that survive will be the ones where generative UI isn't just an option, but a necessity: when context varies significantly (role-based dashboards, device-responsive layouts); when information density is high (medical records, financial data, research tools); when user expertise ranges widely (beginner vs. power user modes); and when task complexity is unpredictable (investigative workflows, creative projects).

The areas where static UI persists will be narrow and specialized: where physical safety is paramount (medical devices, industrial controls); where regulatory compliance demands consistency (financial trading terminals, aviation systems); and where muscle memory creates competitive advantage (professional tools where speed = revenue). But even these domains are under pressure. If you can map every user need to a predetermined interface, you’re building something that AI will replace, not enhance.

Discoverability in a Generated World. If the interface changes based on context, how do users learn what’s possible? This is where conversational discovery matters. Instead of exploring menus, users can ask: “What can I do with this data?” or “Show me advanced options for video editing.” The system becomes self-documenting through dialogue. This also means your product’s capabilities become your interface. Documentation really matters.

07

07 — Invisible UI as an Option

The best technology disappears — not literally, but cognitively. When software understands intent and acts autonomously, explicit interaction becomes the exception, not the rule.

The best technology disappears. Not literally, but cognitively. It becomes so seamlessly integrated into human behavior that its operation feels natural.

The smarter the machine gets, the lighter the interface — rising from terminals to heavy GUIs, then melting into plain language and finally becoming ambient.

We're approaching that threshold with agentic systems. When software can understand intent, maintain context, and act autonomously, the need for explicit interface diminishes. You don't need to see a dashboard if the system proactively tells you what's important. The interface emerges at the moment of interaction and dissolves when the task is complete.

The Industries Ready for Invisible. Some domains are naturally suited for interface minimization. Logistics and Operations: warehouse workers don't want to stop and interact with screens. They want systems that anticipate needs and communicate through audio, haptics, or peripheral vision. Inventory management, for example, should be conversational. Healthcare: clinicians need information, not interfaces. The best electronic health record is one that surfaces relevant patient data exactly when needed, without requiring explicit queries. Imagine diagnostic support that nudges suggestions rather than demanding attention. Financial Services: consider a portfolio management flow that adjusts automatically based on market conditions and personal goals or banking that handles routine transactions invisibly while flagging only the decisions that require human judgment.

Competitive Implications. When interfaces become invisible, what's your differentiation? It has to be the level of your understanding of the customer and the quality of your product's judgment. This is where brand gets interesting. In a world of invisible interfaces, trust becomes everything. Users can't evaluate your product by looking at it – they have to experience its behavior over time. AX is a way to showcase your brand values and demonstrate judgment through product.

The companies that win in an invisible UI world will be those that understand their users' workflows so deeply that the software anticipates needs before they're consciously recognized. This requires cultural fluency, behavioral insight, and domain expertise that can't be copied overnight.

The Gradual Fade. Interfaces will fade gradually, becoming smarter about when to surface and when to stay hidden. The companies that start building for this future now – designing systems that work with minimal interface, optimizing for voice and gesture, building trust through consistent behavior – will have the advantage when the transition accelerates.

Your job as a product builder is to make interfaces optional over time, building systems so intelligent and reliable that users choose to interact less visibly because it's simply the better model. This is the ultimate expression of AX: technology that understands you well enough that explicit interaction becomes the exception, not the rule.

08

08 — The 8 AX Principles

Behavioral heuristics for building agents people trust: taper transparency, prompt both ways, clarify before committing, push back, stay multimodal, loop in experts, build memory, and personalize.

Agentic products act with intent, evolve with use, and earn trust by behaving like competent collaborators. This section outlines key principles that distinguish shallow AI features from mature AX systems. Think of these as behavioral heuristics for building agents people trust. These aren’t rules to be rigidly followed, but they’re helpful modes of interaction that elevate the relationship between user and product.

1. Transparency, Tapered Over Time. In the early days of working with someone new, the best collaborators over-communicate. They show their thinking, surface their reasoning, and earn your trust by exposing their process. Agents should do the same. Early AX should lean toward transparency: full rationale, visible sources, and clear decision trees. Not to overwhelm, but to reassure and say: “here’s how I got there.” Over time, as trust builds, verbosity should fade. Mature AX knows when to simplify, when to summarize, and when to step back. It defaults to streamlined, confident responses, while still making depth available on demand. Transparency isn’t static. It adapts to the arc of the relationship.

2. Prompting Goes Both Ways. A passive assistant waits for instructions, while a great teammate gets ahead of them. Agentic systems should ask clarifying questions, surface uncertainties, and propose smart next steps. They should engage and nudge instead of simply reacting. This kind of back-and-forth turns software from a servant into a strategic partner. It reduces misalignment, increases shared understanding, and builds momentum without micromanagement. Prompting is not a one-way street. In AX, dialogue is design.

3. Clarify Before You Commit. Initiative is powerful, but commitment requires care. Before taking high-stakes actions like sending messages, updating systems, and triggering workflows, agents should pause and confirm intent. This is what's known as intelligent friction: a moment of alignment that protects the user's time, reputation, and trust. It also signals respect. The agent doesn't assume authority, but checks in unless explicitly told otherwise. That alone builds confidence.

4. Pushback Is Professional. Great collaborators interpret intent and push back when it matters, rather than just following instructions. The same should be true for agents. If the user asks for something suboptimal, a mature system might say: “Here’s what you asked for. But here’s what I’d recommend instead.” Done well, this shows the agent is thoughtful, not just obedient. But it requires tact. Pushback without tone awareness can feel arrogant or jarring. Get it right, and your product becomes more than helpful – it becomes respected.

5. Multimodal for the Moment. Clarity is the goal, but the medium is a tool. Agentic products should fluidly shift between text, voice, visuals, summaries, and interactive demos depending on what the moment calls for. Explaining a concept? Maybe show a diagram. Delegating a task? Perhaps a short voice confirmation is faster. AX isn’t about forcing users into a specific modality. It’s about choosing the one that best supports understanding. This flexibility makes agents feel human not in personality, but in responsiveness.

6. Loop In Other Experts. No one wants a know-it-all, not even in software. Mature AX systems should know their limits, and know when to hand off. That might mean escalating to a human, calling in a specialized sub-agent, or pulling from another app's API. This is the beginning of multi-agent collaboration: agents acting as orchestrators, not silos. Like a good project manager, they don't try to do everything. They assemble the right team. The future isn't one agent, but many, working in sync.

7. Learn Context, Build Memory. Repetition kills trust. If a user has to remind the system of their preferences, tone, workflow, or goals every time, they won't stick around. Agentic systems should accumulate memory across interactions, ethically, transparently, and with boundaries. The user should always know what's remembered and how to shape it. Done right, memory unlocks compounding value. Every project feels more tailored and attuned. This is where agents shift from being efficient to being indispensable.

8. Personalization Is the Moat. Over time, a great agent should feel like it gets you. It knows your voice, your pace, that “keep it brief” means three slides and a Notion summary. That “next week” usually means Monday, unless there's a holiday. That kind of personalization can't be cloned. It's the product of time, trust, and accumulated context. And in a world where every feature can be copied overnight, that relationship becomes your moat. You're not just building a product. You're building familiarity. And that's very hard to compete with.

Trust is the Foundation

If it isn't already clear: in an AX world, trust isn't a feature. It's the product. In AX systems, trust is built over time through consistent, thoughtful behavior. Software used to wait for instructions. Now, it interprets intent, takes action, and sometimes makes decisions users didn't explicitly request. That power creates both incredible utility and deeper risk. Trust in this context is less about reliability in outputs and more about clarity in judgment, humility in action, and consistency in behavior.

Trust grows in four stages: Stage 01 Functional Trust – can it complete basic tasks reliably? Stage 02 Contextual Trust – does it understand nuance, preferences, history? Stage 03 Judgment Trust – can it make good calls in ambiguous situations? Stage 04 Advocacy Trust – will it act in my best interest, even when the incentives misalign?

Break that trust, and the whole experience collapses. The fastest way to do that? Overconfidence. Inconsistency. Taking action beyond what's authorized. Optimizing for company metrics over user success. Mishandling complexity when a handoff to a human would've been better. In short: acting like you know more than you do, and pretending you don't need help.

In a world of commoditized AI, trust becomes the moat.

It's the thing users are least willing to rebuild from scratch. Features are replaceable, but relationships are not. Build systems that are transparent, humble, and dependable, and users will happily stick around. The catch? The agents we trust most are the ones that verify before acting. The ones that admit they don't always know. That thoughtfulness is what earns the right to assist again tomorrow.

09

09 — The Business Case for AX

Relationships are the product and trust is the only moat that compounds. Agentic experiences get more valuable with every interaction — but AX is a full-stack transformation, not a feature.

As large language models become table stakes, and AI becomes the default layer between product and user, the differentiator is no longer what the model can do, but how the product behaves. In an AI-native world, relationships are the product and trust is the only moat that compounds.

When users interact with an agent, they're not judging screens on pixel polish alone. They're evaluating judgment. They're asking: Does this system understand me? Does it learn from me? Can I trust it to act in my interest? The answers to those questions determine whether a user sticks around, or quietly churns to something that feels more aligned. AX is about alignment over time. It's not only about the first interaction, but about interactions number 10, 20, 50, and beyond. Where traditional UX optimizes for task completion, AX optimizes for relationship depth.

Agentic experiences get more valuable with every interaction. This compounding behavior is strategic gold for a business. 1. Context through Conversation: the more a product remembers and adapts, the harder it is to abandon.

“… personalization led to a 180% increase in app sign-ups, a 190% increase in retention, and a 200% increase in engagement …” — Twilio

2. Increased Efficiency: users reach goals faster.

“Eaton's generative-AI workflow slashed new product design time by 87 percent, taking a process that used to run 16 weeks down to roughly two weeks.” — aPriori

3. Better User Understanding: continuous context collection creates a nuanced view of user behavior and preference, unlocking more personalized recommendations.

“Spotify credits its 1,000%+ decade-long growth in user base and revenue in large part to sophisticated, continuously improving personalized recommendation engines.” — HBR

4. Differentiation Through Behavior: when every product uses the same models, how your product behaves becomes your brand.

As AI products saturate the market, trust will become the most meaningful differentiator. Agents that overstep, confuse, or break alignment will lose users. Agents that respect boundaries, show their work, and improve over time will win long-term loyalty. This is the flywheel of AX. AX is how that trust is built.

You don't need to rebuild your product overnight, but you do need to start climbing the curve. The winners in the AI era won't just be the teams with the best models or biggest datasets, but they'll be the ones that build the best relationships. And relationships are built the same way they always have been: through memory, initiative, presence, and care.

Implementation Reality Check

Most teams underestimate what it takes to build a great agent. They treat it like a UX feature or a prompt wrapper. But AX is a full-stack transformation — new skills, new metrics, new infrastructure. If you don't acknowledge that up front, your implementation will stall before it ever delivers meaningful value. This is your reality check.

AX requires different capabilities than traditional product development. 1. Conversational design is not just UX. It's about dialogue flow, behavioral nuance, and trust scaffolding — a different craft entirely. 2. Agent engineering isn't API plumbing. It demands prompt architecture, context management, fallback logic, and behavioral state handling. 3. Better user understanding shifts from clicks and funnels to relationship quality: how often do users engage voluntarily? How do their trust levels evolve over time? 4. Systems integration must support agents that orchestrate across tools, preserve context, and recover from partial failure — gracefully and in real-time.

The roadmap is longer than most teams think. Don't try to boil the ocean. Competitive differentiation happens by staging your buildout. Months 1–3: single workflow with conversational overlay — prove it adds value without harming flow. Months 4–6: cross-workflow memory and coordination — let the agent carry context and suggest next steps. Months 7–9: adaptive personalization + behavioral intelligence — this is where relationship depth begins. Months 10–12+: cultural fluency and community alignment — the final leap into durable competitive advantage.

Watch for common failure modes: 1. Over-conversational — forcing chat where a button would do. 2. Under-contextual — shipping agents that don’t understand user patterns. 3. Interface destruction — breaking spatial memory for the sake of “smartness.” 4. Trust erosion — agents that guess confidently, never escalate, or offer no way to recover.

The key insight: AX success is less about model sophistication and more about organizational readiness.

Your company needs to understand what product lessons to take into the AI age, and what frameworks like AX are necessary to achieve. If you can't sustain a multi-phase build, start smaller. But if you're in — be honest about the depth of investment it requires. The moat is real. But so is the cost of building it.

10

10 — Potential Futures

Four competing futures for who owns the trust layer: Bring Your Own Agent, the agentic browser, OS-level AI, and vertical AI companions. Each makes AX thinking more urgent.

The race to build agentic products isn't just about better features or smarter models. It's a race to earn the deepest, most durable relationship with the user.

Today, trust is earned piecemeal, one product at a time. Each app tries to build its own bond, its own memory, its own loop. But tomorrow, trust may centralize. Instead of forming relationships with dozens of tools, users may rely on a single agent to manage those relationships on their behalf.

The shift from product trust to agent trust is already underway. And it raises a critical question: which layer of the stack gets to own the relationship? Below are four competing futures that represent different answers to that question. They’re not mutually exclusive, but they are mutually competitive. Each one is a strategic attempt to win the trust layer. And each one makes AX thinking more urgent.

1. Bring Your Own Agent (BYOA). In this future, users don't form deep relationships with each individual app. Instead, they form one primary relationship with their personal agent, and that agent interfaces with everything else. The agent becomes the user's representative, selectively sharing data, translating goals, and filtering noise. Apps become utilities, not destinations. The trust contract moves upstream: win the agent, or you don't get access to the user at all.

This changes how companies design product experiences. Instead of optimizing for direct user engagement, they'll optimize for agent collaboration: exposing APIs, memory models, and preferences in a way agents can work with. Success is no longer measured by DAUs, but by whether a user's agent chooses to include you in the flow. The relationship is with the agent, and only the most trusted, aligned agents will win.

2. Agentic Browser. Another future is where the browser evolves into the trusted layer. It already knows your search history, your shopping preferences, your bookmarks, your logins. Now, imagine that context being unified into an agentic layer that rides shotgun across the web: filtering content, drafting responses, summarizing pages, and orchestrating workflows between apps. In this model, the browser becomes the most trusted tool in your life, not because of AI novelty, but because it sits at the nexus of everything you already do. It earns trust by making every other tool feel smarter and less demanding. This reframes the browser war as a trust war: who helps you navigate, protect, and leverage your web life best?

3. OS-Level AI. Apple, Google, and Microsoft are likely betting big on OS-level agents. In this scenario, your operating system becomes your agent. It sees your calendar, your files, your location, your camera roll, your voice. And it uses that information to offer coordination across devices, contexts, and tasks. The promise here is tight integration and effortless assistance. The OS already owns the trust layer in many ways. People are more likely to grant permissions to Apple or Google than to a random app. But earning behavioral trust – understanding what to do, when to help, and how not to overstep – requires a shift from passive assistant to intelligent teammate. OS-level AI could win simply by being invisible, helpful, and always there.

4. Vertical AI Companions. Another possibility is that trust fragments along vertical lines. You don’t have one agent, but rather many, each deeply embedded in a specific domain: a health agent that understands your body and history; a finance agent that knows your spending patterns and goals; a creative agent that helps you write, design, and think. Each one wins trust by going deep, not wide. This model favors startups and specialists: those who know the nuances of a particular industry and can build agents that act with real judgment. The advantage here is precision and reliability: users may be more willing to trust a domain-specific agent that “gets it,” rather than a generalist that tries to do it all. But even here, the core battle is the same: who earns the right to remember, act, and advise?

11

11 — Conclusion: A New Discipline for the AI Age

Features can be copied and models rented, but trust is earned and compounds. AX is how today’s interface becomes tomorrow’s relationship — and relationships are where margin lives.

All of these futures, from BYOA, to agentic browsers, OS intelligence, and vertical AI, share one thing: they're all competing to win the relationship layer.

Features can be copied. Models can be rented. But trust is earned. And once it's earned, it compounds. The interface of the future is a collaborator. And your product's long-term advantage will be that trusted relationship.

Agentic Experience isn't a trend. It's a new discipline for a new kind of software. One that turns tools into teammates. It doesn't reject UX, but adds the necessary thinking to build on top of those principles and into the new paradigm.

AX is how today’s interface becomes tomorrow’s relationship. And relationships are where margin, retention, and sustainable growth live.

This handbook is the first step. The rest is what you build from here.

Who is LCA?

LCA is the design firm for the AI Age. Over the last few years, we've helped over 100 brands turn tools into teammates and products into relationships. We've designed and built agentic experiences alongside companies like Character AI, Jasper, Bolt, Paramount, Dropbox, Grammarly, Slack, and dozens of others, pushing the edge of what software can feel like and how trust is earned in the AI Age.

This handbook is just the beginning. If you're someone building an agentic product, feature, assistant, or platform with the belief that the relationship layer can be your edge, you're on the right path. We'll continue to help guide ambitious leaders on this journey, and are always excited to connect with new brands. If you want to build a relationship with the firm behind this handbook, send us an email at theo.tabah@latecheckout.studio. We believe great relationships start with a conversation.

Stay Awhile. — Theo Tabah, CEO at LCA, and Ed Landon, GM at LCA. This handbook was a collective effort by the team at LCA, with special thanks to our incredible designers and everyone who helped bring this to life.