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.