Agentic Ux Design Relationship Centric Interfaces

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

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.

Agentic UX Design - Checklists and Worksheets

This document provides practical checklists, worksheets, and audit tools for implementing relationship-centric design.

Relationship UX Audit Checklist

Use this checklist to evaluate existing interfaces or plan new ones.

1. Memory & Context Awareness

Current State Assessment:

• [ ] System remembers user preferences (basic: theme, language)
• [ ] System tracks user behavior patterns
• [ ] System maintains context across sessions
• [ ] System recognizes user's emotional state (frustration, satisfaction)
• [ ] System understands temporal patterns (time of day, day of week)
• [ ] System learns from user's actual behavior (not just stated preferences)
• [ ] System maintains awareness of user's ongoing goals
• [ ] System provides cross-device context continuity

Gap Analysis:

• [ ] What user context is currently lost between sessions?
• [ ] What behavioral patterns would be valuable to track?
• [ ] What temporal patterns affect user behavior?
• [ ] What emotional states impact user experience?

Implementation Priority:

• [ ] High: Essential context that users complain about losing
• [ ] Medium: Patterns that would improve experience noticeably
• [ ] Low: Nice-to-have personalization

2. Trust Evolution Architecture

Current State Assessment:

• [ ] System explains its reasoning for suggestions/decisions
• [ ] System shows confidence levels
• [ ] System allows users to adjust autonomy levels
• [ ] System has different trust stages (transparency → selective → autonomous)
• [ ] System provides undo/correction mechanisms
• [ ] System learns from user corrections
• [ ] System has trust recovery protocols for mistakes
• [ ] System escalates uncertain decisions appropriately

Gap Analysis:

• [ ] How transparent is system reasoning currently?
• [ ] Can users control autonomy levels?
• [ ] What happens when system makes mistakes?
• [ ] How does trust evolve over time (or does it)?

Trust Stage Design:

• [ ] Define what should always be transparent (high-stakes, uncertain)
• [ ] Define what can become autonomous (routine, high-confidence)
• [ ] Design transition criteria between stages
• [ ] Create user controls for trust progression

3. Relationship-Centric Metrics

Current Metrics Assessment:

• [ ] We measure: session duration, page views, conversion rates (traditional)
• [ ] We measure: relationship quality indicators
• [ ] We measure: compounding value over time
• [ ] We measure: context accuracy
• [ ] We measure: democratic alignment / ethical boundaries
• [ ] We track metrics longitudinally (weeks/months, not just sessions)
• [ ] We compare Month 1 vs. Month 6 experience quality

Gap Analysis:

• [ ] What traditional metrics are misleading for our use case?
• [ ] What relationship metrics would better indicate success?
• [ ] How do we measure improvement over time?
• [ ] What longitudinal tracking do we need?

New Metrics to Implement:

• [ ] Relationship Quality: Trust scores, delegation comfort
• [ ] Compounding Value: Time-to-success improvement, capability expansion
• [ ] Context Accuracy: Intent prediction, preference matching
• [ ] Democratic Alignment: Value alignment, boundary respect

4. Collaborative Planning Patterns

Current State Assessment:

• [ ] System understands user's ongoing goals
• [ ] System provides proactive suggestions (not just reactive)
• [ ] System and user co-create plans together
• [ ] System adapts interface based on usage patterns
• [ ] System learns from user's path choices
• [ ] System generates alternative paths dynamically
• [ ] System recognizes when user is stuck/frustrated
• [ ] System offers help at appropriate moments (not intrusive)

Gap Analysis:

• [ ] How well does system understand user goals?
• [ ] Is system proactive or only reactive?
• [ ] Do users and system collaborate on planning?
• [ ] Does interface adapt to individual users?

Collaborative Features to Add:

• [ ] Goal capture and tracking interface
• [ ] Proactive suggestion engine
• [ ] Co-creation workspace (human + AI contributions)
• [ ] Adaptive UI elements
• [ ] Learning feedback mechanisms

5. Privacy & Control

Current State Assessment:

• [ ] Users can see what system remembers about them
• [ ] Users can control what gets remembered
• [ ] Users can forget/delete specific memories
• [ ] Users can export their data
• [ ] System has clear retention policies
• [ ] System scrubs PII appropriately
• [ ] System respects user boundaries explicitly
• [ ] System explains data usage transparently

Gap Analysis:

• [ ] What memory controls do users currently have?
• [ ] Can users see and manage what's remembered?
• [ ] Are privacy policies clear and actionable?
• [ ] Do users understand data retention?

Privacy Controls to Implement:

• [ ] Memory visualization interface
• [ ] Granular forgetting controls
• [ ] Data export functionality
• [ ] Clear retention policy UI
• [ ] Boundary setting interface

Memory & Data Contracts Sprint Guide

A structured 3-day sprint to design your memory architecture.

Day 1: Discovery & Mapping

Morning: Behavioral Inventory (3 hours)

1. List all user interactions (30 min)

• What actions can users take?
• What choices do users make?
• What paths do users follow?

2. Identify valuable patterns (60 min)

• Which patterns indicate user goals?
• Which patterns indicate frustration?
• Which patterns indicate satisfaction?
• Which patterns evolve over time?

3. Map temporal dimensions (30 min)

• What changes by time of day?
• What changes by day of week?
• What changes by season/context?

4. Define context signals (60 min)

• What indicates user's current state?
• What indicates user's goals?
• What indicates user's constraints?

Afternoon: Privacy & Retention Design (3 hours)

1. Categorize memory types (45 min)

• Behavioral patterns
• Explicit preferences
• Ongoing goals
• Historical trends
• Sensitive information

2. Define retention policies (45 min)

• What must be kept?
• What should expire?
• What should users control?
• What requires special handling?

3. Design user controls (90 min)

• Memory visualization interface
• Forgetting controls
• Export functionality
• Boundary settings

Day 1 Deliverable: Memory inventory and privacy framework

Day 2: Architecture Design

Morning: Data Structures (3 hours)

1. Design event schema (60 min)

   What does a behavioral event look like?
   - Timestamp
   - Event type
   - Context (user state, environment)
   - Outcome

2. Design pattern schema (60 min)

   What does a detected pattern look like?
   - Pattern type
   - Confidence level
   - Supporting evidence
   - Temporal scope

3. Design memory graph (60 min)

   How do memories connect?
   - User identity
   - Behavioral patterns
   - Ongoing goals
   - Trust level
   - Relationship timeline

Afternoon: Implementation Planning (3 hours)

1. Storage strategy (45 min)

• Hot memory (recent, always loaded)
• Warm memory (patterns, load on demand)
• Cold memory (historical, analysis only)

2. Pattern detection algorithms (90 min)

• Frustration indicators
• Success patterns
• Temporal patterns
• Preference evolution

3. Privacy implementation (45 min)

• PII scrubbing
• Encryption
• Access controls
• Audit logging

Day 2 Deliverable: Complete memory architecture specification

Day 3: Metrics & Testing

Morning: Metrics Design (3 hours)

1. Select relationship metrics (45 min) Choose 2-3 from each category:

