Gamma
AI agents built to move enterprise work forward

Companies wanted to put AI agents to work across support, sales, operations and finance, but each team was stitching together prompts, scripts and API keys on its own.
I led the design of an enterprise platform that covers the whole life of an agent: build it on a visual canvas, evaluate it against real cases, deploy it gradually, observe every run, govern it with guardrails and human approvals, and measure its cost.
- UX research
- Interaction design
- UI & design system
- Prototyping
Process
From problem to delivery, step by step.
06stages documented in this case
- 01Wireframes
Before any screen was styled, the core flows were laid out in low fidelity: the workflow canvas, the traces list and the trace it opens.
- 02Build
A visual builder lets anyone connect inputs, an AI model, knowledge and real tools such as Gmail on a canvas, then run the flow and watch each…
- 03Evaluate, deploy, observe
Experiments compare every new version with production on real cases, and releases move to production gradually, with automatic rollback if error,…
- 04Observability
An agent in production needs to be explainable.
- 05Governance
Enterprises only scale what they can govern.
- 06What I learned
Make the invisible visible: trust in AI comes from evidence, so every run, change and cost had to be something people could see and replay.
Wireframes
Before any screen was styled, the core flows were laid out in low fidelity: the workflow canvas, the traces list and the trace it opens. The wireframes settled hierarchy and density first, and the shortest path from a failing run to its cause.
The spec then turned them into numbers engineering could build from: a 54 px icon rail, 28 px page gutters, 16 px between blocks, 38 px controls and 62 px table rows, all on an 8-point rhythm and taken straight from the Figma auto layout.





Build
A visual builder lets anyone connect inputs, an AI model, knowledge and real tools such as Gmail on a canvas, then run the flow and watch each step before publishing.
Business teams that understood the work could finally build agents themselves, without waiting weeks for engineering.


I can explain the process in five minutes. I just can’t turn it into an agent without waiting weeks for engineering.
Operations manager, enterprise customer
Evaluate, deploy, observe
Experiments compare every new version with production on real cases, and releases move to production gradually, with automatic rollback if error, latency or cost leave their limits.
Once live, every run becomes a trace that can be replayed span by span, with automatic evaluations on each answer.



Observability
An agent in production needs to be explainable. Tracing shows each execution as a tree: what the agent received, which tools it called, how long each step took and what it cost. Monitors turn that data into alerts with a probable cause, not just a red number.



Governance
Enterprises only scale what they can govern. Guardrails are written as policies anyone can read, versions go out in gradual rollouts and budgets show cost per agent, so security, engineering and finance look at the same product.





What I learned
Make the invisible visible: trust in AI comes from evidence, so every run, change and cost had to be something people could see and replay.
Governance is part of the UX. Guardrails, approvals and audit logs designed in from the start turned security from a blocker into a reason to adopt.
Results
Time to publish an agent
Token cost per execution
Agents in production in 6 months
Admin satisfaction score
