16 skills · 152 min

When NOT to use:

• Simple one-time transactions with no user accounts
• Static content websites with no personalization needs
• Systems where memory/learning creates privacy concerns
• Interfaces where consistency > adaptation (e.g., medical equipment)

The Five Pillars of Agentic UX

1. Memory Revolution: From Static Preferences to Contextual Intelligence

Old model: Store static preferences (theme: dark, language: EN)

New model: Maintain dynamic, evolving relationship models

Design for:

• Behavioral patterns: Not just “user clicked X” but “user spends 20 min frustrated searching for Y on Tuesday evenings”
• Emotional context: Recognize frustration, urgency, exploration, decision-making modes
• Temporal evolution: How preferences change over weeks/months
• Cross-session continuity: Seamless continuation across devices and time

Key question: What would this experience look like if it remembered everything and got better over time?

2. Trust as a Design Material: The Three-Stage Evolution

Design interfaces that earn autonomy through graduated trust:

Stage 1: Transparency Phase

• Show all reasoning, decision processes, confidence levels
• Explain why the system suggests actions
• Reveal data sources and logic paths
• User wants to see everything

Stage 2: Selective Disclosure Phase

• Show reasoning only for important/uncertain decisions
• Quiet confidence for routine actions
• System learns when to show work vs. act confidently
• User trusts but verifies

Stage 3: Autonomous Action Phase

• Act independently with subtle confirmation patterns
• Clear escalation paths for mistakes
• User delegates entire decision categories
• Trust through consistent, aligned behavior

Design patterns:

• Progressive disclosure controls (let users adjust transparency level)
• Confidence indicators (system certainty visualization)
• Trust recovery protocols (clear undo/correction paths)
• Explain-on-hover for autonomous actions

Key question: How might users develop trust with this system gradually?

3. Relationship-Centric Architecture

Design ongoing partnerships, not isolated transactions.

From: User logs in → completes task → logs out → system forgets

To: System maintains continuous awareness of:

• User’s ongoing goals and projects
• Communication preferences and patterns
• Learning from what works for this individual
• Relationship depth over time

Implementation patterns:

• Memory visualization: Show what system remembers (preferences, goals, patterns)
• Context indicators: Subtle cues showing how past interactions influence current suggestions
• Forgetting controls: User agency over what gets remembered vs. forgotten
• Relationship timeline: Visual representation of how the relationship evolved

Key question: What goals are users really trying to achieve, and how could an agentic system help them get there more effectively?

4. Systems That Plan Their Own Path

From: Design every possible user path explicitly

To: Design goal-alignment mechanisms where system dynamically constructs paths

Agentic systems:

• Maintain awareness of underlying user objectives
• Adapt interaction patterns based on what works
• Learn from imperfect demonstrations and natural language feedback
• Construct custom workflows for individual users

Design for:

• Goal continuity: Persistent awareness of user objectives across sessions
• Proactive nudging: Gentle next-step suggestions without intrusion
• Collaborative planning: Human + AI jointly developing approaches
• Adaptive interfaces: UI elements that evolve based on usage patterns

Key question: Can the system help users achieve goals they haven’t fully articulated yet?

5. New Success Metrics: Beyond Conversion Rates

Traditional UX metrics (session duration, conversion rates, clicks) miss the point for agentic experiences.

Measure instead:

Relationship Quality

• Trust scores and delegation comfort
• User confidence in system decisions
• How often users second-guess the system
• Comfort with autonomous actions

Compounding Value

• Experience improvement over time
• Increasingly complex problems solved
• Better outcomes through accumulated understanding
• Month 6 vs. Month 1 comparison

Context Accuracy

• System understanding of intent and preferences
• Alignment with user values and goals
• Situational needs recognition
• Prediction accuracy for important decisions

Democratic Alignment

• Alignment with broader human values
• Socially acceptable behavior boundaries
• Ethical decision-making
• Collective constitutional principles

Key question: How do we know if the relationship is getting better, not just more frequent?

The Relationship Design Process

Phase 1: Understand the Relationship Context

Ask these questions:

1. Relationship duration: How long do users typically engage? (days, months, years?)
2. Interaction frequency: Daily? Weekly? Sporadic?
3. Goal complexity: Simple tasks or evolving, complex objectives?
4. Trust requirements: What level of autonomy makes sense?
5. Memory sensitivity: What should system remember vs. forget?
6. Personalization depth: How much should experience adapt?