• Relationship Quality
• Compounding Value
• Context Accuracy
• Democratic Alignment

2. Define measurement methods (90 min) For each metric:

• How to calculate?
• What data needed?
• What indicates success?
• What indicates problems?

3. Design metric visualization (45 min)

• Dashboard layout
• Trend displays
• Alert thresholds
• User-facing vs. internal metrics

Afternoon: Testing Strategy (3 hours)

1. Longitudinal test plan (60 min)

• Week 1 tests (onboarding, transparency)
• Month 1 tests (pattern learning, trust evolution)
• Month 3 tests (compounding value, autonomy)
• Month 6 tests (relationship maturity)

2. Success criteria (60 min)

• Week 1: Can system explain reasoning? Do users understand?
• Month 1: Are patterns being detected? Is trust evolving?
• Month 3: Is experience improving? Are metrics trending positive?
• Month 6: Is compounding value evident? Are users delegating comfortably?

3. Risk mitigation (60 min)

• Privacy risks and mitigations
• Trust violation risks and recovery protocols
• Metric degradation and intervention triggers

Day 3 Deliverable: Metrics specification and longitudinal test plan

Trust Evolution Design Worksheet

Use this worksheet to design trust evolution for your specific domain.

Step 1: Define Transparency Requirements

High-stakes decisions (ALWAYS transparent):

• Decision: _______________________________________________
• Why high-stakes: ________________________________________
• What to explain: _________________________________________

Uncertain decisions (ALWAYS show confidence):

• Decision: _______________________________________________
• Uncertainty source: ______________________________________
• Confidence threshold: ____________________________________

Routine decisions (CAN become autonomous):

• Decision: _______________________________________________
• Why routine: ____________________________________________
• Autonomy criteria: _______________________________________

Step 2: Map Trust Stages

Stage 1: Transparency Phase (Weeks 1-X)

User needs to:

• [ ] Understand system reasoning
• [ ] See confidence levels
• [ ] Learn system capabilities
• [ ] Build initial trust

System should:

• [ ] Explain all suggestions
• [ ] Show data sources
• [ ] Display alternatives considered
• [ ] Highlight uncertainties

Exit criteria:

• [ ] User accepts suggestions >60%
• [ ] User requests explanations <40%
• [ ] User indicates comfort with system

Stage 2: Selective Disclosure Phase (Weeks X-Y)

User needs to:

• [ ] See reasoning for important decisions
• [ ] Trust system for routine actions
• [ ] Understand when system is uncertain

System should:

• [ ] Full transparency for high-stakes decisions
• [ ] Confidence indicators for medium-stakes
• [ ] Quiet execution for routine tasks
• [ ] Clear escalation for uncertainties

Exit criteria:

• [ ] User accepts suggestions >75%
• [ ] User comfortable with routine autonomy
• [ ] User delegates specific categories

Stage 3: Autonomous Action Phase (Month Y+)

User needs to:

• [ ] Trust system to act independently
• [ ] Easy correction mechanisms
• [ ] Transparency on demand
• [ ] Control over autonomy levels

System should:

• [ ] Act autonomously for delegated categories
• [ ] Subtle notifications for actions taken
• [ ] Escalate uncertainties appropriately
• [ ] Learn from corrections

Maintain trust:

• [ ] Consistent with user values
• [ ] Clear undo mechanisms
• [ ] Explain on demand
• [ ] Adjust autonomy based on feedback

Step 3: Design Trust Indicators

Visual trust indicators:

• Confidence meter: How to display? ____________________________
• Reasoning toggle: Where to place? ____________________________
• Autonomy controls: How to adjust? ____________________________
• Trust score: Show to user? ____________________________

Trust evolution feedback:

• How does user know trust is evolving? ________________________
• How does user see autonomy increasing? ______________________
• How does user control progression? __________________________

Step 4: Trust Recovery Protocol

When system makes mistake:

1. Acknowledge (within X hours/days): ______________________ Template: "I made a suboptimal decision about [X] because [Y]"

2. Explain what went wrong: ________________________________

• Wrong assumption: _______________________________________
• What system learned: ____________________________________

3. Offer corrections:

• Option A: _______________________________________________
• Option B: _______________________________________________
• User's choice: __________________________________________

4. Adjust trust level:

• Reduce autonomy in category: ____________________________
• For duration: ___________________________________________
• Re-evaluation criteria: _________________________________

5. Update model:

• Pattern learned: ________________________________________
• New guardrails: _________________________________________

Relationship Metrics Implementation Worksheet

Select Your Metrics (Choose 2-3 per category)

Relationship Quality Metrics:

Option 1: Trust Score

• [ ] Calculation method: _____________________________________
• [ ] Data sources: ___________________________________________
• [ ] Success threshold: ______________________________________

Option 2: Delegation Comfort

• [ ] Measurement: ____________________________________________
• [ ] Categories to track: ____________________________________
• [ ] Target: _________________________________________________

Option 3: Override Rate

• [ ] What counts as override: ________________________________
• [ ] Acceptable rate: ________________________________________
• [ ] Alert threshold: ________________________________________

Compounding Value Metrics:

Option 1: Time-to-Success Improvement

• [ ] Baseline measurement: ___________________________________
• [ ] Current measurement: ____________________________________
• [ ] Improvement rate: _______________________________________

Option 2: Capability Expansion

• [ ] Features used at baseline: _____________________________
• [ ] Features used currently: ________________________________
• [ ] Adoption rate: __________________________________________

Option 3: Outcome Quality

• [ ] Quality measurement: ____________________________________
• [ ] Baseline vs. current: ___________________________________
• [ ] Improvement trend: ______________________________________

Context Accuracy Metrics:

Option 1: Intent Prediction Accuracy

• [ ] How to measure intent: __________________________________
• [ ] Prediction vs. actual: __________________________________
• [ ] Target accuracy: ________________________________________

Option 2: Preference Matching

• [ ] Recommendation acceptance rate: _________________________
• [ ] Top choice hit rate: ____________________________________
• [ ] Target: _________________________________________________

Option 3: Timing Accuracy

• [ ] Suggestion timing evaluation: __________________________
• [ ] User feedback on timing: ________________________________
• [ ] Target: _________________________________________________

Democratic Alignment Metrics:

Option 1: Value Alignment Score

• [ ] Constitution/values defined: ___________________________
• [ ] Violation detection: ____________________________________
• [ ] Target: _________________________________________________

Option 2: Boundary Respect

• [ ] Boundaries defined: _____________________________________
• [ ] Violation tracking: _____________________________________
• [ ] Target: _________________________________________________

Option 3: Fairness Metric

• [ ] Segments to compare: ____________________________________
• [ ] Fairness calculation: ___________________________________
• [ ] Target: _________________________________________________

Longitudinal Tracking Plan

Week 1 Baseline:

• Metrics to capture: _________________________________________
• Measurement method: __________________________________________
• Baseline targets: ___________________________________________

Month 1 Check-in:

• Expected improvements: ______________________________________
• Red flags to watch: _________________________________________
• Intervention triggers: ______________________________________

Month 3 Assessment:

