Context
Alex Cornell is a design director at Meta, where he leads design on Muse, Meta's consumer AI agent. This episode is about how Muse was designed to feel approachable to mainstream users even though the underlying system is complex, proactive, and highly personalized. It matters to PMs because many AI product patterns still come from coding tools and enterprise software, while Muse shows a different playbook for consumer AI: familiar interaction patterns, fast feedback, layered transparency, and useful outputs built from a person's own data. The discussion is especially useful for teams deciding how much AI internals to expose, how to handle latency, and what "generative UI" should actually mean in a shipped product.
The Big Idea
A good consumer agent should feel familiar, fast, and personally useful before it feels technically impressive.
Muse achieves that by borrowing the logic of messaging, revealing system detail only when needed, and turning scattered personal data into recurring artifacts people actually want to revisit.
Alex Cornell's core point is that an agent for everyday users should not begin with software-centric concepts like threads, traces, and connectors. It should begin with a clear relationship model, simple status cues, and visible usefulness, then let depth appear only when the user asks for it.
Key Insights
Messaging beats chatbot framing
Muse was designed as an exchange between a person and an entity, not as a generic AI utility.
- The team used messaging patterns as the main reference point instead of copying other AI apps.
- Message bubbles matter because a proactive agent may contact the user at different times of day, so the UI has to show where one interaction ends and another begins.
- The avatar at the top of the screen reinforces that the user is interacting with a persistent counterpart, not just firing isolated prompts into a tool.
- For PMs, the lesson is simple: start from the relationship the product is creating, not from the interaction patterns the industry has already normalized.
Status needs three layers
Muse uses progressive disclosure to serve both casual users and technical users without forcing either group into the wrong experience.
- At the first layer, the product answers the simplest question: is the agent doing anything at all?
- At the second layer, the product explains what the agent is doing in plain language, such as researching a topic.
- At the third layer, the product exposes deeper action history and eventually technical detail for people who want to audit what happened.
- Alex's example was clear: an engineer may want to inspect exactly what the agent did, while a mainstream user often just wants reassurance that work is in progress.
This matters because many AI products treat transparency as all-or-nothing. Muse treats transparency as a ladder.
Speed reduces explanation burden
A lot of AI UI complexity is really a compensation for latency.
- Claire Vo explicitly called out that Muse feels unusually fast.
- Alex noted that when the product is quick, users sometimes almost question whether it really did the work because the response comes back so fast.
- For longer tasks, Muse still gives an immediate acknowledgment, sometimes just a reaction or a short plan, so the user is never left wondering whether the system disappeared.
- The product then relies on status states, not a noisy trace, to reassure the user while work continues.
For PMs, the takeaway is that better loading narration is not always the right fix. Sometimes the right fix is simply making the product faster.
Generative UI needs guardrails
Alex's version of generative UI is much more disciplined than the common fantasy of a fully shape-shifting product.
- Muse keeps stable primitives such as the avatar, status area, ideas surface, and feed.
- The generated part lives inside those frames. The ideas change based on recent conversations. The status text adapts to the task. The avatar appears in different states. The feed can reflect personalized prompts.
- Alex said today's product is still "on the rails" in important ways. The interface is not fully regenerated every time a person opens the app.
That is a useful product lesson. In a shipped consumer product, generative UI often works best as bounded personalization rather than total structural unpredictability.
Personal data becomes product fuel
Some of the strongest Muse use cases came from taking old or ignored personal data and turning it into a new artifact.
- Alex used Instagram saves to create a daily shopping catalog in a SkyMall-like style.
- He used archived Instagram stories as a personal memory feed that he checks repeatedly.
- He turned hundreds of saved golf tips into a golf manual tailored to the patterns he keeps bookmarking.
- He had Muse recover a 20-year-old blog through the Wayback Machine and convert the writing into a podcast he listens to in the morning.
The pattern is bigger than any single demo. The product becomes valuable when it can find data that already matters to the user, reorganize it, and render it in a format that is easier or more fun to consume.
One main chat matters
Muse is built around a canonical main chat with optional side chats, not a product that starts from many equal threads.
Alex's reasoning was that once models can handle longer context, a single ongoing conversation feels more natural for an agent that is meant to resemble an enduring relationship. Starting a brand-new thread every time is useful for organization, but it can make the experience feel more like task software than a persistent counterpart.
He was also clear that the design is not finished. Alex likes the current balance because it exposes the benefit of the main chat, but he still sees a lot of unsolved work around helping normal users understand when to use the main chat versus a side chat.
Design shifts to scaffolding
AI product design forces a change in design mindset because the output is non-deterministic.
- In traditional software, a designer can predict the screen state much more tightly because the product is coded to produce a fixed outcome.
- In Muse, Alex has to think more about the system, architecture, and scaffolding that shape outcomes rather than about one exact screen that every person will see.
- He described this as both difficult and liberating. The output may not be pixel-perfect every time, but it can still be highly useful.
For PMs and designers, this means the design problem shifts upward. The job is less about specifying every pixel and more about specifying constraints, fallback behavior, data flows, and user trust signals.
Mental Models & Frameworks
Entity-first interaction design
Ask one framing question before choosing an AI interaction pattern: if the user were speaking with another person, how would this exchange work?
- Use it when deciding whether an experience should feel like messaging, search, workflow software, or a dashboard.
- The model pushes teams to think about turn-taking, acknowledgments, memory, interruption, and identity.
- Muse used this model to justify message bubbles, a visible character, proactive outreach, and an ongoing main conversation.
Three-layer status ladder
This is Muse's clearest reusable framework.
- Layer 1: confirm that work has started.
- Layer 2: explain the current task in plain language.
- Layer 3: reveal deeper action history for auditing, debugging, or expert trust.
Use this framework when one AI product must work for both mainstream users and power users. It avoids the false choice between total opacity and constant trace spam.
Stable shell, dynamic interior
Keep the product structure stable while letting AI personalize what appears inside it.
- The shell includes the surfaces a user learns over time, such as chat, feed, ideas, and avatar states.
- The dynamic interior includes suggestions, content, labels, summaries, and personalized outputs.
- This model is useful when a team wants generative UI benefits without making the product feel random every time it opens.
Reformat buried personal data
Look for user data that is already emotionally or practically valuable but trapped in a poor format.
- Saved posts, old blogs, practice logs, shopping interests, and game history all fit this pattern.
- The agent's job is not just retrieval. The agent should re-render the material as a catalog, coach, dashboard, recap, or feed.
- Use this model when the product has access to rich historical data and needs a stronger repeat-use loop than one-off chat answers.
Decision Principles
Principle: Hide technical detail
- When: building for mainstream users who care about the result more than the internal process.
- Why: detailed traces are valuable for auditing and debugging, but they become noise when shown by default. Muse keeps the detail available without requiring every user to parse it.
Principle: Fix latency first
- When: a team is adding more narration or reasoning text to reduce user anxiety during waiting periods.
- Why: Muse suggests that a quick acknowledgment plus a fast system is often better UX than a verbose explanation of every intermediate step.
Principle: Default to one thread
- When: the product is trying to feel like a persistent relationship and the model can retain enough context to support it.
- Why: a canonical conversation makes the agent feel continuous. Separate threads still help with organization, but they should solve a real user need, not inherit a convention from older AI apps.
Trade-offs & Nuance
Transparency versus calm
Showing more system detail can build trust, but it can also make the product feel louder and more technical than necessary.
- Muse solves this by letting the casual user stay at the reassurance layer.
- Muse still preserves deeper inspection for users who need auditability.
- The trade-off is not honesty versus simplicity. The real trade-off is default cognitive load versus optional depth.
One thread versus order
A single main chat gives continuity, memory, and a more human feel. Side chats give clarity, isolation, and easier organization.
Alex does not present one model as fully solved. He prefers the current Muse direction, but he also says the architecture still needs work so users better understand why each mode exists.
Polish versus usefulness
Generated artifacts will often be useful before they are perfectly polished.
- Alex described having to relax the old design instinct to tune every visual detail.
- That does not mean quality stops mattering. It means quality shifts toward stronger scaffolding, better personalization, and better utility.
- Teams still need high standards on the fixed parts of the experience, especially navigation, status, trust cues, and fallback behavior.
Common Mistakes
Mistake: Port enterprise patterns
Many AI teams start with the patterns they know from coding tools or knowledge-work apps.
- That often leads to products full of threads, files, diffs, traces, and connectors as the primary experience.
- Alex's work on Muse suggests those concepts can be too technical or too abstract for mainstream consumer use.
- The better approach is to choose primitives that match the user's mental model, even if that means leaving familiar AI conventions behind.
Mistake: Expose every trace
Teams often surface reasoning or action detail by default because they want to prove the agent is working.
That can backfire. The chat becomes cluttered, technical, and harder to scan. Muse's answer is to keep the main surface calm, then let users drill into detail when they want more confidence or auditability.
Mistake: Design fixed screens
Treating agent experiences like deterministic UI flows causes teams to over-specify surface details and under-specify the system beneath them.
The better approach is to design the scaffolding: what data is available, what states exist, how the user can inspect progress, how outputs get organized, and what happens when results are imperfect.
Practical Application
Map your user primitives
Before the next design review, list the core nouns in your AI product.
- Include labels such as thread, project, connector, prompt, agent, memory, or diff.
- Mark which nouns come from the system architecture rather than from the user's natural mental model.
- Rewrite at least one major workflow using a more familiar frame, such as messaging, assistant, coach, journal, or feed.
Build layered status states
Create a status system that answers progressively deeper questions.
- Start with a binary reassurance state, such as working or done.
- Add a plain-language task description, such as comparing strollers or researching local classes.
- Add a deeper audit view for support teams, power users, and debugging.
- Keep detailed system actions out of the default chat unless the audience truly needs them there.
Use connectors for delight
Look for one external data source that users already care about but rarely revisit.
- Saved posts, browsing lists, practice logs, old writing, or purchase watchlists are good candidates.
- Generate a recurring artifact from that data, not just an answer on request.
- A daily catalog, weekly recap, or personal coach gives the product a reason to re-enter the user's life.
Keep frames, generate inside
If your team wants to add generative UI, start with bounded surfaces.
- Keep navigation, layout, and main primitives stable enough for habit formation.
- Let AI personalize the contents of those surfaces, such as suggestions, summaries, feed items, or visual states.
- Treat fully dynamic layouts as a later-stage exploration, not the default starting point.
Test main versus side
Do not assume your thread model is obvious.
- Run usability sessions where participants solve the same tasks using a single ongoing chat in one version and fresh side threads in another version.
- Ask users to explain why they chose a given conversation space.
- Measure not just completion, but also later retrieval, perceived continuity, and confidence about where information lives.
Questions to Consider
- Which parts of your AI product still speak the language of builders, such as threads, connectors, or diffs, instead of the language of the mainstream user you want to serve?
- Where is slow model or tool performance pushing your team to add more narrated reasoning, when a faster response plus a simpler status system might solve the real problem better?
- What user data in your product is currently stored, ignored, and rarely revisited, but could become a recurring artifact such as a memory feed, a coach, or a shopping catalog?
- If your agent kept one canonical conversation instead of starting a new thread for every task, would users feel more continuity or more confusion?
- Which parts of your AI experience truly need pixel-perfect control, and which parts only need strong scaffolding plus a useful output?
Bottom Line
Muse shows that consumer AI design works best when the product feels less like a technical console and more like a familiar relationship. The winning pattern is a fast, calm shell with layered transparency, plus personalized artifacts created from the user's own data, while the team accepts that AI outputs inside that shell will never be perfectly fixed.
Resources Mentioned
| Resource | Type | Why it was mentioned |
|---|---|---|
| The Wayback Machine | Website | Alex used it to recover posts from a blog he had written roughly 20 years earlier so Muse could turn the writing into a new, usable format. |
| SkyMall / Sharper Image aesthetic | Reference | Alex used the look and language of old SkyMall-style catalogs as the visual frame for a Muse-generated shopping surface built from Instagram saves. |
Concepts to Explore
Generative UI
Generative UI here does not mean a totally different product every time the app opens. In Muse, generative UI means keeping a stable product structure while letting AI generate personalized contents, states, and suggestions inside it. This is the practical version most PMs can ship today.
Progressive disclosure
Progressive disclosure means revealing complexity only when the user asks for it or needs it. Muse applies it to status, letting a casual user see only a simple working state while still allowing a technical user to inspect deeper actions.
Non-deterministic interfaces
A non-deterministic interface is one where the output can vary meaningfully from user to user or from run to run. Alex's design advice follows from this reality: specify the scaffolding, trust signals, and boundaries well, because the exact artifact cannot be designed the way fixed software screens once were.
Case Studies Mentioned
Instagram saves as catalog
Alex had Muse inspect years of saved Instagram posts, organize them, and then turn the output into a daily shopping catalog rendered in a SkyMall-like style. The product lesson is that an agent can create delight by turning a messy archive into a recurring surface with both utility and personality.
Golf data as coach
Alex records every round and tracks individual shots on a watch, which gives Muse detailed golf data to work with. Muse turns the raw records into round recaps, visual explanations of where a score improved or collapsed, and practice breakdowns that are much easier to act on than a plain scorecard or machine readout.
Old blog as podcast
Alex used the Wayback Machine to recover a long-abandoned blog, had Muse gather the posts into a single source, and then converted the writing into a daily audio format he now prefers consuming. The product lesson is that AI can unlock dormant personal archives by changing the format, not just by retrieving the file.
Chess games as dashboard
Muse pulls in Alex's chess history and renders a dashboard that combines game-by-game analysis with trend views over time. The useful pattern is that hobby data becomes far more motivating when it is turned into a coach-like surface rather than left inside a generic activity log.
Tools & Products
| Tool / Product | What it does | Why it was mentioned |
|---|---|---|
| Meta Muse | Meta's consumer AI agent | It is the main subject of the episode and the product Alex helped design. |
| Social platform with saved posts and stories | Alex uses Instagram data as a rich personal dataset for shopping ideas, memory feeds, and other Muse outputs. | |
| Visual discovery platform | Claire mentions using Pinterest boards with agents to generate concepts and language from visual inspiration. | |
| Chess.com | Online chess platform | Alex uses chess game data from Chess.com to create a dashboard and coaching-style analysis in Muse. |
People to Follow
Alex Cornell
Alex Cornell is a design director at Meta leading design on Muse. He is especially worth following for concrete, public thinking on consumer agent UX, including status design, generative UI boundaries, personalization, and how AI changes the designer's job.
Experiments to Try
Experiment: Hidden trace default
- Hypothesis: mainstream users will feel more clarity and equal or greater trust when detailed action traces are hidden behind a tap instead of shown in the main chat.
- Change: move system actions into a layered status view while keeping a simple working state and a plain-language task description visible by default.
- Test: compare the current interface against the layered-status version in a moderated usability study and an A/B test.
- Measure: task completion, reported trust, time to understand what the agent is doing, and drop-off during long tasks.
Experiment: Saved content digest
- Hypothesis: users will return more often when an agent turns saved content into a recurring artifact rather than waiting for users to ask for retrieval.
- Change: generate a weekly digest from one rich data source such as saved posts, bookmarks, or old notes.
- Test: offer the digest to a small cohort and compare it with a control group that only has standard search or chat access to the same data.
- Measure: weekly return rate, open rate, repeat creation of new digests, and downstream actions such as clicks, purchases, or shares.
Experiment: Single main chat
- Hypothesis: a canonical ongoing conversation will make the agent feel more personal and easier to use than a product that starts every task in a fresh thread.
- Change: make one version of the product default to a persistent main chat and another version default to new threads for each task.
- Test: have new users complete a mix of short tasks and ongoing tasks over several days.
- Measure: perceived continuity, retrieval success, confusion about where work lives, and the percentage of users who voluntarily create side chats.
