For decades, Setup made admins come to it: hundreds of pages to navigate and dig through just to find the one thing they needed. Agentforce for Setup inverts that. Instead of sending people hunting, it brings what they need to them, a conversational interface that interprets intent and renders the right components on the fly by pulling from the metadata already in the org. I helped design that agentic layer, shifting the admin experience from manual navigation to natural dialogue.
This is human-AI interaction at its most consequential: an agent acting directly on a customer's production system. The design challenge wasn't just understanding intent; it was building the trust and control that let admins hand real configuration work to an AI.
Across the program, I led the observability experience on Setup Home, designed the agent's recommended utterances, and led user permissioning.
Agentforce for Setup is a large program. Here's where I went deepest, trust and the agent's on-ramp, and how the same pattern carried across the rest. Jump into any one.
Setup Home is the surface admins land on. I led its data visualizations and the agentic layer that turns a wall of nested menus into a place that brings the right components to you. It is also where the whole program had to read as one product, since the cards here are rendered from many teams' work.
A note on this screen: Setup Home is an amalgamation of many teams' work, and several of the cards shown here come from other teams rather than our designs. That's real evidence of cross-team alignment, and also exactly why I owned shared patterns across the program. The friction shows too: notice the competing primary buttons across the suggestion cards, where a clear hierarchy should point to a single next step. Driving toward the shared patterns that resolve that kind of inconsistency was a core part of the work.
Letting an AI change a production org is a trust problem before it's an interface problem. When the agent isn't certain it understands what an admin wants, it asks a clarifying question instead of guessing, so it never shows the wrong thing or acts on a bad assumption. Before any change is applied, the admin can preview exactly what it will do. Nothing touches the org until they confirm.
This wasn't a hunch. In pre-pilot research, admins' top concerns were exactly these: the agent making changes without confirmation, output they couldn't verify, and losing control of their org. Designing for trust was the way to turn that anxiety into adoption.
"I appreciate it when it comes back with confirmations or questions. When it says 'you requested this, the best way to accomplish it is this action, do you confirm?', that instills a lot of confidence."Pre-pilot research participant
A real request, start to finish. Each step on the left lights up as the agent works through it.
Recommended utterances are the on-ramp to the agent: the suggested things an admin can say to get started. In the pilot they were hardcoded and fired straight at the agent, which quietly broke trust, because admins could not control what the button sent and the message in the chat often did not match what they meant. For the beta, I led a research-driven redesign around experience, onboarding, and trust.
Stripped to its bones. Hover each highlighted area to see the call I made.
Others and I ran nine Beta 2 sessions on how admins launched a recommendation: a button that ran it immediately, and an arrow that pasted it into the composer to edit first.
Every call on this surface came back to trust: whether an admin could rely on what happened when they clicked.
Match what's shown to what's sent. The pill an admin reads and the utterance the agent receives have to be identical, so what they see is exactly what gets sent. Obvious in theory, but a real fight early on, when label and utterance had drifted and admins were sending something they'd never seen.
Relevant and actionable, or not shown at all. A recommendation an admin can't act on exposes the limits of the agent and chips away at confidence. Relevance was a trust decision.
Verbs or domains? Research came down clearly in favor of domains; the pull toward verb-led labels came mainly from some newer admins, for whom domains can read as jargon. We chose domains, five utterances each, which left room for fuller strings, and built them to start curated and then personalize to how each admin uses their org, with the personalization-engine team.
Two mental models, not one. On Setup Home, utterances are a starting point, the way ChatGPT or Gemini seed prompts before you know what to ask; inside a conversation they're contextual. I pushed the team to design for both instead of collapsing them into one pattern.
My take, and where it went next. Most admins expect a click to go straight to the agent, so I kept that and added the arrow as a separate edit path, with a clearer icon once research showed it confused people. Another designer later dropped the dual model so a click now lands in the composer first. I still see a case for the original expectation, and I respect the call they made.
A small surface on Setup Home, but more effort than almost anything I worked on, because it is where onboarding to the agent and trust in it begin. The patterns carried into the broader agentic design library.
Trust and recommended utterances were where I went deepest. The same agentic move carried across the other surfaces I owned: ask in plain language, and the agent returns a structured, actionable result right in the flow, with nothing applied until you confirm.
Metrics that start a conversation. I led the observability experience on Setup Home: org health, license availability, and storage. Each visualization doubles as an entry point to the agent, so an admin goes from seeing a number to asking about it and acting on it without leaving the page.
Lead Designer. Managing permissions and access control by talking to the agent instead of hand-assembling permission sets, profiles, and sharing rules. Access is the highest-stakes thing an admin touches, so it follows the trust pattern exactly: the agent drafts a clear, reviewable change, and nothing applies until the admin confirms. Shipped across two beta cycles in Spring '26.
Sole designer. Six months of change history used to mean exporting a CSV and parsing it by hand. I designed it as a conversation: ask “show me all changes by John Doe in the last 7 days,” and the agent returns a filtered, sorted table inline, then names exactly how to narrow it further.
This was a large, fast-moving launch: partners, PMs, and six scrum teams building in parallel. As the UX point of contact and Patterns Liaison, my job was to keep one coherent experience from fragmenting across all of them. In practice that meant collaborating across 15+ teams, including SLDS, Digital Wallet, Formula Management, Content Design, and Setup Audit Trail, and representing our work to the broader Agentic Patterns workgroup. Everything shipped while the patterns were still being written.
Owned the shared patterns so they stayed documented and consistently lived across every team, managing pattern changes to prevent the experience from fragmenting.
Acted as the bridge between the core UX vision and individual scrum teams, delivering tailored designs without breaking global standards.
Represented our team's agentic patterns to the broader Agentic Patterns workgroup, presenting our decisions and reconciling them with the standards forming across the company, so Setup's work strengthened the wider effort instead of diverging from it.
Represented Agentforce for Setup across two booths at Dreamforce: ran live product demos, delivered my team's Dreamforce presentation, and gathered feedback directly from admins and customers.

I flagged it from the start. Admins would need an onboarding flow and an obvious way to find the feature and turn it on, or a capable agent would sit unused.
It moved up the priority list later, and when it did, I already had a direction: a proposal built on an existing onboarding surface, with an exploration of how it could work.
Generally available June 2026, free to every admin tier. Featured by Salesforce Ben.
Looking back, I'd make one big call differently. We tried to ship every area at once for the pilot, when the smarter move would have been to pick a single surface, user access, or data models, or flows, and make that one work really well. Supporting that many scrum teams without a shared, reusable component library led to inconsistent implementation. Because the agent's underlying actions weren't built out as fully as they needed to be, it often misread intent and sent people to the wrong place, which is the fastest way to lose trust and lose users.
If we had spent that same energy going deep on one area and earning trust there first, I believe the outcome would have been stronger and far less chaotic. It's the clearest lesson I carry forward: with agents, focused depth and hard-won trust beat broad coverage every time.