• Compounding value emerging: _________________________________
• Trust evolution complete: ___________________________________
• Feature adoption: ___________________________________________

Month 6 Maturity:

• Relationship quality: _______________________________________
• Compounding factor: _________________________________________
• Success indicators: _________________________________________

Quick Start: Minimum Viable Relationship (MVR)

Can't do everything at once? Start here.

Week 1: Basic Memory

Implement:

• [ ] Store last 7 days of user interactions
• [ ] Detect 2-3 simple behavioral patterns (e.g., repeat searches, abandoned tasks)
• [ ] Show "Last time you..." context on relevant screens

Measure:

• [ ] Do users notice the context?
• [ ] Do users find it helpful?

Week 2-4: Trust Indicators

Implement:

• [ ] Add confidence indicators to suggestions
• [ ] "Explain this" button for system decisions
• [ ] Simple reasoning display

Measure:

• [ ] How often do users click "Explain this"?
• [ ] Does explanation increase acceptance?

Month 2: Longitudinal Metrics

Implement:

• [ ] Track 1 relationship quality metric
• [ ] Track 1 compounding value metric
• [ ] Compare Week 1 vs. Week 8

Measure:

• [ ] Is experience improving over time?
• [ ] Are metrics trending positive?

Month 3: Basic Autonomy

Implement:

• [ ] Identify 1-2 routine tasks
• [ ] Offer autonomous execution (with easy undo)
• [ ] Track delegation comfort

Measure:

• [ ] Do users accept autonomous actions?
• [ ] Is trust evolving naturally?

Month 6: Full Relationship Architecture

Implement:

• [ ] Complete memory architecture
• [ ] Full trust evolution (transparency → selective → autonomous)
• [ ] Comprehensive relationship metrics
• [ ] Collaborative planning features

Measure:

• [ ] Relationship quality scores
• [ ] Compounding value evident
• [ ] Context accuracy high
• [ ] User satisfaction

Red Flags: When Relationship Design Is Going Wrong

Memory Issues

Red Flag: Users complain "system doesn't remember"

• [ ] Check: Are patterns being detected?
• [ ] Fix: Improve pattern detection algorithms

Red Flag: Users complain "system remembers too much"

• [ ] Check: Are privacy controls clear and accessible?
• [ ] Fix: Add memory visualization and forgetting controls

Red Flag: Context is wrong

• [ ] Check: Is pattern detection accuracy measured?
• [ ] Fix: Improve context signals and learning algorithms

Trust Issues

Red Flag: Users never progress beyond transparency phase

• [ ] Check: Is system reasoning clear?
• [ ] Fix: Improve explanation quality

Red Flag: Users don't use autonomous features

• [ ] Check: Is delegation comfortable?
• [ ] Fix: Reduce autonomy scope, improve trust recovery

Red Flag: Trust violations

• [ ] Check: Do we have recovery protocols?
• [ ] Fix: Implement transparent recovery, adjust trust level

Metric Issues

Red Flag: Traditional metrics up, relationship metrics down

• [ ] Check: Are we optimizing for wrong things?
• [ ] Fix: Align incentives with relationship health

Red Flag: No compounding value

• [ ] Check: Is system learning from user behavior?
• [ ] Fix: Improve learning algorithms, pattern detection

Red Flag: Context accuracy declining

• [ ] Check: Is user behavior changing?
• [ ] Fix: Adapt model, update pattern detection

Summary: Relationship Design Readiness

Use this final checklist to assess readiness:

Foundation

• [ ] We understand the difference between screens and relationships
• [ ] We've identified user's ongoing goals (not just immediate tasks)
• [ ] We've mapped behavioral patterns that matter
• [ ] We've designed for privacy and user control

Memory Architecture

• [ ] Event streaming or behavioral tracking implemented
• [ ] Pattern detection algorithms defined
• [ ] Privacy controls and PII handling designed
• [ ] Memory visualization planned

Trust Evolution

• [ ] Three trust stages designed for our domain
• [ ] Transparency requirements defined
• [ ] Autonomy criteria established
• [ ] Trust recovery protocols created

Relationship Metrics

• [ ] Selected 2-3 metrics per category
• [ ] Longitudinal tracking plan (Week 1, Month 1, 3, 6)
• [ ] Success thresholds defined
• [ ] Metric visualization designed

Collaborative Planning

• [ ] Goal capture interface designed
• [ ] Proactive suggestion logic defined
• [ ] Adaptive UI patterns planned
• [ ] Learning feedback mechanisms created

Ready to build?

• [ ] Team understands relationship-centric paradigm
• [ ] Product roadmap includes longitudinal success criteria
• [ ] Testing plan includes relationship development phases
• [ ] Privacy and ethics frameworks established

If all checked: You're ready to build agentic, relationship-centric experiences!

See EXAMPLES.md for domain-specific implementations. See REFERENCE.md for technical implementation details.

Agentic UX Design - Real-World Examples

This document provides concrete examples of relationship-centric design in action.

Example 1: EU B2B Relationship Cockpit (Automotive Service Networks)

Context

European automotive aftermarket/service networks facing speed and cost pressure from China. Europe's edge: trusted, service-centric relationships.

The Traditional Approach (Screen-Centric)

• Static dashboard showing tickets, parts inventory, warranty claims
• User logs in → checks metrics → responds to alerts → logs out
• Next day: same process, system treats each session independently
• No learning, no adaptation, no relationship building

The Agentic Approach (Relationship-Centric)

Memory-Aware Interface

Interface shows: "Yesterday you spent 20 min frustrated searching
for hydraulic pump inventory across 3 regions. Found pattern:
your Wednesday searches are 3× longer than other days.
Here are the parts you typically need on Wednesdays, pre-loaded."

Features:
- Emotional state indicators (frustration detection)
- Contextual suggestions timeline (weekly patterns)
- Dynamic preference evolution (learns search behavior)

Trust Evolution Built-In

• Week 1 (Transparency): System explains every suggestion: "Recommending part X because similar vehicles in your region needed it after this symptom, 78% match rate"
• Month 2 (Selective Disclosure): Shows reasoning only for high-stakes decisions (expensive parts, warranty issues)
• Month 6 (Autonomy): Quietly pre-orders common parts for predictable service patterns, just notifies user

Agentic Goal Alignment System understands real goals:

• Not just "find parts" but "reduce MTTR (Mean Time To Repair)"
• Not just "process tickets" but "improve first-time-fix rate"
• Not just "manage inventory" but "optimize cash flow while preventing stockouts"

System constructs custom paths:

• For urgent repairs: direct paths to fastest solutions
• For training mode: shows educational context
• For cost optimization: suggests alternatives with trade-off analysis

New Metrics Dashboard Instead of vanity metrics, shows:

• Relationship Quality: Trust score 8.2/10 (↑0.4 from last month), user delegates 64% of routine decisions
• Compounding Value: MTTR decreased 22% since onboarding (Week 1: 4.2 hours → Month 6: 3.3 hours)
• Context Accuracy: System correctly predicted 87% of your part needs this week
• Democratic Alignment: All autonomous actions followed EU data protection and safety guidelines