Phase 2: Map Trust Evolution

For your specific use case:

1. Define transparency needs: What must always be explained?
2. Identify routine actions: What can become autonomous over time?
3. Design trust indicators: How will users see system confidence?
4. Create recovery paths: What happens when system makes mistakes?
5. Plan trust checkpoints: How do users adjust autonomy levels?

Phase 3: Design Memory Architecture

1. Behavioral data: What patterns matter?
2. Preference evolution: What changes over time?
3. Context signals: What indicates user’s current state/goal?
4. Memory controls: How do users manage what’s remembered?
5. Cross-session continuity: How does system maintain context?

Phase 4: Build Collaborative Planning Patterns

1. Goal capture: How does system learn user objectives?
2. Proactive suggestions: When/how does system offer help?
3. Co-creation interface: How do human + AI work together?
4. Adaptive UI: What interface elements should evolve?
5. Learning feedback: How do users correct system understanding?

Phase 5: Define Success Metrics

Choose 2-3 metrics from each category:

• Relationship Quality indicators
• Compounding Value measures
• Context Accuracy signals
• Democratic Alignment guardrails

Track these over weeks/months, not just sessions.

Design Patterns Library

Memory-Aware Interface Components

Contextual Timeline

• Show user’s journey over time
• Highlight preference evolution
• Display key relationship moments

Emotional State Indicators

• Recognize frustration, urgency, exploration
• Adapt interface based on detected state
• Show system’s understanding of context

Dynamic Suggestions Panel

• Based on current goal + historical patterns
• Confidence indicators for each suggestion
• Explain why these suggestions now

Trust-Building Components

Reasoning Display (Transparency Phase)

• Show decision logic
• Display confidence levels
• Reveal data sources

Confidence Meter

• Visual indicator of system certainty
• Hover to see reasoning
• Adjust autonomy based on confidence

Undo/Correct Patterns

• One-click correction of autonomous actions
• System learns from corrections
• Clear escalation paths

Collaborative Planning Components

Goal Dashboard

• Ongoing objectives visualization
• Progress indicators
• System suggestions for next steps

Planning Canvas

• Human + AI co-create plans
• System contributes capabilities
• User provides judgment and strategy

Preference Evolution Map

• Show how system’s understanding improved
• User control over what’s learned
• Forgetting controls

Common Mistakes

❌ Treating Memory Like Static Settings

Problem: Storing preferences as key-value pairs (theme: dark) instead of evolving patterns

Fix: Design dynamic models that understand behavioral patterns, temporal context, and evolution over time

❌ Binary Trust Model

Problem: System is either fully transparent or fully autonomous from day one

Fix: Design three-stage trust evolution with gradual autonomy and user-controlled trust levels

❌ Using Traditional UX Metrics

Problem: Measuring session duration and conversion rates for relationship-based systems

Fix: Track relationship quality, compounding value, context accuracy over weeks/months

❌ Forgetting Privacy Controls

Problem: System remembers everything with no user control

Fix: Build forgetting controls, memory visualization, and clear data retention policies

❌ Designing Screens Instead of Relationships

Problem: Focusing on pixel-perfect interfaces without relationship architecture

Fix: Start with relationship model, then design screens that support ongoing partnership

❌ No Trust Recovery Path

Problem: When system makes mistakes, users lose all trust permanently

Fix: Design clear correction paths, system learning from mistakes, and trust recovery protocols

Real-World Applications

See EXAMPLES.md (opens in a new tab) for:

• EU B2B relationship cockpit (automotive service networks)
• Memory-aware content discovery (streaming services)
• Collaborative planning assistant (project management)
• Trust-evolving financial advisor

See REFERENCE.md (opens in a new tab) for:

• Detailed research foundation (DeepMind, Anthropic, OpenAI)
• Technical implementation patterns
• Memory architecture designs
• Metrics implementation guides

See CHECKLIST.md (opens in a new tab) for:

• Relationship UX audit checklist
• Memory & data contracts sprint guide
• Trust evolution design worksheet

Quick Reference

Remember

• Design for relationships that span months, not sessions
• Trust evolves through three stages: Transparency → Selective → Autonomous
• Memory means understanding patterns, not storing static preferences
• Measure relationship quality, not just engagement metrics
• Systems should plan paths to goals, not just execute predefined flows
• User control over memory, trust levels, and autonomous actions is essential
• Privacy and forgetting are as important as memory and learning

The screens will always matter. But the relationships matter more.