George Kavuma

Every agent gets a state: Draft, Testing, Live. NextGen AI

NDS Logistics live at about $60K closed. 3 agent states in production. Cycle time 2 to 3 days across 8 sprints.

The agents page rebuilt on shadcn components and design tokens: the same dark screen with one restrained palette. Sample data.
The shadcn version, in the productThe same screen rebuilt on shadcn components and tokens. One rule now: color follows meaning.
Role
Product Experience Lead, first product hire
Client
NextGen AI Technologies, enterprise AI agent platform
Discipline
Workflow design, interaction design, design system
Team
7 developers I manage, in two pods: platform, and agent runtime
Status
NDS Logistics live. Release 1.7 shipped July 2026.
Year
January 2026 to present

An agent is Draft, Testing, or Live, and the customer's admin decides which.

The situation

NextGen AI is an enterprise AI platform. Companies use it to run agents that do a business process for them. I joined on January 15, 2026 as the first product hire, and the brief was one line: we need the 2.0 version of the platform, make it more usable.

I spent January on analysis. I used Claude Code to read the codebase and Cursor to start the design system. In March I spent a week in Florida with the lead developer, working out how we would build together. In April I went to Albania to sit with the developers and co-lead the team with him.

The problem

Version 1.0 was a form. A customer filled in what they wanted the agent to do, the way you would fill in a Google Form, and then developers wired it up by hand in the backend. It was the same kind of work I did at my first UX job.

The customer got their change fast. The developers paid for it. Every new customer project pulled every developer off whatever they were building, and what they were building got forgotten. Two to three years of tickets had piled up that way, and nobody could say what should be built next.

The constraint

The company was small and chaotic, and the idea of the product lived in everyone's head at once. Roles were not defined, so the same decision got made three times by three people. The industrial client's project was running the whole time and could not stop.

I was also on the sales calls. Whatever a customer asked for had to land in the roadmap the same week, or it went back into the developers' heads and out again.

What I tried first

The first thing I did was draw where the platform was going, not what it should look like. NextGen Studio: a workflow builder where anyone creates an agent by having a conversation with it. The agent asks you for what it needs, you answer, and the connectors are the only thing you wire by hand.

That first cut was high level and full of AI jargon. It showed the developers the direction, and that was its job.

The decision

The average person needs to be able to create an agent with the least intervention possible. The agent should ask them for the information it needs, and let them give it. Building an agent should not feel like patching cables on a modular synth. It should feel like the conversation they would have had with us.

To get the team there, I split it into two pods. Platform developers own the architecture, backend and frontend. Agent runtime developers build the agents our customers run and the APIs that reach outside the platform. We moved to two-week sprints, brought in an SDLC consultant, and cleaned up Jira so a ticket meant one thing.

The design system shipped first and the developers reference it now when they make changes. Agents carry a state: Draft, Testing, or Live, shown as a pill on the agent card.

In Draft you can talk to the agent but it reaches nothing outside. In Testing it can hit connectors, phone numbers, and APIs. The organization admin moves it between states, not a developer.

When NDS Logistics asked for a driver-hiring agent, we met on a Tuesday and they said yes to the designs on Thursday. That agent hires and manages their contracted drivers, from hiring to firing, and keeps their records and background checks current. It closed at about $60K.

What I refused

Demos for companies that did not want agentic processes. Every one of those demos pulled developers onto work we did not need. I said we focus on one product, the industrial one, because those customers had walked us to the finish line of what they wanted and most other sales calls were unsure.

Letting developers be the only people who could put an agent live. Before the states existed, there was no testing, because the people flipping the switch were the people who built it.

What I traded away

Closed deals have slowed, and so has demo work. I am sure about not chasing clients who pull developers off the product, and that shows in the pipeline: about $60K closed and about $100K in pipeline today, down from the number the page used to claim. The industrial client I told the company to focus on took the product in-house.

Cycle time has held at two to three days across eight sprints and average velocity rose from 54 points to 68. Unplanned work is still a third of every sprint. The conversational Studio is still an idea in a room, not a screen. The biggest thing live today is the billing page, and Stripe is being built so customers can pay without a billing cycle.

The design system shipped first, and it is on its third version.

