Back to work
AI Studio at Rocketium. Designers decide, agents execute.

Designers were spending their days executing decisions they had already made.

September 14, 2025

I designed the agentic system that took 5,000+ creatives from 3-5 business days to 15-20 minutes, without taking a single decision away from the designer.

Role
Product Designer, end to end
Timeline
3 months
Team
PMs, Engineers and Founders
Impact
100% adoption (managed services), 80% (self-serve)

Context

A brief arrives. Nobody agrees on what a brief is.

Rocketium is a creative production platform for teams that make advertising at scale. Think thousands of ads, one campaign, and a deadline that was yesterday.

It all starts with a brief. Sometimes it's an email. Sometimes a PDF, a Figma file, or a Google Sheet. There is no standard format, so the designer does what designers do: reads it, decodes it, and gets going. Then the routine kicks in, from setting up a template to adding sizes and variants each time to running bulk operations.

A pile of briefs in every format (urgent emails, PDFs, a Google Sheet, media assets) beside a designer working through nine boxes, from template to delivery.

For a single customer, that was already a full day. And designers rarely had a single customer. They ran campaigns in parallel, scaling to 5,000 creatives, sometimes past 12,000.

The craft was still in there somewhere. It was just buried under execution.

A designer resting their chin on their hand, saying “It takes more time to put all the pieces of information together than the creative work itself.”

Problem statement

Rocketium already had an AI co-pilot. Nobody needed it.

It looked like the right idea. A chat window, an assistant, a little sparkle of intelligence. In practice it was a command menu wearing a chat interface. Fixed queries. No open input. No follow-ups.

The old co-pilot, a chat window with preset prompts, a CSV upload and a mapping table.No follow upsFixed interactionNo open input

Creative work is a conversation. You try something, react, adjust, try again. The co-pilot could not hold up its end of that. Worse, everything it could do was already one click away in the product. Asking the co-pilot was slower than just pressing the button.

So designers did the sensible thing. They ignored it, and kept working around it.

Then the technology caught up. The opportunity was never to automate designers out of the process. It was to take on the repetitive execution and leave every meaningful decision in the designer's hands.

Role and scope

One designer. Three months. No playbook.

Nobody had built this before, so nobody had a template for it. That meant the job was bigger than screens.

I sat with the design team and mapped how they actually worked. I ran the workshops with the founders that shaped what the agents should feel like. I worked with engineering on what agents could and couldn't do. I set the design principles. Then I designed the interface, tested it with the people who would live in it, and rebuilt it when it failed.

The process in six steps. Research, workshops, principles, design, test, rebuild.

Research and discovery

Before designing anything, I sat and watched.

Engineering had already proven that agents could handle isolated tasks. Creating a brief. Flagging missing fonts. The technology was ready. What nobody had mapped was the full human workflow it was supposed to replace.

So I spent several days sitting with Rocketium's in-house design team. Every action. Every switch between tools. Every workaround.

Then one moment made everything clear.

To add content variants, designers exported editor data into a Google Sheet, edited it outside the product, and imported it back in. A round trip out of the tool and back, just to do something the product should have handled itself.

It wasn't a quirk. It was a symptom. Repetitive, judgment-free execution had quietly eaten the entire day.

Nine steps made up the workflow. Not one needed an original creative decision. The brief format never changed. The size selection never changed. The auto-adapt logic never changed. Designers weren't making choices. They were performing them.

That became the principle: every step that requires no creative judgment belongs to an agent.

A designer looking at nine faded boxes of busywork, and the five steps that are left for them. Confirm details, project setup, content, auto adapt, review.

Finding the principles

The hard part wasn't what the agents would do. It was how working with them should feel.

Features are easy to list. Feelings are not. So I ran three exercises with the founding team to find out what we actually believed. Some of those conversations were not comfortable.

We went looking for something familiar. Not what the agent would do technically, but how it should behave as a presence in a designer's day. The team threw out 40+ analogies. Most fell apart under pressure. Three survived.

The analogy workshop board. Three phases of instructions and a wall of sticky notes, each naming an analogy such as power steering, muscle memory and sous-chef.

