We’ve been focused on architecting systems that act on behalf of customers. That shift didn’t come with templates or best practices. Our design perspective is taking shape through iteration, system constraints, and close observation of how users respond when agent behavior doesn’t match their expectations.

In agentic systems, that behavior is defined by prompt architecture.

AI features are being added to nearly every product today. Some function as useful tools, some as small chat widgets, and some as full agents acting on behalf of the user. When that shift occurs, the nature of design work changes. It moves from creating screens and turn-by-turn scripted conversations to shaping agent behavior through prompt architecture. Prompts form the behavior layer, and without them, the experience itself is not truly being shaped.

When working with large language models, it is difficult to keep interactions from breaking. The model will interrupt, miss emotional cues, or forget what was said earlier in the conversation. These breakdowns are not just model issues. They come from gaps in prompt architecture — places where behavior was left undefined.

It often shows up when a voice agent cuts someone off mid-sentence, when a chat assistant misses frustration in the user’s tone, or when an agent seems to forget what was said earlier. These breakdowns are rarely just about the model itself. More often, they reflect gaps in prompting where the agent’s behavior was left underspecified.

These challenges are not solved by UI polish. They come down to behavioral alignment. Factors like detecting frustration, deciding when to escalate, repairing misunderstandings, building trust through timing and tone, or pausing instead of pushing ahead cannot easily be captured in a wireframe. They need to be addressed through prompt architecture, otherwise the agent is left to improvise in ways that may not match user expectations.

When we think about how users experience an AI system, we map across three levels of mental model alignment:

• Outcome — What the person is trying to accomplish. Did the thing happen? Was it worth their time?
• Causal — How the person thinks the system works. Can I trust this agent? Does it remember what I told it? Will it escalate if I need it to?
• Interactional — What it feels like to interact with the agent. Did it listen? Did it cut me off? Did it sound competent? Did it stay with me when I needed help?

Defining prompt architecture is how we prevent misalignment. It gives structure to agent behavior by specifying what the system pays attention to, what it acts on, how it handles uncertainty, and when it needs to escalate or defer.

Principles That Shape the Architecture

We’ve learned these principles by working on a voice agent, where the interaction is entirely driven by what the agent says, how it sounds, and how it responds. The voice is the interface. Every turn has to be designed with clarity, pacing, escalation, and recovery in mind. There is no visual fallback, no tap target to redirect the user.

But these same behavioral decisions apply across agentic systems, even when the format changes.

These are the dimensions we focus on when working with large language model–driven agents. Some echo classic conversation design, but the difference is that LLMs are not deterministic. They improvise. Without intentional guardrails, behavior will drift in ways that may sound plausible but fail to meet user expectations.

• Designing flows, not fragments.
  LLMs generate output one turn at a time, but each response depends on the turns before it. If prompts are designed only in fragments, coherence breaks down. Defining the full arc including greetings, confirmations, next steps, and closure, creates the scaffolding that keeps the conversation from drifting.
• Adjusting tone by context. LLMs can shift tone dynamically, which is powerful but risky. Without guidance, the agent may swing from overly formal to overly casual in the same interaction. Prompt guardrails are needed to anchor tone to the user’s situation, whether the interaction is routine, corrective, or high stakes.
• Building recovery paths.
  LLMs frequently misinterpret intent, over-generate, or lose track of context. Without recovery guidance, they tend to loop or guess. Prompts can direct the agent to clarify, confirm, or gracefully move on. This is a critical shift from IVR design, where recovery is scripted; here, it has to be adaptive but still intentional.
• Defining escalation rules.
  Escalation in LLM systems cannot be reduced to keyword matches. It requires interpreting clusters of phrasing, repeated refusals, or emotional signals like frustration. Prompts and supporting classifiers need to define how these signals are recognized and what action to take. Done well, escalation feels timely rather than arbitrary.
• Providing trust signals.
  Because LLMs produce fluent language even when wrong, users can be misled if prompts don’t enforce confirmation and honesty. The architecture has to specify what details must be confirmed, when reassurance is needed, and how to set clear boundaries around what the system can and cannot do.
• Setting pacing and rhythm.
  In voice, pacing determines whether a user feels interrupted or ignored. In chat, pacing affects readability and the perception of attentiveness. LLMs can generate instantly, but design decisions about pauses, chunking, and timing shape whether the interaction feels rushed, slow, or balanced.

Together, these principles show why prompt architecture is different from scripted design. With scripted IVR, behavior is predetermined. With LLMs, behavior is probabilistic. The role of prompt architecture is to turn that probabilistic output into something structured, consistent, and aligned with human expectations.

If we don’t define behaviors intentionally, the agent will default to what the model assumes is helpful. That may be plausible. But it won’t always be usable.

What follows is the working structure we are developing to support this alignment. It is made up of eight components that help us define, implement, and test prompt architecture as part of real-world human-agent interaction.

Inside the Framework

To support consistent and trustworthy agent behavior, we’re developing an internal framework made up of eight components. Each one plays a different role in how prompts are structured, implemented, and evaluated across real scenarios.

Together, they help us align the agent’s behavior with how users think, what they need, and how the interaction feels in practice.

The components are:

1. Prompt Construction
2. Conversation Flow
3. Utterances
4. Voice and Tone
5. Fallbacks and Errors
6. Edge Cases and Tests
7. Inputs and APIs
8. Prompting Style

The rest of this article walks through each one — what it’s for, how we use it, and why it matters.

1. Prompt Construction

The first component of the framework is Prompt Construction. This is where we define the building blocks of a prompt and make sure each one is aligned with a layer of the user’s mental model. The goal is to give the agent clear instructions about what it can do, what it should prioritize, and how it should behave across the interaction.

Each part of a prompt serves a different alignment function:

• Causal alignment: Persona, role clarity, and scope. The prompt specifies the agent’s role, its authority, and the boundaries of what it can handle. It defines when to trust system tools, when to ask the user for verification, and when to stop and escalate.
• Outcome alignment: Objectives and expected results. The prompt makes clear what the user should expect from the interaction, confirms critical details, and communicates next steps. It reassures the user if the task cannot be completed.
• Interactional alignment: Tone, pacing, and repair. The prompt guides how the agent should sound, how it should detect and respond to emotion, and how it should recover from interruptions, silences, or errors.

By distributing these responsibilities across layers, prompt construction prevents misalignment. It ensures the agent knows not only what tasks to complete but also how to handle uncertainty, how to maintain user trust, and how to close the interaction cleanly. Without this structure, agents tend to default to the model’s generic behaviors, which may be plausible but rarely feel aligned with what people actually expect.

2. Conversation Flow

The second component of the framework is Conversation Flow. Where Prompt Construction defines the parts of an instruction, Conversation Flow lays out the sequence. It describes what happens turn by turn, how system actions are woven into the exchange, and how the interaction reaches closure.

The goal is coverage. Every step has to be intentional, from the first greeting through record matching, confirmation, task execution, and closing.

Conversation Flow is also where we ensure alignment across disciplines. Design, engineering, and QA all work from the same blueprint so that the intended behavior, the system calls, and the evaluation criteria match. This prevents the common failure where a flow looks complete in design but falls apart in implementation.

Most of what we specify here supports causal alignment — making sure the user’s sense of how the system works matches the actual order of events. It also contributes to interactional alignment by preventing awkward silences or abrupt jumps. When the flow is clear, the user can follow the arc of the interaction and understand what the agent is doing at each step.

3. Utterances

The third component of the framework is Utterances. While Conversation Flow maps the sequence, Utterances bring the flow to life through example dialogue. These examples give shape to how both the agent and the user might speak at each step.

The purpose is not to script the agent word for word. It is to provide reference points that make tone, pacing, and clarity concrete. A well-chosen utterance helps writers, engineers, and testers align on what “good” sounds like, and it sets expectations for how the agent should handle variations in user input.

This component leans heavily on interactional alignment. It ensures the agent’s responses feel natural, avoids robotic phrasing, and reinforces empathy when the task carries emotional weight. It also supports causal alignment by confirming that the language matches what the system is actually capable of doing.

4. Voice and Tone

The fourth component of the framework is Voice and Tone. While Utterances show what the agent might say in context, Voice and Tone define how it should sound across scenarios. This is where we set anchors for warmth, professionalism, empathy, or efficiency depending on the situation.

Voice and Tone also help us avoid mismatches that damage trust. For example, a highly empathetic phrase offered during a routine booking can feel insincere, while a flat, transactional tone during a stressful failure can feel dismissive. Calibrating tone to context is what allows the agent to feel appropriate rather than generic.

This component is primarily about interactional alignment — making sure the user experience feels coherent and emotionally grounded. It also contributes to outcome alignment by reinforcing clarity at key points, such as confirming a booking or closing the call.

Fallbacks and Errors

The fifth component of the framework is Fallbacks and Errors. No matter how carefully prompts are constructed, users will say unexpected things, APIs will fail, and recognition errors will occur. This component defines how the agent recovers in those moments.

The purpose is to keep the interaction from breaking. A fallback should not feel like a dead end. It should acknowledge what went wrong, explain what the agent can do next, and carry the user forward. In some cases that means retrying, in others it means clarifying, and in others it means gracefully ending the interaction.

Fallbacks and Errors also serve as a protection against robotic behavior. Without this guidance, agents tend to repeat the same line or loop the user through the same step. By designing repair strategies up front, we can make sure the agent responds in a way that feels intentional rather than mechanical.

This component supports all three layers of alignment. It protects outcome alignment by reassuring the user even when the task cannot be completed. It supports causal alignment by showing the user that the system has a plan for handling errors. And it strengthens interactional alignment by using clear, empathetic phrasing instead of silence or repetition.

Edge Cases and Tests

The sixth component of the framework is Edge Cases and Tests. These are the scenarios that do not show up in the happy path but still occur often enough to matter. They include conflicting user information, incomplete details, out-of-scope requests, or situations where system tools return unexpected results.

The purpose is to anticipate variability before it reaches production. By documenting edge cases and the expected agent behavior, we give design, engineering, and QA a shared reference for testing. This prevents surprises in live environments and ensures the agent responds consistently across conditions.

Edge Cases and Tests also create a bridge between design intent and quality assurance. Instead of leaving “unusual” interactions undefined, we make them part of the architecture.

This component is primarily about causal alignment. It helps users see that the agent works logically, even when their request is outside the norm. It also supports interactional alignment by defining how the agent should acknowledge confusion or redirect the user in a way that feels natural.

Inputs and APIs

The seventh component of the framework is Inputs and APIs. Prompts are only as effective as the system capabilities that support them. This component ensures that what the agent asks for, confirms, or reports back is directly tied to the data available through system tools and integrations.

The purpose is to keep the conversation grounded in reality. If the agent asks for information it cannot process, or promises actions it cannot take, trust is lost immediately. By mapping each step of the flow to its required inputs and expected outputs, we make sure prompts stay aligned with what the system can actually do.

Inputs and APIs also create alignment between design and engineering. Instead of leaving technical dependencies implicit, they are documented as part of the prompt architecture. This prevents the common mismatch where the conversation design assumes one path but the backend tools behave differently.

This component supports causal alignment most directly, ensuring that the system’s logic matches the user’s expectation of how things should work. It also contributes to outcome alignment by making sure the agent only commits to results it can deliver.

Prompting Style

The eighth component of the framework is Prompting Style. While Voice and Tone set the overall character, Prompting Style focuses on the writing itself: how questions are phrased, how confirmations are delivered, and how the agent acknowledges the user across turns.

The purpose is consistency. Without clear style guidance, prompts drift. Some may be overly wordy, others too abrupt. Some may over-apologize, while others miss the opportunity to reassure. By defining style rules, we create a unified experience no matter who on the team is writing or revising prompts.

