In late 2025, MuleSoft made a strategic push into the AI and agentic space. The core design teams were fully committed to Agent Fabric, a new agent orchestration platform, which left a gap: the Anypoint Exchange Agent had no dedicated designer. I was brought in from the Salesforce Design team on a three-month loan with a clear mandate: establish the UX strategy, validate it fast, and leave behind a design foundation documented well enough that another designer could carry it forward without losing momentum.
Anypoint Exchange is MuleSoft's API marketplace, where developers and administrators manage hundreds of assets. The Agent was the first conversational AI experience on the platform, with no existing design system or pattern library to draw from. My job was to build the interaction framework from scratch, within an aggressive launch window, on a domain I was ramping on in real time.
The project was already in flight when I joined. The PM had completed initial discovery and written foundational user stories. My role was to bring UX strategy to a team that had momentum but needed a design lead who could move fast, ask the right questions, and make decisions with conviction. The work needed to be left in a state another designer could carry forward.
Because discovery was already underway when I joined, my first priority was to understand what the PM had found and figure out where the design thinking needed to go deeper. I reviewed existing research, mapped it against the user stories, and spent time with the PM to pressure-test the assumptions behind them.
What emerged was a clear picture of where users were running into walls. The pain clustered around a few recurring friction points that the existing product architecture could not solve.
How might we help users manage and discover their API assets through a conversational interface — without sacrificing the scale and control that enterprise administrators depend on?
I designed unmoderated usability tests structured around two personas that reflect the full asset lifecycle:
The Exchange Administrator: Manages catalog quality, enforces compliance standards, and performs "housekeeping" (deprecating old versions, ensuring documentation completeness across hundreds of assets).
The Developer: Seeks fast discovery and reusable assets to accelerate their own work.
To keep pace with the engineering timeline, I made an early call to broaden our recruitment criteria. The initial screening required deep Anypoint expertise, which would have slowed us down significantly. I shifted to participants with general API catalog experience instead, which gave us an immediate pool and let us validate core interaction patterns where domain literacy mattered more than platform familiarity. This kept the design process ahead of development rather than behind it.
Tests were structured around two themes: foundational interactions like opening and closing the panel, understanding AI suggestions, and rediscovering the agent; and complex multi-step workflows covering bulk operations, the double-panel concept, and reviewing AI-generated documentation drafts. Three main findings shaped the final design.
Before designing a single new component, I needed to understand what already existed. I audited the MuleSoft design system and Salesforce pattern library, mapping behaviors like panel interactions, confirmation dialogs, and status indicators to conversational use cases. The goal was to borrow before building. Where the existing patterns held up, I adapted them. Where they did not, I designed new ones, always keeping them grounded in the same visual logic as the rest of the platform. The goal was for the agent to feel native to the platform, not like a product bolted on from somewhere else.
The final result elevated how users interact with their API catalog, moving away from a static, search-and-browse experience toward something that actively works with them.
Administrators can now manage hundreds of assets through natural conversation, while developers get instant, context-aware answers without digging through documentation. The agent meets users where they are in the platform and responds to what they actually need in that moment.
First-time users often don't know where to start with a new AI interface. The welcome screen surfaces three curated prompts giving users an immediate entry point without requiring them to figure out what to ask. These are hand-picked to represent the most common starting points, not AI-generated.
Agent Max, the MuleSoft mascot, anchors the experience from that first screen. Usability testing showed his presence shifted user
sentiment, making the experience feel approachable rather than clinical. For an enterprise product asking users to trust AI with
their data, that first impression matters.
Users can ask natural language questions to instantly surface documentation, platform knowledge, and asset recommendations. Rather than hunting through menus or reading help docs, they get answers in context.
After every agent response, three suggested follow-up recommended prompts appear. The suggestions are AI-driven so they adapt to where the conversation has gone rather than following a scripted path.
The Exchange Agent proactively identifies assets that don't meet compliance standards due to missing documentation. Rather than flagging them one by one, it surfaces the full set and gives administrators a way to act on all of them at once by applying a
missing documentation tag. The agent always confirms before executing.
Once approved, the tags are applied across every affected asset, giving administrators a filtered view they can return to when they're ready to do the documentation work. The batch operation turns what would have been hours of manual housekeeping into a single reviewed action.
When a query matches more than one result, the Exchange Agent pauses before acting. It surfaces the matching options and prompts
the user to confirm which API they mean, so the correct asset is always targeted and never assumed. Once the user makes their selection and clicks "Delete Version," the action executes. The agent then provides a plain-language summary of what changed, giving users a clear picture of the outcome without having to trace it through the interface.
The agent always asks before acting. Whether the user is deprecating one asset or hundreds, no action executes without explicit
approval. Once the user approves, the action executes and the button disables, giving immediate feedback that the operation is complete. After every action, the agent provides a plain-language summary of what changed so users don't have to reconstruct the outcome from the interface.
My design work was completed and handed off within the project window. Engineering is currently in the spiking phase, with another designer now carrying the work forward into build. This project pushed me across multiple dimensions at once: no existing conversational AI patterns to draw from, an aggressive timeline, and a team already in motion. Ramping up quickly enough to set strategy, make credible design decisions, and identify opportunities the team had not yet considered, all while the work was already moving, is what made it demanding. These are the outcomes and reflections I'm taking away from it.
Shifting the team's relationship with research- The MuleSoft team had not done much usability testing before this project, largely viewing it as slow and resource-heavy. By introducing UserTesting.com and running quick validation rounds, I showed that feedback could come back in days rather than weeks. That shift in how the team thought about research felt like one of the more lasting things I contributed.
Building a conversational foundation- Prior to this project, MuleSoft lacked established conversational UI patterns. The interaction framework I designed, covering message alignment, thinking states, confirmation flows, and contextual prompts, now serves as the foundational standard for the MuleSoft Agentic Design System.
Shipping a pragmatic MVP without losing sight of the vision- Testing the double-panel concept revealed something more nuanced than a simple pass or fail. For administrators managing dozens of APIs at once, it was not the right fit. The volume made it impractical. But for smaller, more focused tasks requiring careful review and iteration, the concept showed real promise. The batch-tagging solution addressed the most pressing business need and was the right call for MVP. But the double-panel work wasn't wasted. It's documented, the thinking is intact, and I carried it forward. When I returned to my automation team and started working on other AI projects, it became a reference point I drew on directly.
Adapting quickly without losing design quality- API management is a specialized domain with its own vocabulary and mental models. Joining mid-project in an unfamiliar space means making peace with not having full context before making decisions, and you have to ramp up while the work is already moving. The approach that worked was moving fast on the things I could validate quickly, while being explicit with the PM about the things I was still learning. Trust is built through that honesty, not through projecting confidence you don't yet have. Ramping up quickly enough to make credible design decisions and identify opportunities the team hadn't yet considered, on a borrowed timeline, is the thing I'm most proud of from this project.
do the honors,
hover over the button!
