Agents hold your standard at speed.

Everyone has an AI story now, and most of them sound the same. A team plugs a model into the workflow. Output goes up. Three months later the product looks like everyone else’s. Faster, yes. Theirs, no.

That isn’t a tooling problem. It’s a question of what the agents are held to.

Here’s the belief we run the studio on: AI made interfaces cheap to generate and expensive to make feel authored. A screen costs almost nothing to produce now. Making it feel like someone decided it costs what it always did: judgment, time, and a person willing to say no. Agents are how you hold authorship at that speed. They are not a way to skip it.

The volume isn’t the hard part

Look at where design hours actually go on a product team. Not the big calls. The volume. The fifteenth variant of a settings screen. The empty state for a filter nobody uses. Spacing fixes across forty components. Copy that has to match a voice doc someone wrote a year ago and nobody reads.

That work matters. It’s also where standards quietly die, because it’s repetitive and there’s a lot of it. A tired designer at 6pm reaches for the default. So does a model with nothing to go on.

So we split the work in two. Agents take the routine volume. Senior people own taste and decisions. The split sounds obvious. How you enforce it is the part most teams skip.

Agents work inside your system, not the internet’s

When we bring agents into client work, they don’t generate from a blank page. They work inside the client’s own design system and design rules. Their tokens. Their components. Their voice.

And their refuses. A refuse is a falsifiable “we will never” rule with a reason attached. “No gradient headlines; our category is loud and we’re the calm one.” “One primary action per screen, because our users are deciding under pressure.” Rules like that are something an agent can actually be held to. A mood board isn’t. A brand doc full of adjectives isn’t. “Clean and modern” means nothing to a model, because nearly every screen it has ever seen was described that way.

The standard is what the agents are held to, so the standard has to be written down. Tokens for every visual value. Components with real states. Refuses with reasons. If the standard only lives in someone’s head, the agent can’t see it, and it fills the gap with the average.

That’s the real work at the start of an engagement. Before an agent produces anything, we make the standard legible to it.

Every output gets a person

Agents propose. People decide.

Every piece of agent output in our client work is reviewed by a person before it goes anywhere. Not skimmed. Reviewed against the same rules the agent was given, by someone senior enough to kill it. Some of it ships. Some of it goes back. Some of it gets thrown out because it’s correct and still not right.

That last pile is the one that matters. An agent can follow every token and every rule and still land on something nobody would choose. Catching that is taste, and taste stays with people. Review isn’t a step we tolerate to keep the agents honest. It’s the job.

What it gives back

Done this way, agents give back about half of design hours. That’s time that used to disappear into volume.

We don’t just bank it as speed. We spend it on the decisions that were getting squeezed: the pricing page, the moment of commitment in onboarding, the one screen that has to feel like nobody else’s. The places where average doesn’t close.

So the pitch isn’t “we’re faster because AI.” It’s that the senior people on your product spend their hours on the calls that need them, and everything else is held to a standard they wrote.

We built the same thing for ourselves

We run this in our own tools too. Pod, our AI client portal, uses multi-model research agents, design system audits and UX insight stories for the teams we work with. Same principle. The agents do the reading, the checking and the first pass. People make the call.

Building it taught us where agents break. They drift when the rules are vague. They drift faster when nobody reviews. They get genuinely useful when the system they work inside is specific and a person is watching what comes out.

Start with the standard, not the tool

If you’re adding agents to your product team this quarter, don’t start by picking a model.

Write down your tokens if they aren’t already. Write five refuses, each with a reason. Name who reviews agent output and what they check it against. Then let the agents take the volume.

Skip that step and you’ll still get speed. You’ll also get a product that could belong to anyone.

Speed was never the hard part. Holding the line at speed is.