Prompting Style also helps the agent manage rhythm and repair. For example, confirming information once and moving on avoids frustration. Acknowledging effort when a user has to repeat themselves shows empathy without slowing the flow. These choices add up to a system that feels intentional and considerate rather than improvised.

This component leans on interactional alignment, ensuring that every exchange feels natural and respectful. It also supports causal alignment by keeping phrasing tightly linked to the agent’s actual capabilities, preventing the temptation to “sound helpful” without being able to act.

Using a Checklist

The framework is only useful if it can be applied consistently. To make that possible, we rely on a checklist that covers all eight components. The checklist is designed to be used before testing a new feature, when updating a flow, or whenever prompts are revised during iterative improvement.

The checklist asks simple but essential questions:

• Does the agent’s role and scope come through clearly?
• Are the outcomes explicit, and does the agent reassure when they cannot be met?
• Is the tone appropriate to the scenario and the user’s state?
• Are fallback and recovery paths defined for both user and system errors?
• Do escalation rules account for intent, phrasing, and emotional cues, not just keywords?
• Are confirmation, recap, and closure steps handled in ways that set the right expectations?

Each item is tied back to mental model alignment. Causal checks ensure the user’s sense of how the system works matches reality. Outcome checks make sure the task is clear and worth the user’s effort. Interactional checks focus on what it feels like to interact with the agent — whether the experience is coherent, respectful, and trustworthy.

Using the checklist helps us spot gaps before they reach production. It keeps prompt construction systematic rather than ad hoc, and it creates shared accountability across design, engineering, and QA. Most importantly, it ensures the agent’s behavior has been reviewed not just for functionality but for alignment with how humans will actually experience it.

Building a Shared Discipline

Creating a prompt architecture is not just about fixing today’s flows. It is about giving experience designers a path to pivot their skills into agent behavior. By breaking prompts into clear components, we create a structure that looks familiar to XDs — objectives, flows, tone, recovery, constraints — but applied to agents instead of screens.

This structure provides scale and consistency. Teams can work from the same blueprint, rather than each person improvising their own approach. It also becomes a teaching tool: new designers can see how prompts connect to user mental models, and how behavioral alignment matters as much as visual clarity once did.

Our work is expanding from interface design to the architecture of agent behavior. A well-defined prompt architecture is how we work towards making that shift practical, teachable, and sustainable for this generation of design.

The views expressed in this article are my own. Examples have been anonymized or generalized to respect confidentiality and may represent a composite of multiple research insights. No specific company, product, or tool should be assumed unless explicitly stated.

This perspective was formed not just through design iteration, but through deliberate, ethically grounded research. All participant feedback referenced here was gathered with informed consent, anonymized to protect identity, and analyzed using transparent frameworks. In every study — whether moderated interviews, feedback roundtables, or synthetic evaluations — human impact came first.

Agentic systems may be powered by AI, but they are built on human expectations, needs, and vulnerabilities. As researchers and designers, it’s our responsibility to treat that data with care and to advocate for systems that respect and empower their users.

But the systems we’re designing today are not the same. We aren’t just building interfaces that respond to user inputs. We’re building systems that initiate, generate, and decide. They lead. They suggest. They interrupt. And often, they get it wrong.

That shift has exposed the limits of traditional design frameworks. What worked for static UI often fails in multi-turn interactions, decision-support flows, and generative experiences. In my recent work testing AI-driven tools across consumer and professional contexts, I’ve seen the same patterns repeat: old heuristics leave key gaps. New friction points emerge. Users abandon systems they initially thought were cool because the experience actually doesn’t work.

This post shares a working set of updated principles. These build on the classics, but reflect what we are learning from people interacting with AI systems.

10 Updated Principles for Designing Generative Systems

1. Explainability of Model Behavior

“Why did it do that?” is the most important UX question in AI.

Classic Heuristic: Visibility of System Status
AI-Integrated Principle: Explainability of Model Behavior
Design Guidance: Show confidence, source, or rationale behind AI output.

People do not expect perfection, but they do expect clarity. When a system suggests something, makes a recommendation, or takes action, users want to understand why. In research sessions, when systems failed to explain their reasoning, participants often abandoned them mid-task.

Many customers interacting with a virtual scheduling assistant expected it to book an appointment. The assistant’s language suggested it could: “I can get that set up for you.” But instead, it offered a link to a form with no explanation.

This mismatch between implied behavior and actual capability leads to confusion and a loss of trust. In UI-driven workflows, it can be even more jarring. Buttons may suggest completion, but instead send users back into manual flows with no indication why the system could not finish what it started.

To prevent this, systems should disclose what they are doing, how confident they are, and what information they are basing it on. Confidence indicators, source tags, and clear handoff messages are essential. Designers should map out behavioral promises and validate that language and functionality match. Product managers should document boundaries — what the system can and cannot do, and what is still under development. Developers should surface backend logic in ways that can be meaningfully communicated. Researchers should listen for trust-damaging patterns like “That’s not what I asked for” or “Why did it do that?”

Explainability is not just about transparency. It is how users learn what to expect next time, and whether there will be a next time.

2. Conversational and Contextual Alignment

When the AI doesn’t speak your language, it breaks flow.

Classic Heuristic: Match Between System and Real World
AI-Integrated Principle: Conversational and Contextual Alignment
Design Guidance: Match the user’s language, task framing, and workflow structure.

When a system outputs something that does not match how people actually speak or work, the experience falls apart. This misalignment is not just about tone. It is about the structure of the output, the assumptions baked into it, and the system’s awareness of the user’s role and workflow.

In testing, a UX researcher asked a system to generate a usability test plan. Instead of receiving a structured guide with sections, time estimates, and goals, they got a paragraph-style summary that sounded like a blog post.

In another case, a field operations workers asked for help drafting a customer message. The system produced something filled with phrases like “unlock your potential” and “delight your experience.”

The issue is not accuracy. It is that the output does not fit the environment or the expectations of the user. If the structure, terminology, or form does not reflect real work, users abandon it or redo it manually.

To address this, systems must recognize the norms of the domain. That includes mirroring expected formats, using industry-specific vocabulary, and staying within the scope of the task. Designers should create tone and format libraries mapped to user roles and use cases. Product managers should validate what a “usable” output looks like in context, not just whether it contains the right information. Developers can structure outputs into modular sections to support easier editing. Researchers should look for friction points where users hesitate, pause, or reformat everything before moving forward.

Alignment is not about getting the right answer. It is about delivering that answer in a form that fits the person, the task, and the moment.

3. Human Override and Undo

If you can’t undo it, you won’t use it.

Classic Heuristic: User Control and Freedom
AI-Integrated Principle: Human Override and Undo
Design Guidance: Always allow reversal, confirmation, or retraction.

People frequently realize what they want to change immediately after they submit an input. The most common behavior we see is a moment of hesitation, followed by visible regret.

This pattern shows up in content generation, workflow automation, customer support, and scheduling tools. Whether the system is producing a message, a plan, or an update, the absence of control after submission is one of the fastest ways to erode trust. Even highly experienced users run into this.

These situations are expensive. They waste time, break focus, and discourage experimentation. If the only way to improve a result is to start over, users stop trying.

Reversibility needs to be built into every stage. That includes visible undo states, confirmation moments, cancel buttons during processing, and editable output. Designers should create flows that assume prompt regret is likely. Product managers should treat interruptibility as a requirement, not a nice-to-have. Developers can break long tasks into discrete steps that allow checkpointing. Researchers should ask users what they would have done differently and whether they felt trapped by the system’s timing or behavior.

Control is not just about letting users opt out. It is about preserving confidence and making room for correction without penalty.

4. Predictable Personality Across Modalities

The AI shouldn’t feel like a different person every time you interact with it.

Classic Heuristic: Consistency and Standards
AI-Integrated Principle: Predictable Personality Across Modalities
Design Guidance: Keep tone, behavior, and output logic consistent across interfaces and formats.

When a system interacts with people through more than one interface — voice, chat, UI, email — it must feel like the same entity. Too often, it does not. A voice assistant might sound warm and helpful, while its follow-up message is terse and impersonal. A system that is conversational in chat may switch to legalistic language in email, or behave more like a static form when embedded in a UI. In our voice and tone study, this pattern emerged again and again.

This inconsistency erodes trust. It forces users to rebuild their mental model with each interaction. Some even assumed they were using different systems altogether. That confusion makes them less likely to try the assistant again, or to rely on it for anything important.

Consistency goes beyond tone. It includes structure, initiative, helpfulness, and pacing. A system that offers options in one channel should not drop into passive summaries in another. When a task starts in voice and continues in chat, it should feel seamless. When follow-up appears in email, it should pick up where the last exchange left off.

Designers should map behaviors and tone traits across surfaces and ensure alignment. Product managers need to treat behavioral coherence as part of product identity. Developers should use shared prompt structures, content schemas, and tone models. Researchers should evaluate cross-channel experiences and ask users whether they felt they were interacting with one assistant or several.

Predictability is not about being repetitive. It is about delivering continuity. That is what builds familiarity, confidence, and long-term use.

5. Hallucination Mitigation and Prompt Safeguards

AI that’s wrong and confident is worse than unhelpful — it’s dangerous.

Classic Heuristic: Error Prevention
AI-Integrated Principle: Hallucination Mitigation and Prompt Safeguards
Design Guidance: Suppress confident falsehoods, detect ungrounded answers, and signal uncertainty.

Systems that generate content or make recommendations can sound confident even when they are wrong. This is more damaging than silence. Users are often misled not because the system failed, but because it sounded trustworthy when it should not have.

This came up repeatedly in research with support and operations tools. In one case, a participant asked about return policy details and was told, “Your return window is 90 days,” when the actual policy was 30. The assistant had simply guessed based on a similar scenario.

This is not just a trust issue. It is a risk multiplier. When a system’s output gets used in decision-making without verification, mistakes cascade. In professional workflows, this leads to rework, customer service escalation, or compliance concerns. In consumer contexts, it breaks the contract of help.

To address this, systems must distinguish between outputs that are grounded and those that are speculative or low confidence. Designers can use visual indicators to surface uncertainty, such as soft labels, expandable source tags, or phrasing like “Based on limited data.” Product managers should define reliability thresholds for output display and suppression. Developers can implement scoring mechanisms or filtering logic to block risky completions. Researchers should investigate when users act on incorrect information and whether they realized it was wrong before or after taking action.

People will forgive limitations. They will not forgive false confidence that leads them astray.

6. Memory and Context Recall

“Didn’t we already talk about this?”

Classic Heuristic: Recognition Rather Than Recall
Updated Principle: Context Persistence
Design Guidance: Retain lightweight memory of user goals, preferences, and prior inputs across task flows.

When a system forgets what has already been said or asked, it creates friction. Users feel like they are starting over. This not only slows them down — it undermines confidence that the system is capable of assisting in real work.

In testing, this pattern emerged across scheduling tools, research assistants, and content workflows. A user would explain their goal, receive a promising first response, and then be asked to re-enter the same information in the next step.

This disconnect breaks the interaction. People stop seeing the system as collaborative and start seeing it as repetitive or even adversarial. In professional settings, where tasks unfold over multiple steps, memory gaps feel especially wasteful.

Persistence does not mean storing everything. Most users do not expect long-term memory. What they expect is short-term continuity: understanding what the task is, what has already been provided, and what constraints or preferences should still apply.

Designers should model task flows around continuity checkpoints. Product managers need to define what should be remembered, for how long, and at what level of personalization. Developers can store ephemeral context using tokens, metadata, or session logs. Researchers should watch for signs that users are re-explaining, re-entering, or disengaging due to repeated prompts or redundant handoffs.

When a system remembers enough to stay present, people lean in. When it forgets, they opt out.

7. Customizability and Prompt Iteration

People want to fine-tune — not start over.

Classic Heuristic: Flexibility and Efficiency of Use
AI-Integrated Principle: Customizability and Prompt Iteration
Design Guidance: Support in-place refinement of prompts and outputs without requiring full restarts.

