When AI is the UI, design moves underneath

David Sacks, on All-In after the Salesforce × Anthropic Claudeforce moment, put it plainly: Benioff is willing to let Claude own the front end — the primary user relationship — because customers want to create agents in the AI they already live in, that then run across SaaS. The bet is not “rip and replace.” Systems of record still hold canonical truth. Probabilistic models don’t. Karl Mehta amplified the clip on X the day it was circulating again: the AI is now the user interface.

That framing asks an older question in a new costume: what place is there for design — for the designer — when AI becomes the primary UI?

Not “still draw screens.” Judgment, constraints, and interaction design for agents. The job shifts. It does not disappear.

The substrate still needs a designer

If the agent is the front door, something coherent has to sit behind it.

Systems of record are not just databases. They are models of the domain: entities, relationships, ownership, permissions, audit trails, what “done” means, what a human must approve. Agents read and write that substrate. If the information architecture is muddy, the agent invents. If permissions are vague, the agent overreaches or stalls. If there is no trust surface — who changed what, under which policy — enterprise buyers walk.

That is classic design work with sharper stakes. Coherent IA. Permission models people can reason about. Empty states and error states that encode policy, not just copy. Auditability as a product requirement, not a compliance afterthought. Head of Design work I have done for years maps here: synthesizing support and analytics into hard constraints, turning research digests into decision rules, writing specs that engineering can ship and that an agent can execute without improvising the dangerous parts.

You do not get a trustworthy agent by polishing chrome on a SaaS shell. You get it by designing the record the agent is allowed to touch.

The agent UI is a product surface

Streaming chat is not “no UI.” It is a denser interaction design problem.

The moments that matter in agentic UX are not the happy-path reply. They are:

• Show the plan before the agent acts.
• Chunk-by-chunk accept so a diff, a tool call, or a proposed write lands as something you can take or leave in pieces.
• One-key stop — interrupt without hunting a menu.
• Missing-constraint ask — one specific question instead of a hallucinated default.
• Human handoff when the agent is out of its depth.

Those are interaction design under a new contract. Generative UI — panels, annotations, viz updates driven by the agent — still needs shared state, progressive disclosure, and a clear relay from click → structured context → next turn. Human-in-the-loop is not a slogan; it is the control surface.

AG-UI (Agent–User Interaction Protocol) is the emerging open standard for that loop: how agents talk to people through a real application UI. MCP is how agents reach tools and data. A2A is how agents talk to other agents. AG-UI is the event stream for text, tool calls, state, and user actions flowing both ways. I treat it as part of methodology now — a shared contract between product and engineering so we stop inventing a custom wire for every “show the plan / accept the chunk / stop / ask / hand off” moment.

When I design agentic UX for complex technical products, those moments are the design. Behavior first, composition second. The protocol is how the team ships the loop without reinventing it.

Brand shows up in how the agent speaks

Product and brand as one system does not collapse when the front door moves.

If AI owns the primary relationship, brand is no longer mostly logos in SaaS chrome. It shows up in:

• What the agent is allowed to promise.
• How it sounds when it is unsure.
• When it refuses.
• How a handoff feels when a human takes over.
• Whether empty states, failure traces, and confirmation copy still read as one company.

I ran brand and product as one pipeline at Plume (Head of Brand, then Head of Design), and I still do: messaging hierarchy, voice rules, and the product’s uncertain states come from the same pillars. An agent that overclaims is a brand failure. An agent that hedges honestly and hands off cleanly is brand doing its job.

Design leadership here is taste plus governance: voice-and-honesty rubrics for agent transcripts, design reviews of agent behavior, decision capture next to the ticket that ships — stop / revise / scale — so the system does not quietly drift.

Disintermediation is a design problem

Benioff’s willingness to risk Claude as the front end is a strategy call. For product teams, the same pressure shows up as a set of design questions:

• What must stay in the dedicated app because the work needs density, spatial layout, or continuous attention?
• What should agents do elsewhere — in the AI the customer already lives in — because that is where intent starts?
• When do we pull the user into a dedicated surface: review a high-stakes write, resolve a conflict, inspect a graph, approve a permission change?
• How do we progressively disclose control so power users can steer without dumping a cockpit on everyone?

“Let the agent do it” without an answer to those questions is abdication. “Keep everything in our chrome” without an answer is nostalgia. The design job is the boundary: what the agent may do, what it must show, when the product reclaims the user’s attention, and how that reclaim does not feel like a trap.

That is progressive disclosure of control. Same craft as progressive disclosure of information, aimed at agency instead of density.

What Head of Design work looks like in this world

The deliverables change shape. The judgment does not.

I still synthesize support, analytics, and session notes into constraints the team can build against. I still run design reviews — now of agent plans, tool-call sequences, and failure scripts, not only of frames. I still capture decisions with an evidence rule attached. I still write specs: agent-turn scripts, state lists, acceptance criteria that both engineers and agents can execute. I still own roadmaps where the riskiest assumption sits next to the bet.

None of that is “prompting as a career.” It is design leadership at agent speed: ask for outcomes, encode the constraints, review the behavior, keep product and brand coherent when the primary UI is a conversation that can write to the system of record.

When AI is the UI, the designer’s job is the substrate, the loop, and the brand promise — not the leftover chrome.

Closing

If you are hiring a Head of Design for an agentic product, look for someone who has already treated product and brand as one system, who designs failure and handoff as carefully as the happy path, and who can turn messy signal into constraints an agent will not invent around.

That is the place for design when AI becomes the primary UI. Underneath. Inside the loop. In the promise.

Source note

Spark (factual attribution, not a news recap): Karl Mehta on X, 2026-10-15 — https://x.com/karlmehta/status/2110730000169357617 — quoting David Sacks on the All-In Podcast (~2026-08-29, Salesforce × Anthropic / Claudeforce context): Benioff integrating Salesforce into Claude, willing to let Claude be the front end / primary user relationship; systems of record still required (“not a rip and replace”); framing that the AI is now the user interface.