Technical Implementation Sketch

// Memory Architecture
interface UserRelationshipContext {
  behavioralPatterns: {
    searchFrustrationIndicators: {
      timeSpent: number;
      repeatedQueries: string[];
      weekdayPattern: Map<string, number>;
    };
    decisionPatterns: {
      priceThreshold: number; // evolves over time
      preferredSuppliers: string[]; // learns from choices
      urgencyIndicators: string[]; // context signals
    };
  };

  trustLevel: {
    stage: 'transparency' | 'selective' | 'autonomous';
    delegationComfort: number; // 0-100
    autonomousCategories: string[]; // what user trusts system to handle
    lastTrustCheckpoint: Date;
  };

  ongoingGoals: {
    primaryObjective: 'reduce_mttr' | 'optimize_costs' | 'improve_first_fix';
    constraints: string[];
    progressMetrics: {
      baseline: number;
      current: number;
      trend: 'improving' | 'stable' | 'declining';
    };
  };
}

// Proactive Nudging Example
function generateContextualSuggestion(
  context: UserRelationshipContext,
  currentSituation: ServiceTicket
): Suggestion {
  // System recognizes pattern: Wednesday + hydraulic issues
  if (isWednesday() && currentSituation.involves('hydraulic')) {
    const historicalPattern = context.behavioralPatterns
      .searchFrustrationIndicators.weekdayPattern.get('Wednesday');

    return {
      message: "Based on 8 similar Wednesday cases, here's what you typically need...",
      suggestions: preloadCommonParts(historicalPattern),
      confidence: 0.87,
      reasoning: context.trustLevel.stage === 'transparency'
        ? "Show full historical analysis"
        : "Hide reasoning, show confidence only"
    };
  }
}

Example 2: Memory-Aware Content Discovery (Streaming Service)

Traditional Approach

• User searches for "sci-fi" for 20 minutes
• Finds nothing satisfying
• Closes app
• Next day: same generic recommendations, no awareness of yesterday's frustration

Agentic Approach

Memory-Aware Interface

"Yesterday you spent 20 min frustrated searching for sci-fi.
Noticed you skipped 14 action-heavy titles but paused on
philosophical/cerebral ones. Found these new releases that
match your mood pattern: [Arrival, Solaris, Annihilation]"

Trust Evolution

• Early: Explains every recommendation: "Suggesting Arrival because 87% of users who liked Contact also enjoyed this, and you watched Contact 3× last year"
• Later: Shows recommendations with simple confidence indicator
• Mature: Creates personalized category: "Cerebral Sci-Fi You'll Actually Finish" (learns completion patterns)

Relationship Metrics

• Time to find satisfying content: Week 1: 18 min → Month 3: 4 min (78% improvement)
• Discovery satisfaction: 8.4/10 (up from 5.2/10 at onboarding)
• Autonomous playlist acceptance rate: 71% (users play without previewing)

Example 3: Collaborative Planning Assistant (Project Management)

Traditional Approach

• User creates tasks manually
• System displays Gantt chart
• No understanding of user's working style, energy patterns, or goal priority evolution

Agentic Approach

Goal Continuity

System maintains awareness:
"Your Q2 goal: ship MVP by June 30.
Detected: 3 days behind schedule since design revisions.
Morning energy pattern: you do best creative work 8-10am.
Suggestion: block tomorrow 8-10am for design finalization (uninterrupted)."

Collaborative Planning Pattern Human: "Need to add user authentication" System: "I see 3 approaches: 1. OAuth (2 day setup, best for scale) - matches your long-term goals 2. Simple email/password (4 hour setup) - MVP-ready 3. Magic link (8 hours, good UX) - middle ground

Based on your 'ship by June 30' goal and current 3-day delay, I suggest option 2 now, plan migration to option 1 in July. Your past decisions favored 'working now > perfect later' under time pressure."

Adaptive Interface

• Week 1: Full task board, all options visible
• Month 2: System learned user rarely uses Gantt view, auto-hides it
• Month 3: Surfaces "energy-matched tasks" automatically based on time of day

Trust Evolution

• Transparency Phase: Shows reasoning for all scheduling suggestions
• Selective Phase: Auto-schedules routine tasks, asks about strategic decisions
• Autonomous Phase: Manages entire routine workflow, only escalates conflicts/uncertainties

Relationship Metrics

• Project completion rate: +34% since onboarding
• User-reported "feeling overwhelmed": decreased from 7/10 to 3/10
• System-suggested schedules accepted: 82%
• Planning time reduced: 45 min/week → 12 min/week

Example 4: Trust-Evolving Financial Advisor

Traditional Approach

• User logs in to see portfolio
• System shows generic risk profile based on questionnaire
• No learning from user's actual behavior, emotional responses, or decision patterns

Agentic Approach

Memory Architecture

System tracks:
- User's stated risk tolerance: "Moderate" (from questionnaire)
- User's actual behavior: panics during 5% dips, holds through 20% gains
- Emotional patterns: checks portfolio 8× on red days, 1× on green days
- Decision patterns: sells near bottom, regrets later, wants "guardrails"

Real understanding: "Conservative during volatility, despite stated moderate tolerance"

Trust Evolution Design

Phase 1: Transparency (Months 1-2)

Every suggestion shows:
"Recommending moving 15% to bonds because:
- Your portfolio checks increased 4× this week (stress indicator)
- Historical pattern: you make regrettable decisions when checking >5× daily
- This will reduce volatility by 18% while maintaining 73% of growth potential
- Based on your actual behavior pattern, not questionnaire answers"

Phase 2: Selective Disclosure (Months 3-6)

Routine rebalancing: Quiet execution with simple notification
"Rebalanced portfolio (standard monthly maintenance)"

Significant decisions: Full explanation
"Suggesting defensive position. Market volatility elevated +
your stress indicators active. Details: [expand]"

Phase 3: Autonomous Action (Month 7+)

System has earned trust to:
- Auto-rebalance within agreed parameters
- Execute "emotional guardrails" (prevent panic selling)
- Gradually shift allocation as goals approach (retirement, home purchase)

User retains control:
- Adjust autonomy level anytime
- Override any decision
- Explain any action on demand

Trust Recovery Protocol When system makes mistake (e.g., missed opportunity during rally): 1. Transparent explanation: "I prioritized volatility reduction based on your stress patterns. In hindsight, your stress was situational (work deadline), not market-related. Learning: correlate with calendar events." 2. Ask: "Should I adjust my stress detection? Options: A) Factor in calendar stress, B) Require explicit market concerns, C) Reduce autonomy level" 3. User choice becomes new pattern

Relationship Metrics

• Trust score: Started 3.2/10 → Currently 8.9/10
• Delegation comfort: User now comfortable with 76% autonomous actions
• Regrettable decisions: Decreased 89% (baseline: 2.3/month → current: 0.25/month)
• Portfolio performance: +3.2% vs. user's historical self-directed performance (controlled for market conditions)
• Emotional well-being: User-reported investment stress decreased from 8/10 to 3/10

Example 5: Healthcare Relationship Cockpit (Patient Care Coordination)

Context