People rarely get what they want on the first try. In systems that generate content or structured output, the most common user need is not a new idea, but a small change. Users want to tweak the tone, shorten a section, or reorder the list — not retype the entire prompt.

In testing, this pain point surfaced constantly. A content strategist asked for a message draft, then realized it was written in the wrong voice.

Instead of enabling fine-tuning, the system offered only one option: re-enter the prompt. The result was a complete rewrite that discarded useful pieces. The user ended up copying the first response into a doc and editing it manually.

This pattern discourages experimentation. It teaches users not to ask for refinements because the cost is too high. It also forces them into copy-paste workflows, which undermines the value of the system itself.

Good systems support iteration in place. That might mean toggles for tone, length, or structure. It could include sliders, rewrite options, or partial generation controls. Designers should build in visible options for adjusting outputs post-generation. Product managers should prioritize features that support non-destructive editing. Developers can implement response chunking and modular regeneration. Researchers should look for signs that users are doing extra work to preserve what they liked while trying to fix what they didn’t.

Iteration is where real collaboration happens. If systems can’t support it, users will stop trying .

8. Cognitive Load Management in Multi-Turn AI

Too much content is just as bad as too little.

Classic Heuristic: Aesthetic and Minimalist Design
AI-Integrated Principle: Cognitive Load Management in Multi-Turn AI
Design Guidance: Keep responses focused, relevant, and scannable — especially across turns.

One of the most common breakdowns in generative systems is overproduction. Instead of offering just enough, the system gives too much — too many words, too many points, too much explanation. This creates noise that users have to filter through, increasing their cognitive burden and decreasing their trust in the system’s utility.

In testing, users frequently scrolled past long responses, skimming to find the part that mattered. Many copied the output into another tool just to cut it down.

The problem is not just volume — it is relevance. When a system repeats itself, adds disclaimers, or includes unnecessary definitions, it forces the user to work harder to extract value. This is especially damaging in tools meant to support fast decisions or creative exploration. In those moments, excess content is not helpful — it is friction.

Cognitive load can be reduced through structure, clarity, and restraint. Systems should return the smallest useful unit of information first, with the option to expand. Designers should use visual hierarchy, progressive disclosure, and plain language. Product managers should define thresholds for maximum output size and ensure response formatting matches user expectations. Developers can implement token caps, role-based verbosity settings, or summarization fallback. Researchers should observe what users skip, skim, or immediately revise — and what they describe as “too much.”

Reducing output volume is not about saying less. It is about saying what matters, in a form that respects time and attention.

9. Transparent Debugging and Recovery Paths

When the AI breaks, the user shouldn’t disappear with it.

Classic Heuristic: Help Users Recognize and Recover from Errors
AI-Integrated Principle: Transparent Debugging and Recovery Paths
Design Guidance: Clearly show what failed, why it failed, and how the user can recover.

When a system breaks or fails silently, users feel abandoned. If they cannot tell what went wrong or how to fix it, they lose trust — not just in the interaction, but in the system as a whole. Recovery is not just a technical concern. It is a user experience problem.

This pattern shows up often in systems that retrieve, generate, or process requests. A user might be in the middle of a task when the system returns a vague error like “Something went wrong,” without any next step.

The damage is not always immediate. A single failure might be tolerated. But when recovery requires guessing, retrying blindly, or starting over, the system becomes unusable in moments that matter.

Effective systems anticipate failure and design for recovery. That includes visible retry buttons, alternative pathways, explanation overlays, and undo functionality. Even a simple message explaining what the system attempted and where it got stuck can reestablish user confidence.

Designers should define what helpful failure looks like and treat it as a core scenario. Product managers should push for graceful fallbacks rather than generic error messages. Developers should surface underlying issues in user-friendly language and track retry outcomes. Researchers should look for moments when users stop using a tool after a failure, especially when the tool made no attempt to help them recover.

Recovery is not a luxury. It is a signal that the system values the user’s time and is still trying to help — even when things go wrong.

10. Embedded Examples and Prompt Scaffolding

Blank boxes are abandonment zones.

Classic Heuristic: Help and Documentation
AI-Integrated Principle: Embedded Examples and Prompt Scaffolding
Design Guidance: Provide just-in-time input guidance, examples, and role-relevant templates in context.

A blank input field is one of the highest-friction moments in any system that asks users to initiate a request, describe their goal, or phrase a task. Without structure, examples, or visible prompts, users often pause, guess, or leave. The problem is not capability. It is ambiguity.

In testing, first-time users of systems that generate content or insight frequently froze at the input field.

This hesitation was especially common among users who were not familiar with free-form or generative interaction patterns. Even experienced users expressed doubt about formatting, tone, or scope. When systems provided no guidance, their prompts were often vague, incomplete, or overly constrained.

When examples were included — especially those relevant to the user’s role or task — confidence and quality of input improved dramatically. Templates, autofill suggestions, dropdowns, and edit-in-place examples made a visible difference. Users moved faster and required fewer retries.

Designers should treat blank fields as interaction zones, not empty states. Product managers should prioritize onboarding not as a first-time experience but as an ongoing design pattern. Developers can implement structured prompt slots, auto-suggest modules, or task starter libraries. Researchers should observe how long users linger before beginning and what happens after they submit their first request.

People want to do the right thing. A good example often makes the difference between hesitation and flow.

How I Developed These Principles

These principles came from watching where things broke.

Over the past 18 months, I’ve seen how people interact with AI systems in real-world contexts. I’ve watched them try to get help, clarity, or speed — and run into confusion, repetition, or failure. I’ve seen users light up after a great first output, then lose trust when the next one felt like it came from a different assistant entirely.

This work draws from moderated studies, voice and tone evaluations, prompt testing, and interviews. The patterns here reflect insights from more than 200 AI-driven interactions.

I hope this gives us a more grounded starting point for what needs to be true if we want these systems to feel usable, respectful, and reliable.

The views expressed in this article are my own. Examples have been anonymized or generalized to respect confidentiality and may represent a composite of multiple research insights. No specific company, product, or tool should be assumed unless explicitly stated.

This perspective was formed not just through design iteration, but through deliberate, ethically grounded research. All participant feedback referenced here was gathered with informed consent, anonymized to protect identity, and analyzed using transparent frameworks. In every study — whether moderated interviews, feedback roundtables, or synthetic evaluations — human impact came first.

Agentic systems may be powered by AI, but they are built on human expectations, needs, and vulnerabilities. As researchers and designers, it’s our responsibility to treat that data with care and to advocate for systems that respect and empower their users.

This Isn’t Your Grandma’s IVR

Let’s be clear: this isn’t a rigid decision tree with robot prompts. Our virtual agent is powered by an LLM and engages with customers through dynamic, human-like conversation. This means we can’t rely on traditional pass /fail task success alone. There’s no clear script, no tidy flowchart — just an open-ended exchange shaped by real-time interpretation and user intent.

What makes this uniquely challenging is not just the unpredictability of language — but the emotional weight users bring to the conversation. When someone calls about a plumbing emergency, they’re not looking to navigate options. They’re looking for reassurance, clarity, and fast resolution. That emotional expectation sets the bar not just for functionality, but for tone, timing, and perceived empathy.

Why Classic Methods Break in Conversational AI

Let’s acknowledge an uncomfortable truth: traditional usability methods are rooted in predictability. Standard usability tests thrive on defined tasks, clear objectives, and measurable outcomes. But these methods, dependable as they are, break down when faced with conversational AI’s inherent unpredictability.

Consider a typical usability scenario: a user clicks through defined screens with minimal ambiguity. Now contrast that with conversation. People interrupt, pause, backtrack, and revise their intent mid-sentence. They expect not just functionality, but empathy, clarity, and reassurance — traits we usually associate with human support, not automation.

In our early tests, that mismatch surfaced fast. Task completion rates and satisfaction scores skimmed the surface but failed to explain moments of hesitation, repetition, or emotional drop-off. Users weren’t just evaluating success — they were reacting to how the experience made them feel.

That’s where our mental model-based scorecards came in. They gave us a deeper, structured way to capture what truly mattered in these fluid interactions: not just what happened, but why it felt the way it did.

Mapping Scorecards to Mental Models

Through early testing, we realized users evaluate virtual agents on three dimensions — consciously or not. These became the foundation of our scorecard:

• Outcome Model: Did the user achieve their intended goal?
• Causal Model: Did the user understand what the agent was doing and why?
• Interactional Model: Did the conversation feel natural, respectful, and engaging?

This framework helped us see beyond the binary. Success wasn’t just about task completion — it was about alignment with user expectations across these layers, especially emotional alignment.

But identifying the dimensions wasn’t enough — we needed to design a scorecard that could operationalize these insights into measurable indicators. Our design process began with mapping each model to observable or reportable user behaviors:

• For Outcome, we looked at user confidence, perceived task completion, and clarity of next steps.
• For Causal, we evaluated whether users understood the agent’s purpose and whether it successfully gathered all required information.
• For Interactional, we assessed conversational smoothness, tone matching, interruptions, and name pronunciation.

We included both qualitative notes and Likert-scale ratings in each sprint to track how users perceived each model. This gave us a multidimensional picture of the experience and a way to score improvement over time without oversimplifying what makes a conversation feel successful.

Applying RITE: Iteration Without Losing Rigor

To evaluate and improve, we turned to RITE — Rapid Iterative Testing and Evaluation. Originally developed for interface design, RITE allows for continuous updates based on real user feedback rather than waiting until the end of a test cycle. It’s a methodology built for speed, realism, and direct observation — making it a natural fit for the unpredictable world of conversational AI.

Traditional usability tests often require detailed task scripts, formal observation setups, and weeks of planning between rounds. RITE let us move faster. We ran compact, unmoderated test batches of 15 participants per sprint, which provided enough data to see patterns without slowing momentum. These short sessions allowed users to speak naturally with the agent — no forced scripts, no artificial constraints.

Crucially, we didn’t just observe outcomes. We analyzed conversations using our mental-model-aligned scorecard. This helped us identify where confidence dropped, where language became misaligned, and when a user’s experience began to fray. By measuring these dimensions sprint-over-sprint, we could adjust prompts or agent behavior and evaluate those changes immediately in the next round.

This pairing — RITE methodology and scorecard metrics — gave us a rhythm: observe, identify, iterate, validate. It kept us grounded in evidence while respecting the inherent fluidity of AI conversation.

When the Greeting Breaks the Experience

One of our most valuable insights came from a seemingly innocuous opening line: “Hi, this is Sam from ABC Plumbing. How can I help you today?”

Users interpreted this as a promise of full-service support. But the agent’s actual capability was limited to information-gathering. The mismatch between expectation and reality triggered sharp drops in confidence — even when the interaction itself was polite and technically successful.

We updated the greeting to set expectations clearly: “Hi, this is Sam from ABC Plumbing. I can collect the details we need and help speed up the appointment process. How can I help?”

That small shift improved scores across Outcome, Causal, and Interactional dimensions. It didn’t change the system’s function — but it realigned the experience with how users mentally modeled what the agent could do.

From Insights to Action

Our scorecard system gave us a practical way to make sense of messy, conversational data. It helped us:

• Identify when and why confidence dipped — even if the task was completed.
• Detect mismatches between what users expected and what the system could deliver.
• Prioritize changes that strengthened clarity, empathy, and flow.

By visualizing where the agent succeeded or stumbled within the user’s mental model, we could act with intention — not just intuition. And importantly, we learned how to make emotional resonance measurable.

Conclusion: Designing with Alignment in Mind

Working with conversational AI demands more than technical tuning. It calls for a human-centered lens that respects the nuance of how people experience dialogue. Unpredictability isn’t a flaw — it’s a defining feature of natural language. The real challenge is designing systems that meet users in that space with empathy, clarity, and adaptive support.

