AX: The Rise of Agentic Experience · Edition 02

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.

The 8 AX Principles, at a glance

A summary card listing the eight principles in order: 1. Transparency, Tapered Over Time; 2. Prompting Goes Both Ways; 3. Clarify Before You Commit; 4. Pushback Is Professional; 5. Multimodal for the Moment; 6. Loop In Other Experts; 7. Learn Context, Build Memory; 8. Personalization Is the Moat.

Text shown in figure

01 Transparency, Tapered Over Time — The agent keeps track, nudges next steps, and improves over time. You're never “starting over.” 02 Prompting Goes Both Ways — It senses, infers, and chooses actions the designer didn't have to script line-by-line. 03 Clarify Before You Commit — Preferences, patterns, even team norms are remembered and reused, no more re-explaining yourself. 04 Pushback Is Professional — Key metric shifts to retention, satisfaction with decisions, and how much autonomy you hand over. 05 Multimodal for the Moment; 06 Loop In Other Experts; 07 Learn Context, Build Memory; 08 Personalization Is the Moat — each captioned, as printed, “The agent shows its work early, then tapers as confidence grows, just like a human teammate.”

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.