Trust is what users develop when they can predict, interpret, and act on agent behavior. As multi-agent systems evolve from federated assistants toward unified operating layers, the experience layer needs a discipline that scales with the platform.
Mental model alignment is that discipline. The foundation users need to make sense of what agents are doing, and the architecture designers need to make orchestrated multi-agent systems coherent across the product.
AXA informs the experience architecture for orchestrated multi-agent interactions. It synthesizes what users tell us about how they perceive, interpret, and build trust with agent behavior across conversational and non-conversational patterns — and gives design, product, and engineering a research-grounded vocabulary for building that experience deliberately.
The framework surfaces a foundation (mental models) and three design dimensions: interactions, agent postures, and orchestration. Together they elaborate what the research suggests product, design, and engineering need to ship agentic experiences that are coherent, predictable, and trustworthy at platform scale.
Mental models are users' internal beliefs about how a system works. They are not a research curiosity. They are the foundation that determines whether agent behavior is legible, predictable, and trustworthy enough to act on.
Three hierarchical layers describe what users believe: Outcome, Causal, Interactional. Each layer answers a different question. Each layer breaks in a different way. Each layer demands a different design discipline as agents grow more autonomous and more orchestrated.
A year ago, users described AI as a tool. They gave it instructions, it executed. Today, they describe it as a collaborator. They set goals, the agent participates in achieving them. The mental model framework has refined alongside what users are telling us.
Outcome alone was enough when users thought of AI as a tool. As agents took on more autonomy, Causal became essential: users tell us they have to understand how the agent is reasoning to confirm, modify, or override it. As agents started acting as teammates, Interactional became the whole game: rhythm, tone, recovery, the feel of working alongside something — the things users name when they describe what makes the experience work or fall apart.
Trust is built bottom-up. Outcome is the ground. Causal is the structure. Interactional is the bloom of trust that grows when both hold.
Interaction patterns evolve across three tiers: Automation, Augmentation, Agency. Each tier changes what users expect, which mental model layer dominates, and what design has to do to keep trust intact.
The framework gives teams a shared vocabulary for matching agent behavior to user expectation at each tier. It shapes how the user experience is designed, how transparency is calibrated, and how trust is built as autonomy grows.
Users don't track agent identity the way the system does. They experience shifts in tone, authority, and focus as the work unfolds — and the design challenge is making those shifts feel coherent rather than fragmented. Agent Postures are the five ways an agent can show up, the underlying structure designers work with to construct that coherence.
Each posture has a defined role, autonomy level, emotional fluency, and strategic value. They're the vocabulary product, design, and engineering use to design how an agent shows up — so the experience reads as one thing even when many agents are involved.
The framework only matters if it's anchored in who actually uses it. Human Personas are the research-grounded counterpart to Agent Postures: the people on the other side of every orchestrated experience. Without them, agent design becomes speculation about behavior nobody has observed.
Teams can maintain libraries of research-grounded personas trained on customer transcript data. They aren't static documents. They're synthetic collaborators teams can talk to, used to evaluate prompts, test tone, and surface trust gaps before development.
Because the personas are GPT-based, they function as synthetic design partners. Teams can talk to them directly, prompt them with workflows, and watch how they respond. That makes them especially useful for testing agent behavior against the mental models the personas embody.
If a frontstage agent confuses a user's causal model of how a workflow actually works, the persona will say so, in language and frustration patterns derived from transcript data. If the agent's tone breaks the persona's interactional expectations, that breakage is observable before any production code ships.
The personas don't just describe users. They let teams pressure-test agent design against the Outcome, Causal, and Interactional layers, the same trust mechanics described in Pages 02 and 03, using a partner who responds the way a customer would.
An orchestrated experience runs on different triggers (something happened, a schedule fired, a user asked) and different agent postures (one in charge, others joining, watching, recovering). These patterns describe the shape of that experience from the user's vantage — who initiates it, where it goes, how it ends.
The framework decomposes orchestration into three layers (User Interaction, Agent Frontstage, Agent Backstage) and three interaction patterns (Reactive, Proactive, Hybrid). Each pattern shapes the user's mental model differently, and each requires different orchestration choices to earn trust.
A framework only matters if it lands in the work. AXA isn't a separate artifact teams reference once and set aside. It integrates into four existing practices: prompt architecture, the design system, design practice, and product development.
Each integration point answers a specific question: how do agent behaviors stay consistent, how does design signal agent identity, how does the design org think in systems instead of pixels, and how does this become how we ship. Together they describe what it looks like for AXA to become part of how an org builds.