Next, no features and no functionality. Just convictions. What does a good outcome look like? What does a bad one look like? Where is the line between helping a designer and replacing one?

The team wrote 30 statements. Four survived. One changed everything: the agent should never make a decision the designer hasn't already made themselves.

The belief statement board from the workshop.

This was the sharpest conversation of the project. The founders wanted the agents visibly working. Long outputs. Visible processing. Proof, for investors and demos, that something real was happening behind the interface. It was a fair instinct. This was also a product that had to be sold.

But the PMs and I pushed back. A designer doesn't care how the agent works. They care whether the job got done. Watching a machine think doesn't build trust. It builds cognitive load.

The anti-pitch board from the workshop.

That argument drew the clearest line of the entire project: the agent's work should be invisible. Only its output should exist.

Design principles

Three lines I refused to cross.

The three analogies that survived the exercise became the principles. Each one is a feeling first and a rule second.

Nobody thinks about how they type. It just happens. The agent's process should never demand the designer's attention. No long outputs. No visible processing. Only the result. The work should feel like muscle memory, not machinery.

A good sous-chef preps, chops, and plates. They never decide what's on the menu. Every repetitive, judgment-free step belongs to the agent. Every creative call stays with the designer. That line does not move.

It makes the car easier to drive, but you still choose where it goes. The designer can pause, redirect, or override at any point. The agent proposes. The human confirms. When the designer is working manually, the agent stays out of the way.

Muscle memory. A designer typing at a desk while formatting, resizing and aligning happen around them. Invisible work, visible output.
The sous-chef. The agent preps while the designer decides what is on the menu.
Power steering. The designer holds the wheel and chooses the direction.

Iteration 1

The first version wasn't designed for experience. It was designed to prove the system worked.

So the agent became a layer on top of the product, reachable from anywhere. Open it and the chat transformed into a split view. Conversation on the left. Artifact on the right.

The question was simple:

How might we run the entire production workflow, brief to creatives, inside a single agentic conversation?

Every agent action produced an artifact. The designer reviewed it, changed what they wanted, and clicked Proceed. That one click was the human in the loop. It confirmed the output, triggered the next agent, and moved the workflow forward.

Iteration 1. The chat on the left and a campaign breakdown table on the right, with the note “Agent output. Designer reviews.”

It was not pretty. The agent's thinking was fragmented and unreadable. The response structure was unclear. When the agent stopped at an artifact, nobody knew what it was waiting for. And the visual design, boxed in by markup language limitations, looked like it belonged to a different product.

Iteration 1. Sizes and layouts on the right with a confirm button, with the note “One click. Human in the loop.”

Some of that was a choice. Showing the raw processing output was a conscious compromise, because hiding it would have taken engineering significantly longer.

Iteration 1. Three long chat panels of agent thinking, with the note “The breaking point. Too much to read before acting.”

I decided to validate the workflow first and fix the experience after.

It worked. One designer said they could now go from a brief to creatives in a single conversation, with four or five clicks.

The system was right. The experience needed to be rebuilt from the ground up.

Reading the signals

Within weeks, designers asked for the old co-pilot back.

That was the signal. Not that the system had failed, but that the experience had. The workflow was right. The interface was getting in its own way.

To find out why, I stopped guessing and ran an observed workshop with the design team. Each designer worked through their real campaigns. Their own briefs, their own customers, their own sizes and languages. No controlled scenarios. The PMs and I just watched.

The observed workshop. The design team around a meeting table, working through their own campaigns.

The breaking point showed up within minutes. The first agent response landed with an artifact beside it. On the left, a wall of thinking: verbose processing text, then the AI's answer. On the right, the artifact, waiting for review.

Designers read everything on the left, felt overwhelmed, and clicked Proceed without looking at the artifact at all.

An overwhelmed designer at a laptop, saying “Wait, I needed to update the template.”

The interface was pulling attention to the wrong place at the wrong moment. The thinking was noise. The artifact was the signal. Nothing in the design told them apart.

The foundation was sound. I had one job: make the interface as invisible as the agents were supposed to be.

