At IBM I led the interaction patterns for enterprise AI agents: where they enter the work, how people check what they found, and how answers become work people can edit and act on.
AI was a mandate across the portfolio, but teams had no shared way to make agent output trustworthy inside real enterprise work.
Treat AI output as work to verify and edit, not a chat reply: agents inside the workspace, scaffolded prompts, every result linked to its source.
A reusable pattern set for agent entry, prompting, verification and structured output that product teams could apply across surfaces.
The job was not to add AI features. It was to find where AI could create workflow value, how users could verify and control what it produced, and how design standards could scale across product teams.
At the same time, the design organization was moving from embedded team support to a Design-as-a-Service model with clearer intake, stronger governance and more consistent quality across a large portfolio.
Find enterprise workflows where AI could cut manual search, interpretation and repetitive document work.
Define how users invoke agents, review plans, inspect reasoning, verify sources and convert responses into work.
Repeatable guidance through advisory rituals, audits, reusable patterns and shared quality standards.
I led the organization and stayed hands-on in the pattern work. These are the parts I owned directly.
Defined with AI and data science partners the model behaviors, transparency moments, guardrails, and the correction and recovery paths users need.
Defined core interaction patterns for agent entry, prompt scaffolding, reasoning visibility, verification and structured output, and extended Carbon with AI-specific patterns.
Built a Watson chatbot and a Python REST layer for Watson myself, alongside the design work.
Led a 14-person design organization, designers through managers, working with 10+ product leaders and 50+ engineers. One of six executives on the committee that moved the division to Design-as-a-Service, live in about three months.
Each one traded a simpler build for something enterprise users needed: orientation, a way to start, control over the result, and evidence.
Agents entered through the product’s existing navigation instead of a separate assistant window.
Why: users already knew where their documents lived. Keeping that orientation made the agent an extension of the work rather than a detour from it.
Quick starters and task-shaped prompt suggestions showed what the assistant could do before asking users to phrase anything.
Why: an empty prompt box asks enterprise users to guess the right words. Starting points make capability concrete without removing natural language.
Results came back as structured tables users could refine, including columns and extracted fields, then move into the workspace.
Why: a chat answer gets copied into another tool and loses its context. A table people can edit stays in the system where the next action happens.
Verification patterns connected each extracted value back to the document it came from.
Why: people act on AI output only when they can check it. Source inspection keeps human judgment in the loop before anything is relied on.
One representative flow: a user asks a search agent for contracts renewing in a given quarter that also contain automatic-renewal language. Select any image to expand it.
The workspace was document-heavy, structured and familiar. Agents arrived inside its navigation model, so capability grew without costing orientation.
A dense enterprise content environment before the agent flow.
The existing workspace users already knew.Agents sit within product navigation, not outside the workflow.
Entry inside the navigation model preserves orientation.Quick starters introduce what the assistant can do. Suggested prompts turn common enterprise tasks into starting points users can adjust.
Capabilities introduced through guided entry points.
Quick starters before the first prompt.Task-shaped suggestions that keep natural-language flexibility.
Suggested prompts make capability concrete.The design problem was what happens after the prompt: showing the agent’s work, returning results as structured data, and letting people verify and keep working.
Users refine the output and inspect evidence before relying on it.
Users adjust column structure and extracted fields before acting.
AI output as a user-controlled artifact.Each result connects back to the document it came from.
Inspect the evidence before relying on it.Results move into the workspace as lists people can refine and act on, without copying AI output into another tool.
Written to support many product teams, not to solve one screen.
Meet users inside the systems where their work already happens.
Show what the agent found, what it inferred, and where it came from.
A good response becomes a table, a list, a workspace object or a next action.
Support editing, verification, correction and follow-through.
Agent behavior, prompts, verification states and outputs work across products.
The work turned AI from an abstract ambition into a practical design language: where agents enter, how users guide and verify output, how results become structured work, and how teams apply the same standard across products.
These screens follow the success path. For uncertainty, failure and correction, try the pricing assistant prototype I built in October 2026.
“AI becomes real when teams can turn it into workflows people trust.”