All work

AI agents built to move enterprise work forward

Designing an enterprise AI agent platform where teams build, evaluate, deploy, observe, govern and measure agents in one visual workspace.

Client
Gamma: Agent OS
Role
Senior Product Designer
Team
1 PM, 8 engineers 1 ML engineer
Read
3 min
The Agent OS workflow editor: user message, AI assistant and output nodes on a canvas
−48%
Time to publish an agent
−40%
Token cost per execution
120+
Agents in production in 6 months
4.7/5
Admin satisfaction score

The short version

Context
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.
Problem
Agents were changed without testing, published straight to production and monitored by nobody. No one could tell which agents were running, whether a change made them better, what they cost or who had approved what.
What I did
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.
Impact
Interviews with builders, admins, support leads and security teams across 9 enterprise customers shaped a lifecycle model, one product area for each stage.

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.

Wireframe of the workflow editor: start and step nodes, the agent card, the run action and the canvas toolbar, numbered
Wireframe flow: a trace picked in the traces list opens its execution tree and inputs and outputs
Traces screen spec: icon rail, header, gutters, KPI cards, filters and table rows with their sizes and spacing
Traces: every run with latency, cost, tokens and feedback
Guardrails for personal data, toxic content and grounding, next to the human approvals queue

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.

The workflow editor in dark mode
Evaluator experiments comparing agent versions, next to versions and deployments across environments
“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.

Project analytics and costs per model and per agent
Audit logs of every action by people, agents and API keys, next to the knowledge base sources
A trace replayed span by span in dark mode

What changed

−48%
Time to publish an agent
−40%
Token cost per execution
120+
Agents in production in 6 months
4.7/5
Admin satisfaction score

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.

Luna•3 min

One token architecture for iOS and Android.

PipeDesk•3 min

A sales pipeline that stays current everywhere.

Magnum SCD•3 min

A digital account built for the mobile-first generation.