What was broken

  • Verbose AI thinking created cognitive overload
  • Users didn't know what the artifact was waiting for
  • Loading time compounded anxiety
  • AI responses were hard to parse
  • GenAI felt too abstract. No tactile control.

What was working

  • Content table replaced the Google Sheet entirely
  • Briefs came in prefilled
  • Multiple projects created in one workflow
  • Infinite canvas for side by side creative review
  • Reviewers could comment directly in the same space

Iteration 2

Every decision was a direct response to a specific failure.

Before any screen was designed, the thinking happened first. The workshop gave me five failures. Each one got a decision.

Wireframes sketched in marker directly on a wooden desk, next to a laptop.
Close-ups of the desk sketches. The chat layout and the artifact panel.

  • A plan, not a wall of text

    Before any agent moves, the designer sees exactly what is about to happen: a checklist of every step, visible from the first message. This replaced the verbose thinking that overwhelmed people in Iteration 1. Instead of watching the agent process, the designer understands the intent upfront and tracks progress against it.

    The new chat with a plan of action checklist, visible before any agent moves.

  • A response with a clear shape.

    Every AI response now follows one structure: an opening statement, an artifact, a closing statement with clear next actions. The artifact card says where it stands. Awaiting action. Action taken. A loader for work in progress. A timer to give a sense of pace. Nothing is ambiguous, and nobody is left wondering what the agent is waiting for.

    An AI response with an opening statement, an artifact card with its status, and a closing statement with next actions.

  • The work moved out of the conversation.

    All agent activity now lives inside the artifact, not the chat. Each artifact has two modes. Preview shows the output.

    The artifact in Preview mode, showing the output.

  • The work moved out of the conversation.

    Activity shows the agents at work. By default, the designer is always in Preview. Activity is there for anyone who wants to look, and nobody has to.

    The artifact in Activity mode, showing the agents at work.

  • Some tasks don’t need a chat at all.

    Certain workflows open directly into an artifact. Every action happens inside it. The chat stays closed until the designer needs it, and only then does it appear.

    That was not a layout decision. It was the design principle made real.

    A workflow that opens directly into an artifact, with the chat closed.

  • One status indicator.

    All system feedback collapsed into a single indicator. Enough to orient. Not enough to interrupt.

    The single status indicator that replaces all other system feedback.

Impact

The numbers. And what they actually meant.

  • 100%adoption in managed services
  • 80%adoption in self serve
  • 15-20minsFor 5000+ ads down from 3-5 days

Those are the figures. Here is what they meant.

Adoption at that level isn't a launch metric. Designers had walked away from the old co-pilot within weeks. This time they stayed, because the agents did the execution and left the decisions alone.

The time drop is the same story. Three to five days of assembling, resizing, and repeating became a coffee break. The designers didn't get faster. The work that never needed them stopped existing.

Then the messages started arriving, unprompted:

  • The AI Studio team was thanked for delivering 5,000+ creatives across pilots and campaigns, including a single campaign of about 2,000, on top of regular work.
  • Another team was recognised for delivering around 50,000 creatives in two months at a 1.40% average error rate and a 2.5-hour average turnaround, handling nearly 20 projects a day for one customer alone.
  • A customer account exceeded its QBR milestones "by a distance," and the momentum prompted a partner agency to pursue a partnership in parallel.
Four redacted messages of thanks from customers and teams.

The craft was no longer buried under execution.

Learnings

What I'd do differently. And what the industry still gets wrong.

If I started this project again, I would trust my design judgment from day one.

The experience failures in Iteration 1 were not technical limitations. They were interpreted as technical limitations. That distinction cost us adoption, and it cost us time.

The deeper lesson is about agentic design itself. There is no shortage of conversation about what agents can do. There is almost none about what they cannot. Agents hallucinate. They produce wrong outputs. They make confident mistakes.

That is exactly where the human belongs. Not as a formality. Not just at the start and the end. At every moment where judgment is required.

The role of the designer doesn't disappear in an agentic world. It shifts, from executor to decision maker. The craft doesn't go away. It finally gets the space it always deserved.

A designer and a small robot thinking side by side, surrounded by pictures, a lightbulb between them.