The scorecard grounded in mental models became our compass. It helped us see past metrics that missed the mark and focus on what actually shapes trust and satisfaction.

These tools also offer broader implications for human factors practitioners entering the AI space. As systems grow more complex and less deterministic, we need new ways to understand the intersection of cognition, emotion, and algorithmic behavior. Scorecards that align with user mental models aren’t just useful — they’re foundational to designing trustworthy agentic systems.

We didn’t erase unpredictability, but we gave ourselves a way to work with it. Through iterative testing and mental-model mapping, we turned complexity into clarity and design into a conversation users could believe in.

The views expressed in this article are my own. Examples have been anonymized or generalized to respect confidentiality and may represent a composite of multiple research insights. No specific company, product, or tool should be assumed unless explicitly stated.

This perspective was formed not just through design iteration, but through deliberate, ethically grounded research. All participant feedback referenced here was gathered with informed consent, anonymized to protect identity, and analyzed using transparent frameworks. In every study — whether moderated interviews, feedback roundtables, or synthetic evaluations — human impact came first.

Agentic systems may be powered by AI, but they are built on human expectations, needs, and vulnerabilities. As researchers and designers, it’s our responsibility to treat that data with care and to advocate for systems that respect and empower their users.

As builders and designers of agentic platforms, we’re now working in a space where traditional human-computer interaction patterns fall short. Users don’t just click and scroll anymore — they query, delegate, escalate. This shift has opened the door to powerful new tools, but it’s also created a crisis of understanding.

That’s why I’ve been thinking a lot about mental models lately — specifically how they might help us bridge the widening gap between what agentic systems do and what people believe they do. I keep coming back to three core layers of understanding: Outcome, Causal, and Interactional.

You can read more in my earlier article, “Mental Models of the Agentic Age”, where I break down how this framework mirrors Maslow’s hierarchy — with Outcome Models forming the foundation, Causal Models in the middle, and Interactional Models at the top.

Recently, I came across the MIT AI Agent Index, an academic taxonomy of 67 real-world AI agents. The authors did something rare: they documented not only what these agents do, but also how well their systems explain how they work, what their limits are, and how they handle risk. Their findings confirm what many of us have sensed intuitively in testing, and they provide a timely outside validation of the mental model framework many of us are starting to adopt.

This article connects the dots between the MIT study and our evolving design toolkit. It outlines how we can use these insights to create agentic platforms that are not only more powerful — but more understandable, trustworthy, and human-centered.

Why This Matters

It’s tempting to treat agent experience as a UI problem. But it’s not just about placement or polish — it’s about expectations. If users misunderstand what the agent can do, how it works, or how to interact with it, they hit friction points fast. These misunderstandings live in the space of mental models.

The MIT AI Agent Index offers a cross-sectional view of how this plays out at scale. It evaluates agentic systems like Devin, Magentic, and LinkedIn’s Recruiter Assistant — not just on functionality, but on scaffolding: the reasoning models, tool use, memory design, and safety mechanisms that underpin them.

Even more useful: it reveals what’s missing in most of these deployments.

What Is the AI Agent Index?

The MIT AI Agent Index is the first large-scale public taxonomy of agentic systems. It covers 67 live products deployed across software engineering, customer service, web automation, and more.

For each system, the Index captures:

• Capabilities and goals (e.g., scheduling, web search, file handling, code generation)
• Scaffolding (how agents plan, reason, remember, and use tools)
• Transparency practices (documentation, safety disclosures, shutdown procedures)
• Evaluation metrics (benchmarks used, post-deployment testing)

You can explore the full database at aiagentindex.mit.edu.

The goal is not just cataloging tools — it’s understanding how developers frame user expectations. Across systems, one pattern emerges again and again: we are overcommunicating capabilities and undercommunicating constraints. We highlight what agents can do, but rarely how or when they’ll fail.

This is the territory of mental models. And it’s where UX can lead.

Key Takeaways from the MIT AI Agent Index

Here are the standout patterns the MIT team uncovered:

1. Capabilities Are Emphasized — Boundaries Are Not

Most documentation focuses on what the agent can do, with little information on what it can’t. This leads to mismatches in Outcome Models, where users overestimate functionality or apply the wrong use cases.

2. Reasoning and Planning Are Opaque

Only 13% of agents disclose how they plan or reason. That leaves users without a solid Causal Model — they don’t understand how the agent is making decisions or why it’s behaving a certain way.

3. Safety and Escalation Paths Are Rarely Defined

Just 19.4% of agents include any public mention of safety protocols or escalation flows. This creates holes in the Interactional Model — users don’t know how to recover when things go sideways.

4. Tool Use and Memory Are Hidden from Users

While many agents use external tools or persistent memory, most keep this behind the scenes. This again breaks the Causal Model — users don’t know what resources are being used or what might be stored.

5. Evaluation Transparency Is Inconsistent

Only about half of the agents disclose benchmark results, and even fewer provide post-deployment evaluations. That means users — and internal teams — can’t assess progress or trustworthiness.

From Index → Models → Action

Here’s how these gaps map onto mental models, and what designers can do about them:

While the last row is an inference (not statistically confirmed in the MIT report), it aligns with what many of us are seeing in practice — personality clarity is often muddled, and it matters more than we think.

Why This Resonates with UX Testing

If you’ve been doing usability testing on conversational agents, this may all sound familiar.

We’ve consistently found that:

• Users don’t need to understand LLMs, but they do need clarity.
• Agents that set the right expectations escalate less and earn more trust.
• Users actively construct models during interaction, even if we don’t explicitly teach them.

Designing around mental models gives us a durable structure for addressing this.

Connecting to Evaluation Work

The MIT Index reinforces a critical need: we can’t just evaluate agentic systems based on whether they generate fluent output. We need to understand how well they align with what people expect, infer, and experience — which is where mental models come into play.

Internally, we’ve developed a layered scorecard system to evaluate real conversations. It doesn’t just ask “Did it work?” — it examines how users are likely interpreting the system across all three model layers:

• Outcome Model — Does the agent clearly communicate what it can (and can’t) do?
• Causal Model — Does it offer enough cues to explain how it’s thinking or making decisions?
• Interactional Model — Does it guide the user through the experience with clarity and grace?

What’s been especially powerful is applying hierarchical weighting to these layers. Since Outcome Models form the foundation of trust and task success, they carry the most weight. If users misunderstand what the agent is for, everything else collapses. Causal clarity supports deeper predictability, while Interactional polish fine-tunes usability and tone.

Our scoring system reflects this logic:

• Outcome alignment issues are flagged as critical failures — they block successful task completion and erode confidence.
• Causal model gaps get prioritized when users express confusion about why the agent did something.
• Interactional issues are more cosmetic unless they snowball into escalation or drop-off.

By layering this evaluation hierarchy over real conversations, we can:

• Diagnose breakdowns at the right layer.
• Prioritize fixes based on their structural impact.
• Track improvement in a way that maps to user understanding — not just model output.

It also gives us a shared language to explain how the agent is performing to cross-functional partners — grounded not in benchmarks, but in real human interpretation.

What Designers and Teams Can Do Now

You don’t need to boil the ocean. Start with small, strategic nudges that align to each mental model layer:

🧠 Outcome Model Improvements

• Be explicit: “I can help you schedule, cancel, or connect with a human.”
• Set expectations from the first line.

🔧 Causal Model Nudges

• Narrate internal logic: “Looking that up now…” or “Let me double-check that.”
• Show that the agent is reasoning, even if the process is simplified.

🗣️ Interactional Model Guardrails

• Admit limitations: “I can’t do that yet, but I can connect you.”
• Offer paths forward, not dead ends.

These are lightweight UX wins that prevent major breakdowns.

Final Thought: Design for Understanding, Not Just Output

The MIT AI Agent Index doesn’t just expose industry gaps — it validates what many of us in UX already know: agentic systems need better scaffolding for trust. Users aren’t just interacting with a feature; they’re forming an evolving relationship with a semi-autonomous system.

Designing with mental models in mind helps us meet users where they are — at every level of understanding. If we can align to those internal models, we won’t just reduce friction.

We’ll help define what good agentic interaction feels like.

The views expressed in this article are my own. Examples have been anonymized or generalized to respect confidentiality and may represent a composite of multiple research insights. No specific company, product, or tool should be assumed unless explicitly stated.

This perspective was formed not just through design iteration, but through deliberate, ethically grounded research. All participant feedback referenced here was gathered with informed consent, anonymized to protect identity, and analyzed using transparent frameworks. In every study — whether moderated interviews, feedback roundtables, or synthetic evaluations — human impact came first.

Agentic systems may be powered by AI, but they are built on human expectations, needs, and vulnerabilities. As researchers and designers, it’s our responsibility to treat that data with care and to advocate for systems that respect and empower their users.

Evolve is a GPT assistant trained to reflect how research is changing. Not in theory. In reality. It’s built for the people who still have questions to answer, users to understand, and product decisions to guide — but who are now expected to do it faster, leaner, and in increasingly AI-mediated environments.

This isn’t just a productivity tool. It’s a transitional scaffold. It helps researchers evolve their practice by embedding structure, simulation, and judgment into how they work with language models. And yes — it can help prove that you’re using AI meaningfully, not just checking a box.

What It Is

Evolve is a custom GPT assistant trained to:

• Generate testable prompts
• Plan hybrid studies using AI + real participants
• Simulate user behavior, tone reactions, and edge-case interactions
• Compare AI insights against real research findings
• Support post-launch evaluation workflows (drift detection, trust repair, CS handoff)

It’s grounded in actual research workflows, not just prompt templates.

Why Use It (Instead of Just ChatGPT)

Because Evolve was trained to behave like a research copilot — not a chatbot.

Unlike ChatGPT, it:

• Knows what phase you’re in (Discovery, Design, Build, Deploy) and adapts accordingly
• Produces structured outputs like logs, behavioral summaries, CoT prompts, and UX evaluation guides
• Uses embedded workflow maps to pair human + AI roles
• Offers simulation-first approaches before defaulting to “suggestions”
• Embeds research language: friction, trust, escalation, behavior, tone, validity

It doesn’t replace you. But it will 10x your thinking, especially when you’re time-boxed, stuck, or working alone.

How It Was Trained

Evolve wasn’t trained on abstract UX theory – I trained it using real research practices and prompt design patterns I’ve developed over the past year. I’ve used this assistant to pressure-test onboarding flows, simulate emotional trust breakdowns, and compare synthetic and real insights side by side. The goal was never to automate research – it was to build a system that understands the work, because it’s grounded in how I do the work. You can see this in how it structures its support.

The Discovery phase is all about surfacing questions, clarifying goals, and understanding user needs. Evolve helps by breaking down assumptions, drafting prompts, simulating early reactions, and helping researchers compare patterns across inputs. It speeds up early-stage thinking without skipping the steps that matter.

Here’s a snapshot of what that looks like in the Discovery phase:

The Deploy phase, on the other hand, is about monitoring live behavior and spotting drift. Evolve can simulate how users might respond to changes, audit tone and flow, and compare AI-generated summaries to real-world feedback. It’s built to help you stay close to the user – even after launch

Here’s a snapshot of what that looks like in the Deploy phase:

These maps are embedded in Evolve’s knowledge — it draws from them when you identify what stage you’re in.

The other phases — Explore, Design, and Build — are equally mapped out with clear guidance on how to pair AI support with human expertise. While not shown in detail here, Evolve draws from the full set of these workflows to tailor its assistance based on your current phase.

How to Start: The Four Prompts

When you open Evolve, you’ll see four starter buttons. They’re not random. Each one maps to a specific research behavior.

1. Write better prompts for research Use this when you know what you want to learn but need to phrase it clearly for simulation or synthesis.

• Expect to be asked what product stage you’re in
• You’ll get Chain-of-Thought (CoT), persona-framed, and diagnostic-style prompts
• Output is ready to paste into Loveable.dev or your prototype GPT