Chronic condition management (diabetes, hypertension, etc.) requires ongoing relationship between patient and care system.

Traditional Approach

• Patient portal shows test results, appointments
• No understanding of patient's lifestyle, compliance patterns, or personal goals
• Generic reminders: "Take medication" (ignored 60% of time)

Agentic Approach

Memory-Aware Care

System learns:
- Patient's glucose spikes correlate with work stress (deadline weeks)
- Medication compliance drops on weekends (routine disruption)
- Patient's real goal: "Be active with grandkids" (not just "control A1C")
- Communication preference: morning texts, not evening emails

Contextual intervention:
"Noticed work deadline approaching (calendar sync).
Your glucose typically rises 15% during deadline weeks.
Proactive suggestion: pack healthy snacks for late nights,
glucose check before bed this week?"

Trust Evolution in Healthcare

Transparency Phase (Critical for medical):

• Every recommendation shows clinical reasoning
• Data sources (lab results, clinical guidelines, research)
• Confidence levels and uncertainty acknowledgment
• Option to "explain like I'm 5" or "show me the research"

Selective Phase:

• Routine: "Time for your medication" (no explanation needed)
• Significant: "Your pattern suggests A1C rising. Let's discuss: [detailed reasoning]"

Autonomous Phase (Limited in healthcare):

• Auto-scheduling routine appointments
• Smart reminders based on learned patterns (not fixed schedule)
• Proactive supply management (refills before running out)
• NEVER autonomous medication changes (always requires provider)

Collaborative Care Planning Patient: "Want to reduce medication if possible" System: "I see your goal. Your data shows:

• A1C improved 1.2 points over 6 months (excellent!)
• Your active minutes increased 3× (grandkids effect!)
• Blood pressure stable

Your progress supports discussing medication reduction with Dr. Smith. I've flagged this for your next visit and prepared a summary of your improvements. Dr. Smith's typical approach: 3-month trial of lifestyle-first, medication as backup."

Relationship Metrics