The agents page on version 1.6: five header buttons in five colors, teal, green, purple, and blue, on a dark theme.
Version 1.6, where I startedThe platform I joined. Five buttons, five colors, and no rule saying which meant what.
The same agents page in the 2.5 prototype: a light theme, serif page title, one purple action button, and a filterable agent table. Sample data.
The 2.5 prototypeThe direction we drew for 2.5: lighter and calmer, one action that matters. We kept it and rebuilt it in the product.
The pattern library home: an index rail on the left, who it is for, how to review a screen, and three ideas behind every entry.
The pattern library, the third iterationThe third iteration of the design system I have created. The C-suite and product managers can review a screen with it.
The stat tile entry: the Looks wrong if checklist, five lines a reviewer checks against the screen, and why the entry exists.
Looks wrong if, on every entryEvery entry ends with a checklist. A manager reads it against the screen and tells us the line that does not match.
The run limit entry: a run stopped at the limit of 25 with 15 of 40 rows left, when to use the notice, and the do and do not pair.
Run limit noticeSome runs stopped at their limit and the screen said Completed. Now it says the limit, what was done, and what is left.
The Studio playground: a workflow of four steps, two needing attention, a history panel, and a row of failure scenarios to try.
The Studio playgroundA working copy of Studio with what goes wrong: the save fails, the connection drops, another editor takes the lock.

You describe the agent, and Prime builds it. In build since October 2026.

New customers signed up, landed on an empty dashboard, and never found agents. This is the Studio idea becoming screens, in three stages: today, the onboarding flow, then the simplified platform.

The platform today: a new organization's dashboard with zero agents and a sidebar of more than twenty pages.
Today: first loginA new admin lands here with zero agents and never finds them.
Creating an agent today: a type picker and a long form with name, department, role, and knowledge base fields.
Today: creating an agentThe only path to an agent is a type picker, then a long form.
In build: the Build your first agent modal on first login. Prime asks who is on the other end of the call and what rules the agent should follow, with starter ideas to begin from. Interaction design.
In build: first loginPrime opens first and interviews you. Three or four questions, and it infers the rest.
The review card: the agent's first line, what it does, its rules, and its tone in plain language, marked Not live. Interaction design.
The draftThe agent in plain language, starting in Draft. Nothing goes live without this confirm.
The first test: call your new phone agent from the browser, with three test calls of up to three minutes each. Interaction design.
One real testYou call your own agent from the browser, then land on its page.
The simplified platform: an agent picker and six sections on the left, one agent's overview and flow in the middle, the rest of the platform behind a drawer. Interaction design.
The final version: one agent at a timeThe simplified platform. One agent in the middle, and the rest behind a drawer.
In the simplified version, New agent opens a chat with Prime that fills the workspace and builds the agent from the interview. Interaction design.
The form becomes a conversationNew agent opens a chat, and the interview replaces the form.
The Setup page: the agent's decision flow as steps and branches on a canvas, each branch a plain-language condition. Interaction design.
Setup, step by stepEvery step and branch in plain language, at a grade 10 reading level.

Working branches with sample data. No customer names. October 2026.

What shipped, and what is in build.

Shipped: the WCAG AA design system. Developers reference it when they make changes.

Shipped: the three agent states, Draft, Testing, and Live. The NDS Logistics driver-hiring agent runs on them.

Release 1.7 shipped in July 2026. A release every two weeks since. NDS is on the current version.

In build: Stripe. A second NDS agent is waiting on their budget sign-off.

NDS Logistics is named with permission. Other client workflows and revenue figures are sanitized.

Outcome.

Live 1 client in production. NDS Logistics: a driver-hiring agent, hiring to firing, records and background checks.
Closed About $60K closed. NDS Logistics. Met on a Tuesday, yes to the designs on Thursday.
Pipeline About $100K. The industrial client I told the company to focus on took the product in-house.
Shipped 3 agent states in production. Draft, Testing, Live. The customer's admin switches them.
Shipped 1 design system. WCAG AA, built from zero. Developers reference it when they make changes.
Verified 2 to 3 days cycle time. Held across sprints 4 to 11.
Verified 54 to 68 points. Average velocity, sprints 4 to 11.
Verified 90 percent to near zero. Unestimated tickets, April to mid August.
Team 7 developers. Two pods, platform and agent runtime. Two-week sprints since April 16, 2026.