2. Plan a study with AI + real users Use this when you need to combine traditional methods with AI tooling.

• Expect help sequencing tasks, matching methods to goals
• You’ll be offered hybrid study plans with both human and synthetic inputs

3. Test design ideas with synthetic users Use this to simulate reactions to flows, content, or copy.

• Evolve can generate a persona or use yours
• You can simulate stress, pushback, or hesitation
• Output includes narrated behavior logs or failure-point summaries

4. Compare AI insights to my notes Use this when you’ve done a study and want to validate or critique a summary.

• You can paste in your notes and/or AI output
• Evolve will compare them, flag differences, and offer a synthesized version

Example: Diagnosing a Trust Problem in Onboarding

Let’s say your team is building a virtual dissection kit for high school biology teachers, and you’ve just launched a prototype. Early feedback shows some teachers are dropping off during onboarding — and your team suspects it’s a trust issue. But you don’t know where that trust breaks, or how to fix it.

Instead of spinning up a survey or guessing at solutions, you start a conversation with Evolve:

You: We think teachers don’t trust the onboarding experience. What should we do?

Evolve:

• Suggests running a step-by-step simulation: “Simulate a high-school biology teacher onboarding to the virtual dissection kit. At each step, rate their trust on a scale of 1–5. Identify hesitation triggers — is it unclear value, tech confusion, tone, or lack of legitimacy?”
• Recommends testing different personas — like a time-strapped teacher, a tech-skeptical veteran, or a curious early adopter.
• Offers to generate a list of trust levers based on common friction points:
• Clarity: Can users understand what this tool is and why it matters in 10 seconds or less?
• Credibility: Are there recognizable affiliations, reviews, or usage stats that suggest legitimacy?
• Control: Do users feel they have agency in how they proceed through the flow?
• Social proof: Do they know other teachers like them are using it?
• Value framing: Are we showing how this saves time or improves student outcomes?

From there, you can choose what to test next:

• Rewrite the first screen of onboarding using stronger trust signals
• Simulate reactions to your current vs. revised flow using Evolve’s persona modeling
• Generate testimonials or proof points to drop directly into the UI

What you get isn’t a generic list of tips — it’s a full research sprint, framed, scoped, and executable in under 10 minutes.

This is what I hope makes Evolve useful: structured diagnosis → simulation → tailored levers → optional outputs → ready-to-test UX guidance.

You can try Evolve here: chat.openai.com/g/g-vUhBYoYDh-evolve-the-ai-research-copilot

If you’re being asked to “prove you’re using AI” in your work this might be a good place to start.

Created by JB Booth — UX & AI strategist and founder of UXSuccess.com
The views expressed in this article are my own. Examples have been anonymized or generalized to respect confidentiality and may represent a composite of multiple research insights. No specific company, product, or tool should be assumed unless explicitly stated.

This perspective was formed not just through design iteration, but through deliberate, ethically grounded research. All participant feedback referenced here was gathered with informed consent, anonymized to protect identity, and analyzed using transparent frameworks. In every study — whether moderated interviews, feedback roundtables, or synthetic evaluations — human impact came first.

Agentic systems may be powered by AI, but they are built on human expectations, needs, and vulnerabilities. As researchers and designers, it’s our responsibility to treat that data with care and to advocate for systems that respect and empower their users.

Over the past year, I’ve conducted dozens of research studies — from product feedback sessions with SaaS teams to desk research across human-computer interaction, social robotics, and voicebot design. I’ve reviewed academic papers, surveyed real users, moderated roundtables with business-facing roles, and synthesized patterns from large-scale industry evaluations. Across it all, one insight keeps resurfacing:

When users don’t understand what an agent is for, how it works, or how to use it, trust collapses — no matter how “smart” the system is.

That’s where mental models come in — not as abstract theory, but as a practical UX framework. This article outlines a three-part structure — Outcome, Causal, and Interactional models — and explains why getting this hierarchy right is essential to building agentic systems that people can actually trust and adopt.

The Problem Isn’t the Interface. It’s the Model.

Design teams often focus on surface-level decisions: Should the AI have a name? Should it sound casual or authoritative? Should we give it an avatar?

But these choices only work when the system’s behavior matches user expectations. When a bot asks for a name, but mishears it and interrupts — trust breaks. When a user is transferred but isn’t told why, confusion sets in. When an agent recommends an action without explaining its logic, users hesitate or reject it.

Across studies and testing environments, we’ve seen users form layered assumptions — fast:

• What can this system do for me?
• Why is it making that recommendation?
• How do I interact with it?

If these assumptions are wrong, the agent loses credibility — even if it sounds great doing it.

A Three-Part Framework for Human-AI Understanding

To design for these expectations, I use a three-level mental model framework that aligns with both observed user behavior and established theory:

Outcome Model — “What is this trying to help me do?”
Causal Model — “How does it work?”
Interactional Model — “How do I interact with it?”

These models are not peers. They’re hierarchical and weighted — meaning that misunderstandings at the foundational levels (Outcome, Causal) cause more severe breakdowns than surface-level misalignment (Interactional).

This framework didn’t emerge in a vacuum. It was shaped through constant triangulation: comparing participant feedback, interpreting usability breakdowns, analyzing industry tools like MIT’s AI Agent Index, and reviewing literature on human frustration with automated agents. Whether users are trying to reschedule a service, assign a technician, or understand their business performance, the mental scaffolding they bring into the interaction determines whether the system succeeds — or falls flat.

1. Outcome Model — Start Here or Fail Fast

This is the foundation. If users aren’t clear on the goal of the system — what it will help them accomplish — they either disengage or overestimate.

In research, this model dominated across all user types:

• One participant said: “Only alert me when something’s really valuable.”
• Another asked: “Give me my morning rundown and tell me what to focus on.”
• A third added: “Just tell me what to do in fast-paced moments.”

Even when phrased differently, the demand was the same: Make it useful. Make it clear.

When agents lead with vague intros — “Hi! How can I help you today?” — users default to their own mental model. If that model doesn’t match reality, misalignment occurs. But when the system clearly states what it can do — “I can help you schedule, reschedule, or get support” — users relax. They engage. They know what to expect.

2. Causal Model — Show the Work

Once the outcome is clear, the next question becomes: How did you get that answer?

The Causal Model reflects users’ beliefs about how the system reasons. Is it just using keywords? Does it factor in history? Does it know something I don’t?

Even basic cues can help:

• “Let me check your recent service history…”
• “This option is closest and has the highest success rate.”

These aren’t just filler lines — they are trust bridges. They signal that the agent isn’t making arbitrary choices. That there’s a logic — however simple — behind its actions.

MIT’s AI Agent Index found that only 13% of agentic systems provide any explanation of how decisions are made. That lack of transparency makes it nearly impossible for users to form a valid Causal Model. And when people don’t understand how a system works, they often resist its recommendations — even when they’re right.

3. Interactional Model — Polish Comes Last

This is the surface layer: tone, phrasing, personality, small talk. It’s often where conversation design teams start — and where users focus when everything else is working.

In our personification studies:

• One group appreciated a warm tone when it helped them sound more personable in customer interactions.
• Another found it distracting in fast-paced operational decisions.
• A third group tolerated personality only when the outcome was clear and the logic made sense.

Interactional elements can add delight, humanity, and brand cohesion — but they only work when they’re layered on a solid foundation of clarity and logic. Otherwise, personality feels performative. Or worse — patronizing.

Why Hierarchy (and Weighting) Matters

These mental models aren’t just labels — they’re a weighted trust architecture.

• If the Outcome isn’t clear, the interaction collapses before it begins.
• If the Causal Model isn’t supported, users hesitate or override.
• If the Interactional layer misfires, users may feel annoyed — but the stakes are lower if the foundation holds.

One user said it best:

“If the bot’s going to crack jokes about my day, it better be fixing it too.”

Validation from Desk and Field Research

My literature review on humanizing VoiceBots echoed these exact dynamics:

• Over-humanized bots increase frustration when errors occur, especially when users interpret the system as “pretending to be helpful.”
• Users with prior experience form stronger Causal Models and show more tolerance for errors — because they already understand what the system is trying to do.
• Voice interfaces outperform chatbots on goal-directed tasks — but only when paired with transparent error recovery and a clearly scoped outcome.

And across industry evaluations, the same pattern appears. Agents that lead with capability and logic — not charm — build trust faster, escalate less, and sustain engagement longer.

Design Implications: Build from the Bottom Up

If you’re building or evaluating an AI assistant, start with this stack in mind:

🔹 1. Lead with Outcome

Set expectations immediately. “I can help you [X, Y, Z].” Avoid open-ended intros unless scoped.

🔹 2. Support the Causal Model

Show the system “thinking.” Reference data sources or logic, even briefly. “I found this based on…” goes a long way.

🔹 3. Use Interactional Elements as Amplifiers

Let tone and style reinforce confidence — not replace it. Friendly voice? Great — once function and logic are clear. Personality is a multiplier, not a foundation.

🔹 4. Debug Surface Issues by Checking the Foundation

When users get irritated by tone, personality, or flow — look deeper. Was the outcome clear? Was the logic exposed? Were they trying to use the system for something it wasn’t designed to handle?

Often, Interactional friction is just a symptom of a misaligned Outcome or Causal model.

Final Thought: Mental Models Are the New Wireframes

If you’re designing for AI, you’re designing for ambiguity. And users resolve ambiguity by forming stories — mental models — about what the system does, how it works, and how to talk to it.

The best agentic systems don’t just sound smart. They make sense.

They don’t just feel human. They feel knowable.

Design for that, and you’re not just improving usability.
You’re building the scaffolding of trust.

The views expressed in this article are my own. Examples have been anonymized or generalized to respect confidentiality and may represent a composite of multiple research insights. No specific company, product, or tool should be assumed unless explicitly stated.

This perspective was formed not just through design iteration, but through deliberate, ethically grounded research. All participant feedback referenced here was gathered with informed consent, anonymized to protect identity, and analyzed using transparent frameworks. In every study — whether moderated interviews, feedback roundtables, or synthetic evaluations — human impact came first.

Agentic systems may be powered by AI, but they are built on human expectations, needs, and vulnerabilities. As researchers and designers, it’s our responsibility to treat that data with care and to advocate for systems that respect and empower their users.

A while back, I watched a test run of a voicebot complete a task perfectly.

It captured the user’s need. It summarized the next steps. It even said please.

But something felt off. It interrupted. It paused too long. It repeated the obvious. The user, audibly annoyed, ended the call.

The bot passed the test.

The experience failed.

Function Isn’t Enough

There’s a gap between accuracy and empathy. Between “the system works” and “that felt good.”

Most bot design focuses on escalation logic, memory, recovery, and timing — essential building blocks.

But what about emotional intelligence? What about tone, timing, and trust?

This article isn’t about making bots “friendly.”

It’s about making them believable. And it’s about using human-centered research and ethical prompting practices to do it.

The Character Is the Interface

In theater, characters aren’t defined by their outcomes. They’re defined by their motivations, their pace, their breath, and their silence.

I took that mindset into an experiment building GPT-based personas like P5, a dispatcher who thinks the system is broken, and Eva, a coach-like figure who values clarity and calm.

We built scenarios:

• Configuring advanced capacity planning
• Troubleshooting dispatch errors
• Assigning roles under pressure

Then we watched the bots try to play opposite them.

These weren’t just usability tests. They were structured rehearsals. And because our GPT personas were derived from de-identified, ethically collected user data, they gave us insight without compromising privacy.

When Bots Break Character

In one rehearsal, the bot’s timing was off. It rushed its confirmation. It skipped emotional acknowledgment.

P5 — the persona — responded with suspicion. That told us more than any usability score could. Another time, P5 got excited about a scheduling success. The bot didn’t match her energy.

