Agentic UX Design - Relationship-Centric Interfaces

Imported from bencium/bencium-marketplace (relationship-design/skills/relationship-design/SKILL.md). Install upstream with npx skills add bencium/bencium-marketplace --skill relationship-design. Copyright stays with the author.

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:

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 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

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.