How I Designed a 3-Agent System to Support My Day-to-Day Work

The issue was never whether AI can generate something quickly. It can.

The real problem is the gap between acceptable and usable. Most AI outputs are acceptable. Very few are usable, by my standards. And I spent months burning cycles in that gap — drafting, reviewing, rewriting, prompting again — before I accepted that the problem wasn’t the prompts. It was the structure.

So I built one.

Why the Switching Was the Problem

My work as a Marketing Head isn’t linear. On any given day, I move between research, execution, and decision-making. I switched from content writing to Marketing Ops to Performance Marketing in the same afternoon. Each requires a different way of thinking.

The problem isn’t the work itself. It’s what happens when you ask a single AI to follow you through all of it.

Every new context means re-explaining your constraints, redefining what good looks like, and rebuilding consistency from scratch. The AI doesn’t know you’re now in performance mode, not brand mode. It doesn’t know this brief needs to be conservative because the market is new. It just responds to what’s in front of it.

That creates cycles. And cycles are where time dies.

What I Built

I mapped how I actually work into three distinct roles, then enforced them as separate agents running inside Claude Projects. The logic was simple: inputs, interpretation, and output are three different jobs. Collapsing them into a single agent introduces noise. Separating them removes it.

Each agent lives as a defined role within the Project. Mira sits in the custom instructions as the permanent gatekeeper. The system doesn’t require a separate tool or platform. Anyone with Claude can build this.

Agent Kabee — the Manager

Kabee handles inputs. That’s it. He pulls information, gathers data, and identifies what we know and what we’re missing. He doesn’t interpret. He doesn’t recommend. If Kabee starts analyzing, he’s doing the wrong job.

Agent Deen Wong — the Director

Deen Wong takes what Kabee surfaces and structures it. He identifies trade-offs, maps the options, and organizes the thinking. He doesn’t redo research. He doesn’t produce the final output. He builds the frame that Mira will work from.

Agent Mira — VP of Marketing

Mira is where the quality control lives. She challenges assumptions, fills gaps, and connects the pieces. She’s the only one who produces the final output. And she’s the gatekeeper — she coordinates, challenges, and decides what gets passed to me.

Mira is also designed as a replica of me. She’s built to reflect how I think, what I prioritize, and what usable looks like by my standards. That’s what separates her from a generic AI output layer. She isn’t just synthesizing. She’s synthesizing the way I would.

But Mira doesn’t execute anything without my confirmation. Recommendations are for review. Actions happen only after approval. That’s a hard constraint.

Me — the CMO

I define the tasks, the constraints, and the requirements. I make the decisions. The system doesn’t make decisions for me. It makes it possible for me to make better ones, faster.

Why Three Agents and Not One

This is the question worth answering honestly.

A well-written single agent with a detailed prompt can get you far. I tried that. The problem is that having one agent do all three jobs — gathering, interpreting, and synthesizing — starts to blend them together. Research bleeds into analysis. Analysis bleeds into output. And by the time you get a result, you can’t tell where something went wrong, only that it did.

Separating the roles creates visible failure points. When the output is off, I can trace it. Did Kabee miss something? Did Deen Wong structure it wrong? Did Mira make an assumption that wasn’t challenged? That traceability matters more than most people think, because fixing a broken system requires knowing which part broke.

It also forces clarity on what each role actually does. Kabee doesn’t analyze because he can’t — that’s not his job. That constraint isn’t a limitation. It’s what keeps the system clean.

What It Looks Like in Practice

Here’s how the system runs on a real task: building a Google Search Ads campaign.

Most workflows go wrong before they even start because no one defines what “done” actually looks like. Mira fixes that first.

Before anything is delegated, Mira defines what needs to be delivered: campaign structure, keyword strategy, ad copy, landing page direction, and performance assumptions. Then the work gets distributed.

Kabee pulls keyword themes, intent clusters, CPC benchmarks, and supporting data. He doesn’t decide which keywords to use. He brings what’s needed.

Deen Wong structures the campaigns and ad groups, identifies the real trade-offs — coverage versus intent, cost versus volume — and organizes the options clearly. He doesn’t pick a direction. He maps them.

Mira takes all of it, challenges what’s missing, closes the gaps, and produces a single consolidated campaign plan. Not a draft that needs to be restructured. A usable plan.

I review it. I set the priorities and budget. I decide what we launch.

Then Mira coordinates what goes next. Ad copy gets drafted or structured for generation. Image requirements get defined for asset creation. Campaign setup gets structured for platform upload. Every step waits for confirmation before it moves.

The Part That Actually Drives Quality

People read about systems like this and assume the system does the work.

It doesn’t. The system handles the first pass. What drives quality is what I do after that.

When something is off, I don’t rebuild it. I tell the agents what’s wrong, why it doesn’t meet the standard, and exactly what needs to change. That feedback is specific. Not “this isn’t good enough.” More like: “The keyword clusters are too broad for the intent we’re targeting. We need tighter commercial-intent terms for this audience, not informational. Here’s why that matters for CPC.”

The next cycle improves. But that’s not the model learning. That’s the model responding to a better context. The distinction matters.

If the conversation ends and that context isn’t saved, the correction disappears. So I treat feedback as something that needs to be captured, not just given. Corrections that reveal a pattern get documented. References get updated. And when Mira’s behavior drifts from my standard in a consistent way, that’s a signal her instructions need updating, not just a one-time fix in chat.

That update has to come from me, deliberately. Mira can’t rewrite her own instructions. She operates within them. That boundary is intentional. If she could update herself based on conversation feedback, her behavior would drift in directions I didn’t approve of. For a replica meant to reflect my standards, that’s a problem.

So the maintenance is mine. I correct. I document. I update when the pattern calls for it. The system improves because I deliberately improve it.

That’s the actual work. And it’s also why the CMO title isn’t just a label. The system reflects my standards because I actively maintain them.

What This Actually Changes

Before this system, writing a single blog post with AI took me 4+ hours. That included prompting, reviewing, rewriting to strip out the AI tone, restructuring the content, and getting it to a point where I’d actually publish it. Most of that time wasn’t creative work. It was correction work.

With the system, a blog post goes from brief to usable draft in under an hour. The time doesn’t disappear. It shifts. I spend it evaluating and deciding, not rebuilding from scratch.

That difference compounds across every task. Campaigns, briefs, plans, copy. The output type changes, but the pattern holds: less time producing, more time deciding. That’s where the leverage is.

On Cost

Three agents use more tokens than one. That’s real.

The trade-off holds when the structure is tight. Defined roles and hard boundaries mean inputs stay constrained, roles don’t overlap, and outputs don’t need to be rebuilt. Less duplication. Lower token usage than a sprawling single-agent setup that loops because it keeps losing context.

If the system cuts 4 hours down to under one, the token cost is worth having.

What Changed

Before: I started from zero every time. Draft, restructure, rethink, rewrite, repeat. Most of my time went into producing, not deciding.

Now: I define the task, review the output, adjust it, and decide. The work shifted from generating to evaluating.

The number of cycles dropped. The quality bar moved up. And the system stays sharp because I keep it that way.

Notes: This is a personal experiment with AI systems. It reflects how I approach my own work and does not represent any company practices or policies.