Emotional Mismatches = UX Debt

We talk about technical debt all the time. But emotional UX debt accrues just as fast.

Every time a bot cuts someone off, misunderstands context, or defaults to “cheerful” while the user is clearly annoyed, it chips away at trust.

This is especially true in agentic systems — bots that aren’t just reacting, but adapting.

Because the more adaptive your system claims to be, the more users expect it to read the room.

That’s why emotional alignment matters. And that’s why this work isn’t just prompt tuning — it’s applied human factors design.

Character Development for AI

The answer isn’t to write longer scripts.

It’s to design characters.

We now use dramaturgical principles to build GPTs that simulate emotion through:

• Tone mirroring
• Subtext recognition
• Conversational pacing

And when we rehearse scenarios with these GPT personas, we test:

• Where bots seem robotic
• Where they feel natural
• Where they break trust

This process depends on a strong UXR foundation and thoughtful, privacy-conscious training inputs. We never use raw data recklessly. We use it respectfully — as the foundation for responsible, synthetic co-creation.

Why This Matters

Because believability breeds trust.

And trust buys time. A user who feels heard will give your bot more space to solve. A user who doesn’t? They hang up.

Designing emotionally intelligent bots isn’t about making AI sentimental. It’s about removing the friction that comes from emotional mismatch.

And when done ethically and with human-in-the-loop rigor, it becomes not just a UX exercise — but a trust-building act.

Try This: Prompt for Emotion

Give your persona GPTs an attitude. Then ask:

• How would this persona respond to being interrupted?
• What does this persona need to hear to stay calm?
• How do they show trust is earned?

Design for those answers. Then test with personas that push back. You’ll uncover more than usability issues — you’ll surface emotional fault lines.

And those are worth fixing.

The views expressed in this article are my own. Examples have been anonymized or generalized to respect confidentiality and may represent a composite of multiple research insights. No specific company, product, or tool should be assumed unless explicitly stated.

This perspective was formed not just through design iteration, but through deliberate, ethically grounded research. All participant feedback referenced here was gathered with informed consent, anonymized to protect identity, and analyzed using transparent frameworks. In every study — whether moderated interviews, feedback roundtables, or synthetic evaluations — human impact came first.

Agentic systems may be powered by AI, but they are built on human expectations, needs, and vulnerabilities. As researchers and designers, it’s our responsibility to treat that data with care and to advocate for systems that respect and empower their users.

I have. And the truth is, the canvas often stays blank longer than it should — not because we lack user insight, but because we’re stuck translating it into interactional structure.

What if GPT could do the heavy lifting?

This is the story of how I began using GPTs — informed by real human dialogue, linguistic analysis, and emotional profiling — to generate meaningful content for the canvas before design even begins. It’s a human-in-the-loop process, where AI doesn’t replace researchers — it supercharges our insight-to-structure pipeline.

I’m writing this not just as a UX researcher, but as someone who recently became certified as an AI Trainer through the Conversation Design Institute. That might sound like it lives in the geekiest space — but for me, it clarified how training AI is more about shaping behavior than polishing flows. It gave me shared language for something I was already doing: treating transcripts and tone markers like rehearsal notes, not just research output. It pushed my work from documenting intent to actively modeling it — ethically, iteratively, and with a very human lens on what the AI is actually being asked to do.

The Canvas doesn’t just document flows. It becomes a way to surface emotion, tone, and behavioral intent that GPT can be taught to simulate, reflect, and improve.

From Post-Its to Prompts

The Conversation Design Canvas is a tool used to structure AI interactions: physical and social context, user needs, emotional mindset, bot superpowers, responsibilities, tone.

In practice, it can feel like a glorified worksheet unless you have meaningful, emotional raw material.

Enter GPT. When fed curated user transcript data and persona analysis — developed through ethical, de-identified research practices — GPT can do something surprisingly helpful: pre-fill the canvas with plausible, nuanced, context-aware inputs.

Step One: Let Personas Talk First

Before generating structure, I generate scenes.

I take user transcripts and distill them into GPT personas — like P5, the skeptical dispatcher who thinks the system is always two steps behind, or P7, the supportive optimizer.

I prompt these personas with real-world tasks:

• “Classify your technicians.”
• “Tell me what frustrates you.”
• “Walk me through what a good day looks like.”

From there, I collect:

• Tone and voice indicators
• Decision points
• Emotional highs and lows
• Common pain points

This gives me the subtext that traditional affinity maps leave behind.

Step Two: Feed the Canvas

Now I ask GPT to fill in the Conversation Design Canvas using only the persona output.

Here’s a snapshot of what GPT helped generate for P5:

• Physical Context: In a noisy office, juggling multiple incoming calls and a broken whiteboard scheduler
• Social Context: Feels alone; overwhelmed by tech she didn’t choose
• Time Factors: End of shift, behind schedule, missing lunch
• Wants to: Assign techs quickly, avoid escalations
• Wants to know: If the system will break (again)
• Feels: Wary, skeptical, hungry, under pressure
• Bot Superpowers: Predict issues, suggest backups, remember technician quirks
• Bot Responsibilities: Must confirm constraints, must explain changes, must never assume knowledge

It didn’t just summarize — it hypothesized as if it were the user.

Step Three: Compare Across Personalities

P7’s canvas looked wildly different.

Where P5 wanted reliability and skepticism, P7 asked for collaboration, options, and system transparency.

This variance helped me:

• Spot opportunities for tone modulation
• Build multi-path conversations
• Identify escalation boundaries

GPT gave me usable scaffolding in hours instead of days.

These insights were only made possible by pairing rigorous UXR methods with synthetic systems trained to simulate behavior, not just echo it. That pairing — done ethically and responsibly — makes for stronger, more adaptable designs.

Why This Works

Because GPT is a simulation engine, not just a summarizer. It doesn’t just compress interviews — it re-performs them.

It lets you:

• Pre-test emotional resonance
• Generate hypotheses fast
• Reveal edge-case mental models

This isn’t about replacing human synthesis. It’s about starting further along the arc, with a creative partner that helps you prototype interaction, not just document it.

Try This Yourself

1. Choose a user transcript that has tone.
2. Build a GPT that speaks like that user.
3. Roleplay a day-in-the-life task.
4. Ask GPT to fill in the Conversation Design Canvas.

You might not use every output. But you’ll spend less time guessing and more time designing.

And if you do it right — with care for privacy, for voice, for the richness of human experience — you’ll also build AI that feels more like a collaborator than a calculator.

The views expressed in this article are my own. Examples have been anonymized or generalized to respect confidentiality and may represent a composite of multiple research insights. No specific company, product, or tool should be assumed unless explicitly stated.

This perspective was formed not just through design iteration, but through deliberate, ethically grounded research. All participant feedback referenced here was gathered with informed consent, anonymized to protect identity, and analyzed using transparent frameworks. In every study — whether moderated interviews, feedback roundtables, or synthetic evaluations — human impact came first.

Agentic systems may be powered by AI, but they are built on human expectations, needs, and vulnerabilities. As researchers and designers, it’s our responsibility to treat that data with care and to advocate for systems that respect and empower their users.

That question guided a recent experiment I led. The goal was deceptively simple: build GPT-powered personas that don’t just repeat user needs — they embody them. What followed was a mash-up of user research, dramaturgy, linguistic analysis, and interactive AI configuration that helped us prototype something new: bots trained not just on data, but on character.

This is the story of Eva the Dispatcher, P5 the Frustrated Skeptic, and how roleplay with GPT changed the way we think about humanizing AI.

The Problem with Static Personas

If you work in UX, you’ve probably used personas to represent user archetypes. But traditional personas are static. They live in slide decks. They wear hats that say things like “Time-Strapped Technician” and sit idle while real-world complexity evolves around them.

They rarely help us prototype. They rarely help us train systems. And they definitely don’t talk back.

So I asked: What if they could?

Enter Dramaturgy: Rewriting the Persona Playbook

My background is in theater and design. That means I don’t just care about what characters want (their objectives), but how they express those wants — through tone, pacing, physicality, resistance, silence. All of it matters.

In dramaturgy, every character is constructed from three texts:

• Spoken text: What they say
• Subtext: What they feel and believe, but don’t say
• Stage direction: What they do, and under what constraints

That became the basis for my new GPT persona framework. Instead of traits and goals, I focused on:

• Linguistic style
• Emotional tone
• Contextual behavior

These became my “rehearsal notes” for each persona.

Building Eva the Dispatcher (and Friends)

To make this concrete, I pulled transcript data from an earlier dispatcher research project. I used ChatGPT to analyze the language patterns and emotional markers of three participants:

• P5: Frustrated, weary, skeptical
• P7: Motivational, supportive, systems thinker
• P8: Logical, precise, no-nonsense

I then distilled those into modular GPT configurations. For example, Eva the Dispatcher is a character built on real-world dispatcher data, designed to speak like a dispatcher, think like one, and respond with the constraints and emotional valence of that role.

Each GPT was created using a blend of:

• Prompt engineering
• Behavioral synthesis
• Backstory derived from actual user interviews

They weren’t just mirrors — they were simulations. Personas that could react, push back, and offer emotionally authentic interactions.

Rehearsing with Bots: Roleplay as UX Method

Once the GPT personas were live, I staged simulated scenes.

• Eva and Sophia (our voicebot prototype) ran roleplays to configure advanced capacity planning.
• In one scene, Eva had to classify technicians under time pressure.
• In another, P5 challenged the bot’s assumptions and exposed edge cases.

These rehearsals didn’t just test scripts. They tested escalation logic, tone calibration, and emotional pacing. We saw where the bot interrupted too early. Where tone broke trust. Where silence meant resistance.

The result? Better prompts, clearer escalation maps, and a voicebot that felt more like a collaborator than a command line.

GPT as Emotional Simulation Engine

What made this powerful wasn’t just the simulation of behavior — it was the simulation of emotional worldview.

P5 didn’t just have different tasks. They had different expectations, anxieties, and language. That revealed where our systems still defaulted to happy-path optimism.

Because we weren’t designing for personas. We were designing with them.

Why This Matters for Agentic UX

As we move deeper into agentic systems — bots that act with autonomy and adapt to context — our role as researchers is shifting.

• From identifying needs to scripting character arcs
• From validating flows to orchestrating interactions
• From insights to influence over behavior, tone, and trust

Interactive GPT personas help us rehearse the future. They let us test assumptions before we launch. And they ground our work in something more dimensional than checklists: believable, testable, human-like interaction.

Call to Action: Try It Yourself

Pick a user you know well. Not an archetype — a person. Feed their dialogue into GPT. Watch what emerges when you shift from asking for summaries to asking for scenes.

The results might surprise you. They might even talk back.

And that’s the point.

The views expressed in this article are my own. Examples have been anonymized or generalized to respect confidentiality and may represent a composite of multiple research insights. No specific company, product, or tool should be assumed unless explicitly stated.

This perspective was formed not just through design iteration, but through deliberate, ethically grounded research. All participant feedback referenced here was gathered with informed consent, anonymized to protect identity, and analyzed using transparent frameworks. In every study — whether moderated interviews, feedback roundtables, or synthetic evaluations — human impact came first.

Agentic systems may be powered by AI, but they are built on human expectations, needs, and vulnerabilities. As researchers and designers, it’s our responsibility to treat that data with care and to advocate for systems that respect and empower their users.

Albert draws on his challenging experiences as a child to form strong connections with people out in the world. He brings his desire to add value to people’s lives into his charity work and his personal coaching business.

This is the third in a series of published interviews that are part of my passion project research study about what it means to serve community.

What does it mean to serve the community? - A spiritual exploration and research project for 2020

JB: Albert, before we get started, I’m prefacing these conversations by saying I’m working on a personal research project to unpack what it means to be service-oriented and what it means to be the type of person who feels like they want to provide service to the community. I’ve got some hypotheses, I’ve talked to a few people. I have a list of questions that I like to ask everybody who I talk to. And all the folks who I am talking to so far, are people who I have identified as being folks who are kind of role models to me, of service. So that is why I asked you to participate in this interview.

