ChiefOSby ConversintStart free
Menu
← Back to the library
Design

Agentic relationship design

Design AI-first interfaces that build ongoing relationships through memory, trust evolution, and collaborative planning, not just isolated screen interactions

Works with the context you provideVersion 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:

  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](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](REFERENCE.md) for:** - Detailed research foundation (DeepMind, Anthropic, OpenAI) - Technical implementation patterns - Memory architecture designs - Metrics implementation guides

**See [CHECKLIST.md](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.**