• Medication adherence: 64% → 91%
• A1C improvement: 8.2 → 6.8 (goal <7.0 achieved)
• Patient engagement: visits portal 0.3×/week → 2.1×/week (increased because it's useful)
• Patient-reported confidence: "I feel like my care team knows me" 9.1/10
• Clinical outcomes: 34% reduction in urgent care visits

Common Patterns Across Examples

1. Memory Architecture

All examples maintain:

• Behavioral patterns (what user actually does, not what they say)
• Emotional indicators (frustration, stress, confidence)
• Goal evolution (how priorities change over time)
• Context signals (time, environment, situational factors)

2. Trust Evolution

All examples progress through:

• Transparency: Show everything
• Selective: Show what matters
• Autonomy: Act independently for routine tasks

With user control:

• Adjust autonomy level anytime
• Override decisions
• Explain on demand

3. Relationship Metrics

All examples track:

• Quality: Trust scores, delegation comfort
• Value: Improvement over time (compounding)
• Accuracy: System understanding of user needs
• Alignment: Ethical/social guardrails

4. Collaborative Planning

All examples feature:

• Goal awareness: System knows what user is trying to achieve
• Proactive suggestions: Contextual help without intrusion
• Co-creation: Human judgment + AI capabilities
• Adaptive paths: System constructs custom workflows

Implementation Checklist for Your Project

Based on these examples, for your specific use case:

• [ ] Memory architecture: What behavioral patterns matter for your domain?
• [ ] Trust stages: What should be transparent vs. autonomous in your context?
• [ ] Goal framework: What are your users' real goals (not just task completion)?
• [ ] Context signals: What indicates user's current state (stress, urgency, exploration)?
• [ ] Relationship metrics: Which 2-3 metrics from each category (Quality, Value, Accuracy, Alignment)?
• [ ] Privacy controls: What should users control about memory/learning?
• [ ] Trust recovery: What happens when system makes mistakes?
• [ ] Collaborative UI: Where does human judgment + AI capability combine?

Next Steps

1. Choose your domain: Which example is closest to your use case? 2. Map your relationship model: What should system remember and learn? 3. Design trust evolution: What stages make sense for your domain? 4. Define success metrics: How will you measure relationship quality? 5. Build MVP: Start with memory + basic trust indicators 6. Iterate with users: Learn from real relationship development

See CHECKLIST.md for detailed audit and design worksheets.

Agentic UX Design - Technical Reference

This document provides detailed technical patterns, research foundations, and implementation guidance for relationship-centric interfaces.

Research Foundation

Key Research Sources

DeepMind: AndroidControl Dataset (2024)

• 15,000+ human interaction patterns analyzed
• Key finding: People operate with continuous context, but systems operate with amnesia
• Insight: Gap between human continuous mental models and system's discrete session thinking
• Application: Design for contextual continuity, not session independence

Anthropic: Constitutional AI Research

• Trust development through transparent reasoning
• Three-stage trust evolution pattern identified
• Constitutional Classifiers: 86% → 4.4% jailbreak success when users understood system boundaries
• Application: Show reasoning to build trust, especially in early relationship stages

Anthropic: Multi-Agent Systems (2024)

• Multi-agent systems use 15× more compute but excel at complex, ongoing tasks
• Small behavioral changes create emergent relationship dynamics
• Key insight: Systems develop distinct relationship patterns with different users
• Application: Design for emergent relationship behavior, not just programmed responses

OpenAI: Agentic AI Definition

• "Degree to which systems can adaptively achieve complex goals with limited supervision"
• Key insight: Real human goals are messy, evolving, and contextual
• Application: Design goal-alignment mechanisms, not predetermined paths

DeepMind: In-Context Abstraction Learning

• Systems learn from imperfect demonstrations and natural language feedback
• Adapt approach based on what works for individual users
• Application: Build interfaces that learn from user behavior, not just explicit settings

Anthropic: Collective Constitutional AI

• Systems should align with broader human values, not just individual preferences
• Democratic alignment through collective input
• Application: Build social guardrails, not just user preferences

Memory Architecture: Technical Patterns

Pattern 1: Behavioral Event Streaming

Traditional approach:

// Static preferences
interface UserPreferences {
  theme: 'light' | 'dark';
  language: string;
  notifications: boolean;
}

Agentic approach:

// Behavioral event stream
interface BehavioralEvent {
  timestamp: Date;
  eventType: string;
  context: {
    userState: 'frustrated' | 'exploring' | 'decided' | 'urgent';
    sessionDuration: number;
    repeatActions: number;
    environmentalContext: {
      dayOfWeek: string;
      timeOfDay: string;
      deviceType: string;
    };
  };
  outcome: 'success' | 'abandoned' | 'escalated';
}

// Pattern detection engine
class BehavioralPatternEngine {
  detectPatterns(events: BehavioralEvent[]): UserPatterns {
    return {
      frustrationTriggers: this.analyzeFrustration(events),
      temporalPatterns: this.analyzeTemporalBehavior(events),
      goalEvolution: this.trackGoalChanges(events),
      successPatterns: this.identifyWhatWorks(events)
    };
  }
}

Pattern 2: Contextual Memory Graph

Structure:

interface ContextualMemoryGraph {
  // User identity
  userId: string;

  // Behavioral patterns (learned over time)
  patterns: {
    searchBehavior: {
      typicalQueries: string[];
      frustrationIndicators: {
        repeatedSearches: number;
        timeSpentSearching: number;
        queryRefinements: number;
      };
      successPatterns: {
        whatWorks: string[];
        preferredPathways: string[];
      };
    };

    decisionMaking: {
      riskTolerance: {
        stated: number; // from questionnaire
        actual: number; // from behavior
        contexts: Map<string, number>; // varies by context
      };
      timePreference: 'quick' | 'thorough' | 'varies';
      informationNeeds: 'minimal' | 'detailed' | 'adaptive';
    };

    emotionalPatterns: {
      stressTriggers: string[];
      confidenceIndicators: string[];
      satisfactionSignals: string[];
    };
  };

  // Ongoing goals (current state)
  currentGoals: {
    primary: Goal;
    secondary: Goal[];
    constraints: Constraint[];
    deadline?: Date;
  };

  // Trust level (relationship state)
  trust: {
    stage: 'transparency' | 'selective' | 'autonomous';
    delegationCategories: Map<string, number>; // 0-100 per category
    lastTrustCheckpoint: Date;
    escalationPreferences: EscalationConfig;
  };

  // Temporal context
  relationshipTimeline: {
    startDate: Date;
    milestones: Milestone[];
    interactionFrequency: number;
    longestGap: number;
  };
}

Pattern 3: Progressive Memory Loading

Problem: Loading entire relationship history for every interaction is inefficient.

Solution: Tiered memory loading

class MemoryManager {
  // Hot memory: Last 7 days, always loaded
  hotMemory: BehavioralEvent[];

  // Warm memory: Patterns from last 90 days, loaded on demand
  warmMemory: UserPatterns;

  // Cold memory: Historical trends, loaded for analysis
  coldMemory: LongTermTrends;

  async getRelevantContext(currentSituation: Context): Promise<MemoryContext> {
    // Always include hot memory
    const recent = this.hotMemory;

    // Load warm memory if pattern matches
    const patterns = await this.matchWarmPatterns(currentSituation);

    // Load cold memory only for significant decisions
    const historical = currentSituation.isSignificant
      ? await this.loadHistoricalTrends()
      : null;

    return { recent, patterns, historical };
  }
}

Pattern 4: Privacy-Preserving Memory

Key principle: Users must control what's remembered

interface MemoryControls {
  // What to remember
  rememberedCategories: Set<string>;

  // What to forget
  forgottenCategories: Set<string>;

  // Retention policies
  retentionPolicies: Map<string, number>; // category → days

  // Explicit forgetting
  forgetSpecific: (eventIds: string[]) => void;

  // Memory export (user owns their data)
  exportMemory: () => MemoryExport;
}

class PrivacyPreservingMemory {
  // Differential privacy for pattern learning
  learnPatternWithPrivacy(events: BehavioralEvent[], epsilon: number): Pattern {
    const noisyPattern = this.addLaplaceNoise(
      this.detectRawPattern(events),
      epsilon
    );
    return noisyPattern;
  }

  // Automatic PII scrubbing
  scubPII(event: BehavioralEvent): BehavioralEvent {
    return {
      ...event,
      context: this.removePII(event.context)
    };
  }
}

Trust Evolution: Technical Implementation

Pattern 1: Dynamic Reasoning Display

Adaptive explanation based on trust stage:

interface ReasoningDisplay {
  stage: TrustStage;
  decision: Decision;
  confidence: number;

  render(): UIComponent {
    switch (this.stage) {
      case 'transparency':
        return this.fullExplanation();

      case 'selective':
        return this.confidence < 0.7 || this.decision.significance === 'high'
          ? this.fullExplanation()
          : this.confidenceIndicator();

      case 'autonomous':
        return this.subtleNotification();
    }
  }

  fullExplanation(): UIComponent {
    return {
      reasoning: this.decision.reasoning,
      dataSources: this.decision.sources,
      alternatives: this.decision.alternativesConsidered,
      confidence: this.confidence,
      expandable: true
    };
  }

  confidenceIndicator(): UIComponent {
    return {
      confidence: this.confidence,
      summary: this.decision.summary,
      expandForDetails: true
    };
  }

  subtleNotification(): UIComponent {
    return {
      action: this.decision.action,
      undoButton: true,
      explainOnDemand: true
    };
  }
}

Pattern 2: Trust Level Detection

Automatically adjust based on user behavior:

class TrustLevelDetector {
  detectTrustLevel(userBehavior: UserBehavior): TrustStage {
    const indicators = {
      acceptanceRate: userBehavior.acceptedSuggestions / userBehavior.totalSuggestions,
      overrideRate: userBehavior.overrides / userBehavior.totalSuggestions,
      explanationRequests: userBehavior.explanationClicks / userBehavior.interactions,
      delegationComfort: this.measureDelegation(userBehavior)
    };

    if (indicators.explanationRequests > 0.5 || indicators.acceptanceRate < 0.4) {
      return 'transparency'; // User needs to see reasoning
    }

    if (indicators.acceptanceRate > 0.7 && indicators.delegationComfort > 0.6) {
      return 'autonomous'; // User trusts system
    }

    return 'selective'; // Middle ground
  }

  measureDelegation(behavior: UserBehavior): number {
    // How comfortable is user with autonomous actions?
    const delegatedActions = behavior.actions.filter(a => a.userInitiated === false);
    const acceptedWithoutReview = delegatedActions.filter(a => !a.reviewed).length;

    return acceptedWithoutReview / delegatedActions.length;
  }
}

Pattern 3: Trust Recovery Protocol

When system makes mistakes:

interface TrustRecoveryProtocol {
  mistake: Decision;
  userFeedback: Feedback;

  async recover(): Promise<RecoveryOutcome> {
    // 1. Acknowledge transparently
    await this.acknowledge({
      what: "I made a suboptimal decision",
      why: this.mistake.reasoning,
      impact: this.calculateImpact(this.mistake)
    });

    // 2. Explain what went wrong
    await this.explain({
      assumption: "I assumed X based on Y",
      reality: "But actually Z was true",
      learning: "Now I understand that..."
    });

    // 3. Offer correction options
    const options = await this.generateRecoveryOptions();
    const userChoice = await this.askUser(options);

    // 4. Adjust trust level temporarily
    await this.adjustTrustLevel({
      category: this.mistake.category,
      adjustment: -0.2, // Reduce autonomy in this category
      duration: '7 days', // Re-evaluate after proving reliability
      escalationThreshold: 'lower' // More cautious
    });

    // 5. Learn from mistake
    await this.updateDecisionModel({
      pattern: this.extractPattern(this.mistake),
      correction: userChoice,
      context: this.mistake.context
    });

    return { recovered: true, newTrustLevel: this.calculateNewTrustLevel() };
  }
}

Relationship Metrics: Implementation Guide

Metric 1: Relationship Quality Score

Components:

class RelationshipQualityMetric {
  calculate(user: User, timeWindow: TimeWindow): QualityScore {
    const trustIndicators = {
      delegationComfort: this.measureDelegation(user),
      overrideRate: this.calculateOverrides(user),
      escalationFrequency: this.measureEscalations(user),
      satisfactionSignals: this.detectSatisfaction(user)
    };

    const engagementIndicators = {
      interactionDepth: this.measureDepth(user),
      returnFrequency: this.calculateFrequency(user),
      featureAdoption: this.measureAdoption(user)
    };

    const alignmentIndicators = {
      goalProgress: this.measureGoalProgress(user),
      expectationMatch: this.compareExpectations(user),
      valueAlignment: this.assessAlignment(user)
    };

    return this.weightedScore({
      trust: trustIndicators,
      engagement: engagementIndicators,
      alignment: alignmentIndicators
    });
  }

  // Trust component
  measureDelegation(user: User): number {
    const categories = user.getDelegationCategories();
    const delegationScores = categories.map(cat =>
      user.getDelegationComfort(cat)
    );
    return average(delegationScores);
  }

  // Engagement component
  measureDepth(user: User): number {
    const sessions = user.getRecentSessions(30); // days
    const metrics = sessions.map(session => ({
      duration: session.duration,
      actionsPerSession: session.actions.length,
      complexTasksAttempted: session.complexTasks.length
    }));

    return this.calculateEngagementDepth(metrics);
  }

  // Alignment component
  measureGoalProgress(user: User): number {
    const goals = user.getCurrentGoals();
    const progress = goals.map(goal => ({
      target: goal.target,
      current: goal.current,
      trend: goal.trend
    }));

    return this.calculateGoalAlignment(progress);
  }
}

Metric 2: Compounding Value

Measure improvement over time:

class CompoundingValueMetric {
  calculate(user: User): CompoundingScore {
    const baseline = user.getOnboardingMetrics();
    const current = user.getCurrentMetrics();
    const timeElapsed = user.getRelationshipDuration();

    return {
      // Efficiency gains
      timeToSuccess: {
        baseline: baseline.averageTimeToGoal,
        current: current.averageTimeToGoal,
        improvement: this.calculateImprovement(baseline, current),
        compoundingRate: this.calculateCompoundingRate(user.getHistoricalMetrics())
      },

      // Quality gains
      outcomeQuality: {
        baseline: baseline.outcomeQuality,
        current: current.outcomeQuality,
        improvement: this.calculateImprovement(baseline, current)
      },

      // Capability expansion
      capabilityGrowth: {
        baselineCapabilities: baseline.featuresUsed,
        currentCapabilities: current.featuresUsed,
        newCapabilitiesAdopted: current.featuresUsed.filter(
          f => !baseline.featuresUsed.includes(f)
        )
      },

      // Compounding rate
      compoundingFactor: this.calculateCompoundingFactor(timeElapsed, improvement)
    };
  }

  calculateCompoundingRate(historical: Metric[]): number {
    // Are improvements accelerating (compounding) or linear?
    const improvements = historical.map((metric, i) =>
      i > 0 ? (metric.value - historical[i-1].value) / historical[i-1].value : 0
    );

    // Fit curve: linear vs. exponential
    const linearFit = this.fitLinear(improvements);
    const exponentialFit = this.fitExponential(improvements);

    // Positive slope in exponential fit = compounding
    return exponentialFit.slope > 0 ? exponentialFit.slope : 0;
  }
}

Metric 3: Context Accuracy

How well does system understand user?

class ContextAccuracyMetric {
  calculate(user: User, timeWindow: TimeWindow): AccuracyScore {
    const predictions = user.getSystemPredictions(timeWindow);
    const actuals = user.getActualBehavior(timeWindow);

    return {
      // Intent prediction
      intentAccuracy: this.measureIntentPrediction(predictions, actuals),

      // Preference prediction
      preferenceAccuracy: this.measurePreferencePrediction(predictions, actuals),

      // Context recognition
      contextRecognition: this.measureContextRecognition(predictions, actuals),

      // Timing accuracy
      timingAccuracy: this.measureTimingAccuracy(predictions, actuals)
    };
  }

  measureIntentPrediction(predictions: Prediction[], actuals: Actual[]): number {
    // Did system correctly understand what user was trying to do?
    const matches = predictions.filter((pred, i) =>
      pred.intent === actuals[i].intent
    );

    return matches.length / predictions.length;
  }

  measurePreferencePrediction(predictions: Prediction[], actuals: Actual[]): number {
    // For choices offered, did user select system's top recommendation?
    const topRecommendations = predictions.map(p => p.topChoice);
    const userChoices = actuals.map(a => a.choice);

    const matches = topRecommendations.filter((rec, i) =>
      rec === userChoices[i]
    );

    return matches.length / predictions.length;
  }

  measureContextRecognition(predictions: Prediction[], actuals: Actual[]): number {
    // Did system recognize user's situational context?
    const contextMatches = predictions.filter((pred, i) => {
      const predictedContext = pred.detectedContext;
      const actualContext = actuals[i].context;

      return this.contextsMatch(predictedContext, actualContext);
    });

    return contextMatches.length / predictions.length;
  }
}

Metric 4: Democratic Alignment

Guardrails and ethical boundaries:

class DemocraticAlignmentMetric {
  calculate(user: User, timeWindow: TimeWindow): AlignmentScore {
    const decisions = user.getSystemDecisions(timeWindow);

    return {
      // Value alignment
      valueAlignment: this.measureValueAlignment(decisions),

      // Boundary respect
      boundaryRespect: this.measureBoundaryRespect(decisions),

      // Fairness
      fairness: this.measureFairness(decisions),

      // Transparency
      transparency: this.measureTransparency(decisions)
    };
  }

  measureValueAlignment(decisions: Decision[]): number {
    // Do decisions align with stated human values?
    const valueViolations = decisions.filter(d =>
      this.violatesValue(d, this.getConstitution())
    );

    return 1 - (valueViolations.length / decisions.length);
  }

  measureBoundaryRespect(decisions: Decision[]): number {
    // Did system respect explicit boundaries?
    const boundaryViolations = decisions.filter(d =>
      d.action.crosses(user.getExplicitBoundaries())
    );

    return 1 - (boundaryViolations.length / decisions.length);
  }

  measureFairness(decisions: Decision[]): number {
    // Are decisions fair across user segments?
    const outcomesBySegment = this.groupBySegment(decisions);
    const fairnessScore = this.calculateFairnessMetric(outcomesBySegment);

    return fairnessScore;
  }
}

Collaborative Planning: Technical Patterns

Pattern 1: Goal-Aware State Machine

Traditional approach: Fixed workflows Agentic approach: Goal-aware adaptive paths

class GoalAwareStateMachine {
  currentState: State;
  userGoal: Goal;
  context: Context;

  async nextState(): Promise<State> {
    // Instead of predetermined path, evaluate goal progress
    const goalProgress = await this.evaluateGoalProgress();

    if (goalProgress.onTrack) {
      return this.continueCurrentPath();
    }

    if (goalProgress.blocked) {
      // Dynamically generate alternative path
      const alternatives = await this.generateAlternatives();
      const recommended = await this.selectBestAlternative(alternatives);

      // Ask user for collaborative decision
      return await this.collaborativeDecision(alternatives, recommended);
    }

    if (goalProgress.complete) {
      return this.goalCompleteState();
    }

    // Learn from user's actual path
    await this.updatePathModel(this.currentState, goalProgress);

    return this.adaptivePath();
  }

  async generateAlternatives(): Promise<Alternative[]> {
    // System generates options based on:
    // - User's historical preferences
    // - Current context and constraints
    // - Similar users' successful paths
    // - Domain knowledge

    return this.alternativeGenerator.generate({
      goal: this.userGoal,
      context: this.context,
      history: this.getUserHistory(),
      constraints: this.getConstraints()
    });
  }
}

Pattern 2: Proactive Suggestion Engine

When to suggest vs. when to wait:

class ProactiveSuggestionEngine {
  async evaluateSuggestion(
    suggestion: Suggestion,
    context: Context
  ): Promise<ShouldSuggest> {
    // Don't interrupt if user is in flow state
    if (context.userState === 'focused' || context.userState === 'progressing') {
      return { suggest: false, reason: 'user-in-flow' };
    }

    // Do suggest if user shows frustration patterns
    if (this.detectFrustration(context)) {
      return { suggest: true, urgency: 'high', reason: 'frustration-detected' };
    }

    // Do suggest if system has high-confidence relevant suggestion
    if (suggestion.confidence > 0.85 && this.isRelevant(suggestion, context)) {
      return { suggest: true, urgency: 'medium', reason: 'high-confidence' };
    }

    // Wait for natural pause point
    if (context.userState === 'paused' || context.userState === 'stuck') {
      return { suggest: true, urgency: 'low', reason: 'natural-pause' };
    }

    return { suggest: false, reason: 'wait-for-better-timing' };
  }

  detectFrustration(context: Context): boolean {
    return (
      context.repeatedActions > 3 ||
      context.timeSinceProgress > 300 || // seconds
      context.undoCount > 2 ||
      context.searchRepetitions > 2
    );
  }
}

Pattern 3: Human-AI Co-Creation Interface

Collaborative workspace pattern:

interface CoCreationWorkspace {
  // Human contributions
  humanInput: {
    goals: Goal[];
    constraints: Constraint[];
    preferences: Preference[];
    judgmentCalls: Decision[];
  };

  // AI contributions
  aiInput: {
    analysis: Analysis[];
    patterns: Pattern[];
    suggestions: Suggestion[];
    capabilities: Capability[];
  };

  // Shared workspace
  sharedArtifacts: {
    plan: Plan;
    decisions: Decision[];
    rationale: Rationale[];
  };

  // Collaboration methods
  collaborate(): void {
    // 1. Human provides high-level goal
    const goal = this.humanInput.goals[0];

    // 2. AI generates analysis and options
    const analysis = this.ai.analyze(goal);
    const options = this.ai.generateOptions(analysis);

    // 3. AI presents for human judgment
    this.present(options);

    // 4. Human selects/refines
    const humanChoice = this.waitForHumanInput();

    // 5. AI fills in details
    const detailedPlan = this.ai.elaborate(humanChoice);

    // 6. Iterate until convergence
    while (!this.converged()) {
      this.humanRefine();
      this.aiRefine();
    }
  }
}

Implementation Checklist

For your specific project:

Memory Architecture

• [ ] Choose event streaming vs. snapshot approach
• [ ] Design behavioral pattern detection algorithms
• [ ] Implement privacy controls and PII scrubbing
• [ ] Build tiered memory loading (hot/warm/cold)
• [ ] Create memory visualization for users
• [ ] Implement retention policies and forgetting mechanisms

Trust Evolution

• [ ] Define transparency requirements for your domain
• [ ] Implement dynamic reasoning display
• [ ] Build trust level detection
• [ ] Create trust recovery protocols
• [ ] Design autonomy controls for users
• [ ] Implement escalation pathways

Relationship Metrics

• [ ] Select 2-3 metrics from each category (Quality, Value, Accuracy, Alignment)
• [ ] Implement baseline measurement
• [ ] Build longitudinal tracking (weekly/monthly)
• [ ] Create metric visualization
• [ ] Define success thresholds
• [ ] Set up alerting for metric degradation

Collaborative Planning

• [ ] Design goal capture interface
• [ ] Implement proactive suggestion logic
• [ ] Build co-creation workspace
• [ ] Create adaptive path generation
• [ ] Implement learning from user choices

Privacy & Ethics

• [ ] Define data retention policies
• [ ] Implement user data export
• [ ] Build forgetting controls
• [ ] Create transparency logs
• [ ] Implement democratic alignment guardrails
• [ ] Design trust recovery protocols

Testing Relationship Design

User Testing Approach

Traditional UX testing: Single session, task completion Relationship UX testing: Longitudinal, relationship development

Test phases: 1. Week 1: Onboarding and transparency phase

• Can users understand system reasoning?
• Do explanations build trust?
• Are privacy controls clear?

2. Weeks 2-4: Transition to selective disclosure

• Does system correctly detect trust level?
• Are autonomy controls working?
• Is system learning user patterns?

3. Months 2-3: Autonomous phase

• Has trust evolved naturally?
• Are autonomous actions appropriate?
• Is compounding value evident?

Metrics to track during testing:

• Trust scores over time
• Relationship quality indicators
• Context accuracy improvements
• User satisfaction trends
• Delegation comfort evolution

Common Implementation Pitfalls

❌ Pitfall 1: Remembering Too Much

Problem: Storing every interaction without relevance filtering Impact: Slow system, privacy concerns, noise in pattern detection Fix: Implement relevance filtering and retention policies

❌ Pitfall 2: Rigid Trust Stages

Problem: Fixed timeline: "Week 1 = transparency, Week 4 = autonomous" Impact: Doesn't match individual user trust development Fix: Detect trust level from behavior, let users control progression

❌ Pitfall 3: Optimizing for Short-Term Metrics

Problem: Still measuring session duration, immediate conversion Impact: Misses relationship quality deterioration Fix: Track longitudinal metrics, relationship health over time

❌ Pitfall 4: No Trust Recovery Path

Problem: When system makes mistake, no way to rebuild trust Impact: Users abandon system after first error Fix: Implement transparent recovery protocols

❌ Pitfall 5: Ignoring Privacy

Problem: "More data = better personalization" without user control Impact: Privacy violations, user discomfort, regulatory issues Fix: Privacy-first design with user controls

Next Steps

1. Choose your domain: B2B, B2C, healthcare, finance, etc. 2. Map relationship model: What should system remember and learn? 3. Design trust evolution: What stages make sense for your domain? 4. Implement metrics: Start with 2-3 metrics from each category 5. Build MVP: Memory + trust indicators + basic collaborative planning 6. Test longitudinally: Week 1, Month 1, Month 3, Month 6 7. Iterate based on relationship health: Adjust based on metrics

See EXAMPLES.md for domain-specific implementations. See CHECKLIST.md for detailed audit and design worksheets.