Albert : Well, thank you.

JB: And I really appreciate you agreeing to chat with me.

Albert : Absolutely.

JB: Before we get started with the questions, the first thing that I ask is for you to kind of tell me your name.

Albert : My name is Albert Talcott. My middle name is John.

JB: Albert John Talcott.

Albert : Yes.

JB: And I know you as Albert.

Albert : Yes.

JB: Or Coach Albert.

Albert : There you go.

JB: So Albert John Talcott. Where did you grow up?

Albert : I grew up in Ohio, many, many places around Ohio, predominantly the Akron area, which is by Cleveland. I went to school in Northwestern Ohio, Bowling Greens. Went to Bowling Greens State University. And that was most of my youth, was Ohio like North-Central Ohio.

JB: Okay. And what brought you to Portland?

Albert : Well, my fiance, Casey and I, we’ve been together for eight years and when we… I mean, living in Ohio, we sort of felt like it was a dead end, in many ways and we were researching where to go next. And we did a lot of traditional research, like cool places we like and why, and figuring out what metrics we wanted to use to move where. And we explored a lot of places. We were thinking about Denver and Boulder, obviously, Seattle, Portland. And we visited Portland for a vacation and Casey proposed to me on that vacation in Mount Hood. And it was quite magical in a lot of ways. It was in the snow and it was very remote. It was just us. So we kind of fell in love with Portland in a way. We actually had our engagement dinner at Andina, when we visited and this was like almost five years ago, almost to the month. January, five years ago was when it happened. After that we just decided Portland. We love Portland, moved out here.

JB: Awesome. Cool. So you’ve been in Portland for how long?

Albert : Four years, in March, so going on almost four years.

JB: And you and I know each other because you and Casey recently moved into the same building that I’m living in.

Albert : Yes. Absolutely.

JB: But you were living in Portland before that?

Albert : Yeah, we were living in Southwest.

JB: Okay. So how do you occupy your days?

Albert : That’s a great question. I’m weirdly intentional about it, actually. I mean, every morning I wake up around the same time and I spend the first hour to two hours of my morning getting my head right. So what does that mean to me? It means getting my body moving. It means meditating. It means affirmations, gratitude. I actually have a whole journal of things that go through every morning that help me remind myself of who I want to be in the world and how I want to show up. I spent a lot of time doing that before I do anything like business or work-related. Like most people, I have to say, I have my fair share of domestic duties, but my fiance, Casey, like I said, we spend a lot of time together. We have an amazing dog, Nigel. So the three of us are like the three amigos, for sure. As much time as we can spend together, we do. And I also own two businesses that I build for work, quote unquote. So that’s what the rest of my time is really centered around.

JB: And one of those businesses is Onyx Coaching.

Albert : Yes.

JB: And just full disclosure, I am a client of yours.

Albert : You sure are, one of my faves.

JB: Ha ha! Yes!!. So, you’re occupying your days, getting your head straight, working on your business. What other kinds of things do you do?

Albert : Well, in my free time?

JB: Yeah, sure.

Albert : In my free time, I mean, I have many hobbies. A lot of them focus around music. I actually went to school for vocal performance, operas. I’m a classically trained singer, so I do a lot of listening to classical music, singing. I also really like reading. I read a ton.

I spend a good amount of my time connecting out in the world. So that can mean a lot of different things. But both my businesses are based on teams and connection with other people. And it might seem somewhat nontraditional, but I get to get out into the world and talk to as many people as possible. And I mean, this study kind of hits the nail on the head in a lot of ways because when I talk to people I think to myself like, “How is it that I can add value to this person?” I don’t know if that’s a smile or a handshake, or just looking at them in the eyes and making that connection, or if it’s having a conversation about cooking or anything. You know what I mean? I’ll chat a stranger’s ear off for an hour if that’s what the moment needs. You know what I mean?

JB: Totally. I mean that’s how we met, right?

Albert : Right, exactly.

JB: We were up on the roof and we ended up chatting, and now we’ve been working together for awhile.

Albert : Yeah, for sure.

JB: Yeah. So what do you like best about living in downtown Portland?

Albert : I would say location, honestly. The fact that it is in the Pearl, it is downtown, makes it really centrally located to a lot of things. Living out in Southwest made it difficult to get to some parts of Portland that I wanted to get to. I didn’t want to have to factor in a 50 minute commute to go across the water, so it’s the location. I mean Casey does hair right now, also two blocks away. So we’re extremely close to where he works and it is a healthier lifestyle. It sort of forces you to get outside. I mean if you want to go somewhere three blocks away, odds of you driving are slim to none. So you’re walking more or you’re biking, you’re whatever. And a big, big reason was this connecting piece that I’m still talking about, which is you’re actually around more people. Simply living in this building, I’ve talked to hundreds of people more than I normally would, living in Southwest. I mean, you could hear a pin drop out there in the suburbs. You know what I mean?

JB: Yes.

Albert : It’s a very different life and those are probably the main reasons, for sure.

JB: Yeah, that’s definitely a recurring theme I’ve been hearing from people.

Albert : Yeah. I think you can find Zen in a lot of places in any way, but I think living down here kind of promote healthier lifestyle in many other ways too. So I agree.

JB: Very cool. I want to go back a little bit into your past and then we’ll kind of come forward.

Albert : Sure.

JB: I’m interested a bit about your formation as a young person. One of the things that I like to ask people is, especially now that we’re just coming out of the holiday season, I’d like to ask you about traditions that have been passed down in your family. One of the focusing questions I would ask is did you celebrate holidays when you were a child? And then if so, what do you remember about that?

Albert : Sure. Specifically talking about traditions of holidays. So yes, basically we celebrated Christmas. We celebrated every “typical” average holiday; Christmas, New Year’s, Easter, all the “normal” things. It really wasn’t based in much other than that’s what society does. My dad was Jehovah’s Witness when he grew up. My mom was Christian but they both had really horrible families, so they both abandoned their religion when they had me. So I was raised with no religion whatsoever, because they were both kind of confused in that world.

But we still did the things as most people would do. I mean our world revolved around presents and presents under the tree and Christmas music, many things I still enjoy today. But there was not a lot of depth there. Making cookies for Santa, the traditional things.

My parents actually, they were divorced when I was four, so I don’t actually have memories of my parents together. A lot of the holidays were actually really stressful because it was always a debate between whose family are you with, in the morning, on Christmas morning, were always surrounding times. And there was a point where they chose for me and then that crossed over to I start to choose, because I’m old enough. And that was tumultuous in many ways and my parents never got along. They still don’t to this day. So it was always somewhat chaotic in a lot of ways.

And then Casey has a huge family. There were like 14 different segments of family, we would like be expected to attend. Because my dad’s remarried three times, my mom’s remarried twice. So that includes a ton of different offshoots of family. In a lot of ways, I love the holidays and it brings back memories of it being really stressful.

JB: A lot of extended family, and family that has broken apart and reformed.

Albert : Yeah. Broken apart, reformed, now has expectations, hoping you would choose them over the other people. So it was sort of a cluster.

JB: And did you have siblings?

Albert : I have one half-sister, her name is Skylar. She is now 18, so she’s quite a bit younger than me. But yeah, we spent a handful of…. I mean, between the time I was 10 and 17, we lived together, but that was it.

JB: Was there a spiritual component to your holiday?

Albert : For me or my family?

JB: Well, both. Start with your family.

Albert : I would say family, no. Absolutely not. They’re almost anti-that. I think because again, they were so polarized in their religion, they didn’t even really want to entertain the idea. So it was no. Christmas is presents. And my dad was brand new to Christmas. I mean, Jehovah’s Witness typically don’t celebrate Christmas. When I was born, was the first Christmas he had ever had. So he didn’t really know how to Christmas, and my mom kind of did. So there was definitely no spiritual component whatsoever.

JB: So how about you, what is your spiritual background?

Albert : Yeah, it’s evolved a lot. Are you asking about what my spiritual thoughts about Christmas or in general?

JB: I’d like to hear more about your general background. I feel like I have a clear picture of your family estranged from their religion, celebrating Christian holidays in a secular manner. I saw you perk up a little bit when you said, “Well, spiritual for me or for my family?”

Albert : Sure. I always felt somewhat… I interpreted it differently. I think that my family in a lot of ways, I often wanted it to mean something more. I mean, I like presents as much as the next person. And I’ve often felt like there was this gap. The day after Christmas, all the joy had left our house and it was like “there has to be more than presents.”

I think at an early-ish age, I don’t know, like early teens, maybe-ish, I started shying away from presents a little bit more. I didn’t really want things. I became the kid that was impossible to shop for, because I didn’t really ask for anything. And in a lot of ways, I wanted it to be about something else. I mean, I liked giving but it was so present-focused that it became not fun anymore.

I started exploring, “Okay, what can this mean to me? How can we be together and not have it be about presents?” Actually, one of my most clear as day memories of Christmas was with my mom. I was probably 9 or 10 and we were totally broke, couldn’t afford a tree, couldn’t afford any sort of presents. She was really sick and we had this dead palm tree in our house. My mom loved plants but couldn’t keep them alive. And there was this palm tree sitting on the ground that was dead.

And I remember the day she was so heartbroken, telling me that we can’t afford a tree or presents and in that moment, I remember thinking, “It’s fine. It doesn’t matter.” In a flash, I went and I literally started decorating this dead palm tree. I was like, “Mom, this is going to be our Christmas tree. It’s okay,” and then I started coloring pages in a coloring book and folding them up and putting them under the tree as presents.

I think her heart was really warmed by that because I didn’t need the tree and the presents. I think that was a really transformational Christmas because I showed myself and I showed her, it doesn’t matter. We’re here together, that’s what actually matters. I think she was kind of blown away by that. I think about it every Christmas.

Casey and I have this ongoing joke, about the palm tree. We know what that means and we always talk about it. It’s a very special memory to me.

JB: Thanks for sharing that with me.

Albert : You’re welcome.

JB: One of my questions as we dig into your spiritual background is about having a spiritual moment story. I wonder if that qualifies?

Albert : I would certainly say yes. I can’t think of anything off the top of my head that’s really bigger. I mean, I’ve had an accumulation of a lot of moments and with my personal growth work, everything always leads to there’s something bigger than me. So in a lot of ways it’s all these small spiritual moments. But let’s say big ones, a lot of them didn’t happen when I was younger, like that one namely.

JB: It sounds like you came out of a situation of scarcity, and seems like you were concerned about your mother’s feelings of sadness because she couldn’t give you things, and you, at a young age, were focused on finding a way to celebrate without having to just get a bunch of stuff, like material things, and focusing on the relationship.

Albert : Absolutely. That was something I was really concerned about because my mom had a really, really crazy childhood and she always told me she did not know the right way to raise a child, but she knew the wrong way. So everything she did was to not do it poorly. I knew that at an age, so I really wanted to make sure I reinforced the fact that it doesn’t matter if you can’t buy anything, you’re an amazing mom. That was my primary concern was. I don’t think it’s surprising that my heart was that way. I think she just kind of was like, “Wow. I don’t have to try to give you all those things. It’s not just material thing. There’s real substance here,” that maybe was lacking like in her childhood.

JB: Cool. Well, besides knowing you and having worked with you for months now, I think one of the things that made me think about you when I was pondering people who are service-oriented is specifically, the work that you did in collecting materials to distribute out into the community over this holiday. I’m wondering if you can talk a little bit about that.

