agentic-ux-design---relationship-centric-interfaces

SKILL.md

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.