| name | Agentic UX Design - Relationship-Centric Interfaces |
| description | Design AI-first interfaces that build ongoing relationships through memory, trust evolution, and collaborative planning, not just isolated screen interactions |
| when_to_use | when user explicitly requests agentic UX design, relationship-centric design, or mentions designing for memory, trust evolution, or long-term user relationships; ONLY use when specifically asked, not for general UI/UX tasks |
| version | 1.0.0 |
Agentic UX Design - Relationship-Centric Interfaces
Overview
The paradigm shift from screen-centric to relationship-centric design.
Traditional UX optimizes individual screens and isolated interactions. Agentic UX designs for ongoing relationships where systems learn, remember, and evolve alongside users across sessions, devices, and contexts.
Core principle: Every interaction builds on learned preferences and user history. Systems don't just respond—they develop understanding that compounds over time.
Announce at start: "I'm using the Relationship Design skill to create an agentic, memory-aware interface that builds long-term relationships with users."
When to Use
Use this skill when:
- Designing AI-powered applications, chatbots, or agent systems
- Building interfaces with repeated user interactions over time
- Creating systems that should learn from user behavior
- Rethinking traditional dashboards or SaaS products for the AI era
- Users complain about "starting over" every session
- You need to measure relationship quality, not just conversion rates
- Designing for trust evolution from transparency to autonomy
- Building collaborative planning features (human + AI co-creation)
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:
- Relationship duration: How long do users typically engage? (days, months, years?)
- Interaction frequency: Daily? Weekly? Sporadic?
- Goal complexity: Simple tasks or evolving, complex objectives?
- Trust requirements: What level of autonomy makes sense?
- Memory sensitivity: What should system remember vs. forget?
- Personalization depth: How much should experience adapt?
Phase 2: Map Trust Evolution
For your specific use case:
- Define transparency needs: What must always be explained?
- Identify routine actions: What can become autonomous over time?
- Design trust indicators: How will users see system confidence?
- Create recovery paths: What happens when system makes mistakes?
- Plan trust checkpoints: How do users adjust autonomy levels?
Phase 3: Design Memory Architecture
- Behavioral data: What patterns matter?
- Preference evolution: What changes over time?
- Context signals: What indicates user's current state/goal?
- Memory controls: How do users manage what's remembered?
- Cross-session continuity: How does system maintain context?
Phase 4: Build Collaborative Planning Patterns
- Goal capture: How does system learn user objectives?
- Proactive suggestions: When/how does system offer help?
- Co-creation interface: How do human + AI work together?
- Adaptive UI: What interface elements should evolve?
- 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 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 for:
- Detailed research foundation (DeepMind, Anthropic, OpenAI)
- Technical implementation patterns
- Memory architecture designs
- Metrics implementation guides
See CHECKLIST.md for:
- Relationship UX audit checklist
- Memory & data contracts sprint guide
- Trust evolution design worksheet
Quick Reference
| Traditional UX | Agentic UX |
|---|
| Session duration | Relationship depth over months |
| Conversion rates | Trust scores and delegation comfort |
| Click-through rates | Compounding value (Month 6 vs Month 1) |
| Isolated screens | Continuous relationship context |
| Static preferences | Dynamic pattern evolution |
| One-size-fits-all | Individually adaptive interfaces |
| Explicit navigation | Goal-aligned path construction |
| Binary permissions | Graduated trust evolution |
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.