Albert : Totally. I mean, come to think about it, is another sort of spiritual moment from when I was a kid to now because around the same age-ish, I don’t know my childhood kind of melts together at certain point, but I used to love taking whatever money I had, going to the Dollar General, at the time, and buying stuff, putting together baskets, shrink wrapping them and giving them to homeless people. There was this homeless shelter where I used to grow up, and I loved doing that. It was amazing. I always got emotional as a young kid. And a lot of times we would get letters back saying, “Thank you so much, you really made my family’s Christmas, et cetera.” That would always make me so happy knowing that I did something significant, even if it was on the minor end, but significant for that person.

And then I reached this age where a lot of scarcity set in, with me, financially. Like, “Oh, I don’t have a lot of money. It’s hard for me to make ends meet. Why am I going to look at you, asking me for money, when I can barely put food on my table?” There was a time I was nearly homeless, a time I almost got completely kicked out of school, really, really struggling. I became very selfish, from a place of preservation, so I can understand it. And I hated it because it was the opposite of what I wanted to be like, and how I wanted to show up. And then over the last couple of years, I’m not in that place anymore and the desire to help has rekindled and grown and grown. And so, how can I continue that and do it in different ways?

That was the primary motivation for this Christmas drive was, there was really no formality to it. I mean, I Googled the organizations, I called them up, said, “Hey, what would be most beneficial to you?” I landed on the Portland Rescue Mission and they were unbelievably grateful, even for the call, let alone that I was putting together this drive. I thought, I mean, I’m not a millionaire yet, and there are a lot of people in this building who have resources to give too. Who cares if I put it together or anyone else? It’s not about me. It’s about what we all can give, as a community, to the homeless people.

I didn’t even think I put my name on the… I got to think they knew my name. I think they knew Onyx, which sure, I guess is my company. But it wasn’t like, “Albert Talcott, donating this stuff” It was, “We want to give you all of this because we know you can use it.” I was really excited to put together the box and tell people about it. I was nervous people were going to think I was a little silly for it, I guess, a little cheesy, in a sense. Because today, you can go online and make a donation payment for anything you want, it’s fine. Having this hand-wrapped box in the lobby of a nice building, I’m like, “Geez, what are they going to think, I’m a little corny or is it going to be fine?”

More people donated than I… I mean there were 36 bags of clothing that we donated, hundreds of dollars. And you were a big contributor to that which I appreciate that so much. And it was just cool to see the building rally behind a cause. That was about humanity. It was a nice glimmer of service and other people too.

JB: Yeah, it was really interesting because I noticed your hand-wrapped and super-nicely Christmas-decorated box. And it was the only decoration in the lobby here, at the beginning.

Albert : Oh, my gosh, that’s true.

JB: And then when that was there, and I saw that people were putting stuff in there and I thought, “Oh my gosh, this is amazing.” Because that came first, and then somebody put up a tree, and then somebody put-

Albert : … some lights.

JB: … some lights up. It was almost like opposite direction of the Christmas decoration. The call for gifts came and then everybody’s sort of started adding the Christmas festivities on top of that. I noticed that and thought that was pretty cool.

Albert : That’s awesome.

JB: What about your spiritual situation today?

Albert : It’s a great question. It’s something that’s evolving. It’s actually something that’s on my… I mean, I’m a very intense goal-setter. One of my top 10 goals is to continue my faith and spiritual walk. It’s something that’s ever-evolving and it’s something that I want to give a lot of attention to. And I’m not entirely sure. I mean, I’m very torn because I think there’s a difference between religion and spirit. A religion might be a set of beliefs that I subscribed to, certain books, certain buildings, certain traditions. I think my spirit has a lot to do with like, but how does that show up in me? And how does that input turn my output around? There are many people who are “religious” that are not great people.

I’m working to merge those two things. I have a pretty solid sense of what goes on in my heart and my head. And then it’s almost reversed. Now, I’m matching that up with a religion, as opposed to the other way around, is what I feel most people do. They find a religion and then they allow that to make their, however they show up in the world.

Casey and I went to a Christmas Eve service at Bethel United Church of Christ and it was amazing. It was really great. And being a gay couple, we were really concerned. Are we going to be accepted, genuinely? Are they inclusive? And there’s a lot of churches in Portland that are. I specifically looked up churches that were in the Gay Pride Parade because I thought, “Well it’s a pretty good place to start. And Bethel was one of them and they were great. The pastor is amazing. The pastor’s son is gay and actually spoke to the congregation which shows a lot of trust that his son has for him and that organization. Right? Because as he’s speaking, his husband was there. So it was a really cool environment.

JB: That’s great.

Albert : Yeah. So we’re sort of trying out different things and so it’s a cool time, for sure.

JB: That’s very cool. Let’s shift a bit to that community and maybe that community or the larger community. One of the things I am asking people is about the challenges they think that the next generation will face. Now, so I’m a boomer. When I think about the next generation, I’m really thinking I’m on the cusp of gen X. So I go to millennials and I think about what are millennials facing? I think you’re a millennial.

Albert : Yes.

JB: When you think about maybe Gen Z, the generation that comes after you, what kinds of things, challenges do you think they’ll be facing?

Albert : As a coach, many things come to my mind. Most of them are internal. What are they going to be struggling with as people? I think spirituality comes into play. But honestly, the first thing that came to mind is sort of completely left field from what we were just talking about. And that’s that most things that are really worth something special in the world, are not based on instant gratification.

They are really based on delayed gratification and putting in work, without seeing results, and that in order to have some of the best things we can have, that’s the journey required to go down. And I think so many people, young people these days, they think that if something’s not can’t be instantly theirs, it’s not worth having. And that’s sad to me in many ways, because I think that if people believe that, they’re missing out on so many things that they could have, based on that one belief.

And there’s a lot of things in that, right? Their self-worth, their personal narrative, like all these things that come together that keep them stuck in that mindset of instant gratification. But I do think that’s a big one, in human connection. I think this service piece actually relates to them. I hesitate to think so many people today, they’re younger than me, I constantly see just on their phones, or just isolated with their cliques. And I’m not saying there’s anything wrong with that inherently, but if that isn’t also paired with this ability to connect with people, I see it problematic. Because there’s a very huge human interaction, coexist together theme that I think actually needs to continue to surface, but I fear will continue to go down. So that’s probably the first thing that comes to mind.

JB: Yeah, that’s pretty interesting. You‘re not the only person who talked about social media as being a bit isolating.

Albert : Yeah, it’s kind of the opposite of what people think it’s going to do. It’s quite ironic.

JB: It is. If you could do something to help that condition, what would it be?

Albert : That’s a great question. Specifically helping that condition, to help them realize that instant gratification isn’t great, is that what you mean, specifically?

JB: Maybe, or maybe if there something you can do now…

Albert : There’s a connection piece. I keep going back to connection. I think everything worthwhile is based in connection. And so many people, I feel are bad at that today. Like I said, a lot of my time is out and about, talking to people in the world. I can tell him two seconds if someone is comfortable enough to talk to me back or not and it seems like a superpower these days. But I think anything service-related, anything hard, it’s going to be forged through connecting with people. I would say what I would do is help people learn how to connect with one another, in lots of big ways and lots of small ways.

Because I think all of that stuff stems from that connection place. So actually I would say, I’m still doing what I am doing; encouraging other people to do that, to take their eyes off of themselves long enough to put them on other people, to make a connection with someone else, even if they’re feeling like their hair looks like crap and they didn’t go to the gym for three days in a row, and they can barely look up. To learn how to push through that to say, “hi,” to a stranger. Probably that.

JB: I have a quote, this is attributed to Mahatma Gandhi. “Our aim is to earn our bread through public service.” Is that relatable?

Albert : Oh, I believe so, in many, many ways. I think… I really don’t think, I believe that at the other end of service is the gifts, right? Like the bread, the anything again, worthwhile having, that we can earn, is so much better when done through service. That quote actually reminds me of a different quote, if I may?

JB: Yeah.

Albert : It’s Rabindranath Tagore, is his name. He was a poet, and the quote says something along the lines of, “Those who plant trees, knowing they will never sit in the shade of those trees, have just started to understand the importance of life.”

JB: Wow.

Albert : So I feel like those are similar in a lot of ways. It’s the selflessness thing. It’s doing for someone else before you get yours, as a friend, as a leader, as a business owner, as a person in the world, all the things. And yeah, that the fruits are born out of taking your eyes off of yourself long enough.

JB: Yeah. And your quote also alludes to the instant gratification thing that you talked about earlier, right?

Albert : Right. Totally. 100%. Exactly. But also you earn your bread… Can you say the quote one more time?

JB: “Our aim is to earn our bread through public service.”

Albert : Right. What I love about that quote is it’s our aim is to do this, which is very intentional. They’re not just trying to get bread, they’re trying to get bread by doing service. I think that’s great. It’s uniquely subtle and intentional. It’s really cool.

JB: So what does the word service mean to you?

Albert : So many things. I think a lot of what we’ve been talking about and also it’s something that even over the past couple of years, has shown itself to be my number one focus of my life. And I think it’s because again, I see as the key to so many things. And I think that in order to serve, we get to go on our continuum of who we are as a person. Going through all the crap that comes up for us as humans, and our human experience, to be able to give to others.

Just like I said, when I was younger and I went to this scarcity place, I didn’t have the internal mechanisms, my crap was too much, coming up for me to be able to serve. I think the work was then me, putting myself back on the track of, “It’s okay that there were crazy things about your childhood. It’s okay that you have a low self-image right now. How can we get you to a place where those things don’t matter as much and you can put your eyes on other people?” I don’t know if that answered your question, but that’s what it means to me.

JB: I think it does. It’s interesting, when I ask what that word means, right? A lot of people go to public service. There are people in the service industry-

Albert : … in the military.

JB: … Or the armed services, like that work service, trying to bring that into….

Albert : Yeah, it’s very umbrella.

JB: My last question here is, I want to kind of turn the tables and say, if you were doing this interview, did you have anybody public or private who you would talk to, who you would want to interview?

Albert : Yeah. I mean, the first people that came to mind for me are definitely some of my coaches, so that the people who have helped instilled this kind of thing in me. I certainly didn’t do it by myself. I’m not that good. Namely, Hannah Bridge is one of my coaches that comes to mind. She’s an amazing woman. She is extremely selfless, extremely service-oriented, will give her left arm, and not for the sake of just to give it, to give. She has amazing intentions, so she’s the first person that came to mind, but I have a slew of coaches that I work with that I would interview. But there’d be so many cool people to talk to.

Albert : I mean, another person that came to mind is Oprah. As maybe cliche as that sounds, I think she’s amazing and a huge public figure. I think what she would have to say on that matter would be really cool. So, Oprah and Hannah Bridge.

JB: Oprah and Hannah Bridge, awesome. I like it! Anything you would like me to know before we end our conversation?

Albert : I guess the thing that just came to mind for me is it sort of doesn’t matter what people go through in their life, child, as a young adult, as an adult, it’s ever too late to go down the path of the person you really want to be. And typically, when people want to make changes, it has a lot to do with how can they serve other people. Typically, things go there, but a lot of times people have this very painful history that make them feel like they can’t, or that they’re not worthy enough to.

And I sigh because that really is something that I’m passionate about and it weighs really heavy on my heart because I don’t think it matters. Sometimes I think it actually forges us more, than somebody who’s had easy things has happened. I guess, I don’t know if that’s to know, or something I’m thinking about right now, but it’s never too late. And the thing you’ve gone through, will strengthen you and it’ll actually better equip people to connect with other people, and they actually make you stronger. And it’s okay to be in a place where you’re growing, and still be able to serve other people.

JB: Thank you.

Albert : You’re welcome. Thanks for asking me.

Here are some resources to learn more about some of the things Albert touched on in our conversation:

Onyx Coaching : https://www.onyxpdx.biz/

Portland Rescue Mission : https://www.portlandrescuemission.org/

Bethel Beaverton UCC : https://www.bethelbeaverton.org/

Rabindranath Tagore : https://www.poetryfoundation.org/poets/rabindranath-tagore