| name | relationship-design |
| description | Design AI-first interfaces around ongoing user relationships — persistent memory, graduated trust, and human+AI collaborative planning — instead of isolated screens. Use for agentic/relationship-centric UX work: systems that learn and remember across sessions, trust-evolution flows, memory/forgetting controls, or relationship-quality metrics. NOT for general one-off UI/UX tasks, static content sites, or simple transactional flows with no accounts — reserve for when relationship design is genuinely the ask. |
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)
- Memory Revolution — dynamic, evolving relationship models over static preferences.
- Trust as a Design Material — earn autonomy through three graduated trust stages.
- Relationship-Centric Architecture — ongoing partnerships, not isolated transactions.
- Systems That Plan Their Own Path — goal-alignment mechanisms over hard-coded flows.
- 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
| 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.
