Relationship Design

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.

When it helps orient the user, signal the frame you're working in — e.g. "Applying relationship-centric (agentic, memory-aware) design here, not just screen-level UX." Skip the announcement when it would be noise.

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 (at a glance)

1. Memory Revolution — dynamic, evolving relationship models over static preferences.
2. Trust as a Design Material — earn autonomy through three graduated trust stages.
3. Relationship-Centric Architecture — ongoing partnerships, not isolated transactions.
4. Systems That Plan Their Own Path — goal-alignment mechanisms over hard-coded flows.
5. New Success Metrics — relationship quality, compounding value, context accuracy, democratic alignment.

Full breakdown of each pillar, its design patterns, and its key question: references/five-pillars.md.

Deep references

• references/five-pillars.md — the five pillars in full: memory, trust stages, relationship architecture, self-planning, and the new metrics families.
• references/design-process.md — the five-phase relationship design process (context → trust map → memory architecture → collaborative planning → metrics).
• references/pattern-library.md — reusable UI components for memory-aware, trust-building, and collaborative-planning interfaces.
• references/common-mistakes.md — six recurring anti-patterns (static memory, binary trust, wrong metrics, missing privacy/recovery) with fixes.

Sibling depth files

• EXAMPLES.md — real-world applications: EU B2B relationship cockpit, memory-aware content discovery, collaborative planning assistant, trust-evolving financial advisor.
• REFERENCE.md — research foundation (DeepMind, Anthropic, OpenAI), technical implementation patterns, memory architecture designs, metrics implementation guides.
• CHECKLIST.md — 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.