What Building a Team of AI Agents Taught Me About Marketing

Source: Midjourney

Building a team of AI agents taught me that the biggest opportunity in marketing isn't creating more content or running more campaigns—it's designing better systems.

Over three months, I built a six-agent workflow to analyze customer reviews at scale in a heavily regulated environment where compliance mattered as much as performance.

What started as an automation project quickly became something else: a lesson in systems thinking. The experience exposed gaps in how work flows through marketing organizations, revealed why AI struggles with ambiguity, and fundamentally changed how I think about GTM execution.

Key Takeaways

Building AI agents taught me five things:

1. AI exposes process weaknesses that humans often work around.

2. Agent workflows require explicit definitions of quality and ownership.

3. Observability matters more than automation.

4. Cost efficiency is as important as functionality.

5. Systems thinking is becoming a core GTM skill.

I'm a GTM marketer. Positioning, campaigns, pipeline, reviews: that's been my world for years, and I'm good with working in it. So this isn't a story about trading that identity in for a new one. It's about what happened when I spent three months of nights and weekends, March to mid-June, building a team of AI agents and getting them to work together, and how it added a lens to my work that I now can't imagine operating without.

My entry point was much simpler: I started using AI to move faster.

At first it was tactical. Writing support. Brainstorming. Cleaning up messy thinking. The usual early wins. Then it crept into bigger things: pressure-testing strategy, connecting dots across campaigns, wrangling the kind of sprawling projects that don't fit neatly into a single channel.

That's when something started to shift. And the agent project is what pushed it all the way over.

Fair warning: it was harder than anyone tells you. Or maybe I just missed that message.

It Started With Reviews

In my last post I wrote about reputation management as the new top of the funnel: customer reviews as trust markers, gold for your brand, especially as search reshapes itself around AI.

I stand behind that, and the data keeps piling up behind it.

• Google zero-click searches hit 68% in early 2026. Buyers increasingly never leave the answer page, so what AI says about you is the funnel. 

• And what feeds those answers? Ahrefs research across 75,000 brands found that brands in the top quartile of earned mentions pull a median 169 AI Overview citations versus 14 for the next quartile (a 12× gap driven by entity strength, not domain authority) and that active review-platform profiles roughly triple a brand's citation probability. 

• Omniscient Digital's analysis of 23,000+ sources puts it even more bluntly: 57% of citations for branded queries go to reviews, listicles, forums, and social proof, while brand-owned content earns just 23%. Reviews aren't a vanity metric anymore. They're citation infrastructure.

But the longer I sat with it, the more I realized the numbers weren't the interesting part.

Behind every public review is a person's story, and even a two-line snippet can carry the whole arc of a brand: the doubt, the decision, the outcome.

The question that wouldn't leave me alone was: how do you mine that? At scale? Without flattening it?

That question became my project.

I enrolled in an AI automation course in March and used the standard pre-set project to get started. But midway through I hit a wall and while I completed 95% of the work, didn't feel confident about the result.

I took the course again in May, this time focusing on reputation management automation, and finished.

It was a real problem, too: a project in a heavily regulated industry, with thousands of customer reviews scattered across public-facing sites such as TrustPilot, Google, and Reddit. The goal was a workflow that could “mine” those reviews for usable social proof and do it without ever letting the wrong testimonial through.

What I Actually Built

By the end, the project had evolved into a six-agent reputation management workflow built to analyze thousands of customer reviews and identify usable social proof without letting risky or non-compliant testimonials slip through.

One agent pulls in reviews from wildly different sources; a tidy five-star Google review and a rambling Reddit thread arrive in completely different shapes. Others assess quality: is there a concrete detail here, a real story, or just generic praise? Others enforce compliance: flagged language, dollar amounts, outcome claims, the stuff that turns a testimonial into a liability.

Each agent has a role, a handoff, and a definition of "good." Reviews that survive the gauntlet come out the other side as verified, compliant, usable proof. Reviews that don't make it get rejected with a reason attached.

Written down like that, it sounds clean.

It was not clean.

The Hard Part Nobody Puts In The Demo

Start with the vocabulary. I came into this as a marketer, and the on-ramp was a wall of terms nobody pauses to explain: setting up a terminal, working in Git, writing markdown, reading JSON. Somewhere in week three I learned the difference between camelCase and snake_case and genuinely wondered: does everyone know this besides me? Then there's the tooling itself: Cassidy, Copilot, Claude Code, each with its own logic and quirks. None of it is hard in isolation. All of it at once, while also trying to build something real, is disorienting in a way that no "anyone can build agents!" post prepares you for.

This is where the structure of the AI Build course earned its keep. Left alone, I would have wandered, or quit like I nearly did the first time. Having a track to run on, and feedback arriving at each stage telling me what was working and what I was fooling myself about, is what kept a steep learning curve from becoming a cliff.

