Carlos

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

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

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.

Trace list with indicators
Trace detail: the execution tree
Monitors and an incident with a probable cause

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.

Guardrail policies and recent triggers
Versions, environments and gradual rollout
Costs and budgets per agent
Experiments and version comparison
The workflow editor in the dark theme

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

−48%

Time to publish an agent

−40%

Token cost per execution

120+

Agents in production in 6 months

4.7/5

Admin satisfaction score

Next case study

Luna Design System

One token source for Apple and Material, light and dark.