Here's an honest sample from my build log.

The course materials were built around a specific type of project, and mine didn't fit. That meant learning and iterating on the fly, sometimes in a vacuum, hoping I didn't break things and have to start over. That sounds empowering in retrospect. In the moment it mostly felt like being lost.

The low point was when I kept testing over and over because I wasn't seeing results logged in my final spreadsheet. I attacked it from every angle: file formats, sharing permissions, headers, variable bindings. At one point my AI assistant confidently told me something that didn't match what I could see on my own screen, and I had to push back on it and trust my eyes. The eventual cause? The system had been working the whole time. Junk rows were just pushing my results out of view.

Lesson learned: a working system that looks broken will eat more hours than a broken one, because you're debugging something that isn't there.

And the first time through this course? A version of that same wall is exactly what stopped me. The difference this time wasn't that I'd gotten smarter. It's that I'd learned to trace problems to their actual cause instead of their apparent one, and learned that eight hours grinding on one problem isn't determination, it's stubbornness.

Now when I hit a snag my process is this: time-box it, flag it, and move on.

The Breakthrough That Made Everything Click

The breakthrough that made everything click was almost boring: I added a step that surfaced every rejected review alongside the exact reason it was gated out, with a column where I marked whether I agreed with the call.

Suddenly I could see the system deciding.

I could watch my compliance agents do their jobs, review by review, and check their judgment against mine. That's the moment it stopped being a black box I hoped was working and became a system I could trust, simply because I could observe it.

Image source: Midjourney

The Meter Running In The Background

One thing ran underneath every decision I made, start to finish: compute costs.

Every run burns credits, and I watched that meter constantly. It forced a question I never see in breathless posts about agentic AI: it's not enough to build a workflow that works. You have to build one that works efficiently, both while you're building it and every time it runs in production. A batch job is pointless if each run torches a pile of credits. Nobody implements that. Nobody pays for that twice.

So cost became part of the architecture, not an afterthought. I learned to read credit burn the way you'd read any other health metric. And the day I ran a hundred reviews through the full pipeline and the cost-per-review came in at roughly half of what processing them one at a time would have cost, I knew the system was actually designed right, not just functioning. I consider that a huge win, maybe the win. Anyone can make AI do a thing. Making it do the thing at a unit cost that survives contact with a budget is the part that makes it real.

What Building AI Agents Did To My Thinking

Somewhere in those three months, the project stopped being about reviews.

When you build a team of agents, you're forced to be explicit about everything marketing usually leaves implicit. Roles. Responsibilities. Handoffs. What "good" looks like at each step. How information moves, not just what gets produced.

You can't wave at it; an agent can't read the room. Vague intentions that a human colleague would paper over become visible failures.

AI didn't just give me leverage. It exposed the gaps.

It made visible all the invisible seams in how marketing actually happens: where context gets lost, where decisions stall, where work gets duplicated, where insights never quite make it to the next step. And once you see those seams, you can't unsee them, whether in your workflows or your org chart.

Why AI Is Making Systems Thinking A Core GTM Skill

That came into sharper focus during a conversation with Dave Steer, CMO at Webflow, who said something simple that stuck with me: "Treat marketing as a team sport."

Not a new idea on the surface; marketing has always been cross-functional. But a team sport isn't about having multiple players. It's about how they play together: the handoffs, the shared context, the feedback loops, the way the system adapts mid-game. That's precisely what I'd spent three months hand-building, agent by agent.

The big, hairy projects I'd struggled with before weren't failing for lack of effort or strategy.

They struggled because no one ever designed the system that moved work across people, tools, and now AI.

And that's when it clicked: the real challenge was never how to do marketing better. It was how to design the system that does the marketing.

Building AI agents didn't teach me how to automate marketing. It taught me how marketing systems actually work.

A recent Forbes piece, The End of Functional GTM Leadership and the Rise of System Thinkers, put a name to what I'd been living. The title alone stopped me, because it described the exact shift I'd stumbled into from the bottom up: GTM leadership, at least how I practiced it before, was about driving outcomes through teams, channels, and campaigns. Systems thinking shifts the lens: it's about designing how those pieces interact, so outcomes emerge more reliably and with less friction.

I'm still early. Most of what I build is imperfect, and some of it breaks in ways that are frustratingly human. But I no longer believe systems thinking is a grand philosophical shift reserved for people with whiteboards full of arrows. It's a practical response to complexity, and you can start with three questions:

How does the work actually flow?

Where does it break?

And what happens if I redesign that, now that AI is part of the team?

Conclusion

If you'd told me in March that a pile of customer reviews would change how I think about my entire discipline, I'd have laughed.

But that's the journey I'm on now: less about doing more marketing, and more about building a system. A team, really. One that transforms to fit each new project, and transforms how the work actually gets done.

I've never been so happy to get a certificate!