The Problem Nobody Talks About
Everyone's writing about AI agents doing creative work. Generating copy. Making images. Drafting strategy.
That's not where the real problem is.
The real problem is coordination. When you run four product lines — each with distinct audiences, price points, and sales channels — across email, paid social, affiliate, and wholesale, with three people and a few external partners, the work isn't hard. Keeping track of the work is hard.
What's running right now across all brands? Who's working on what? Did that email actually go out? Is the evergreen ad still spending? When the team goes heads-down on a launch, what stopped getting attention?
Nobody can answer these questions without a 30-minute investigation. Spreadsheets get abandoned. Project management tools get ignored by the people who actually need to use them. Status lives in chat threads nobody reads back.
That's the control problem. And it's the one I decided to solve with agents.
Why Spreadsheets Fail Here
The first instinct is always a spreadsheet. Or Airtable. Or Notion. Some structured grid where everyone enters their status.
It doesn't work. Not because the tool is bad — because the workflow demands that creative people stop doing creative work to update a database. Designers don't want to open Airtable. They want to be in Figma. Forcing them into a tracking tool means the tool is always behind, and the "source of truth" is actually the source of last Tuesday's truth.
The insight: the tracking tool should not require humans to feed it. The humans should keep doing their work. The system should figure out what's happening by watching.
The Architecture
I already had a fleet of specialized agents running — each one wired to a different marketing system. One reads the ad platform APIs. One tracks email performance. One monitors the sales pipeline. One manages content. They already know what's happening. They just weren't synthesizing it into one picture.
The control system adds a coordination layer on top of the existing fleet:
No agent talks directly to another agent. They write their outputs to a shared database. The orchestrator reads everything and produces one coherent picture. The humans interact with the orchestrator — not with the data layer.
The Lane System
With four brands and a small team, you can't go full-throttle on everything. Someone has to decide what gets attention this week. I call this "lanes."
Hero: The brand getting everything. Full-funnel activation. New creative, dedicated email sequence, affiliates briefed, wholesale outreach. This is a launch or a major push. Max one brand at a time.
Support: One channel gets attention. Everything else holds. Maybe it's a single email send or one new ad variant. Partial team time, not dedicated.
Autopilot: Evergreen creative and email flows running on their own. No human touch. The agent fleet monitors it and fires an alert if something stops. This is where brands go dark without warning — the monitoring exists to prevent that.
One command sets the lanes. The entire fleet adjusts its output based on the current priority. The ad agent focuses budget recommendations on the Hero brand. The content agent prioritizes Hero brand copy. The email agent sequences the Hero launch. Everything else runs on its existing momentum.
The Interface is the Conversation
Here's where it gets interesting. Nobody opens a database. Nobody fills out a status form. People talk to the agent in whatever app they already live in.
The marketing director tells the agent in Slack: "Reebok launch email is scheduled for Thursday." The agent logs it. The creative director replies to a Monday thread: "Assets approved." The agent records it. The designer says: "Template done." Status chain updates automatically.
Every Monday morning, the orchestrator posts a structured check-in to the team channel. Here's what should be happening this week. Here's what the APIs say is actually running. Three questions — one for each person. Reply in thread.
Every Wednesday, the agent checks that all autopilot items are still running. If everything's green — silence. If something stopped — one clear alert.
Every Friday, the agent compiles everything: ad spend by brand, email performance, pipeline movement, team check-in responses, blockers. One report. Automatically generated from real data, not from people remembering to update a spreadsheet.
The operator gets a compressed digest on their phone. Numbers and blockers. That's it.
Why This Works Better Than a Dashboard Alone
Dashboards are pull. You have to go look at them. In my experience, even the best dashboard gets checked for two weeks and then forgotten.
This system is push. It comes to you. The Monday check-in appears in your Slack before your first coffee. The Wednesday alert interrupts you only if something broke. The Friday report arrives whether or not you asked for it.
The dashboard still exists — for when you want to drill in. Brand cards showing current lanes and key metrics. Email timeline. Ad performance sparklines. But the dashboard is the backup, not the primary interface.
The primary interface is a conversation with an agent that already knows everything because it reads every other agent's output.
The Role Clarity Problem
One thing the system forced me to solve: unclear ownership between the creative director and the marketing director. Both are involved in "campaigns." Both have opinions. Without clear boundaries, things either get done twice or fall through.
The fix: split ownership by decision type. The creative director owns what things look and sound like. The marketing director owns what goes out, when, to whom, and why. The handoff has a defined protocol with status stages — briefed, in production, designed, scheduled, sent — and the agent tracks the chain. If something stalls, the agent flags it. No chasing. No "where are the assets?" messages.
Clear ownership isn't a management philosophy exercise. It's a data model decision. When you can't define who owns what in a database schema, you can't automate the coordination.
What Changes
Before: piecing together status from five different apps and a dozen chat threads. After: one Friday message with everything, generated from live API data, without asking anyone for an update.
Before: brands going dark for weeks because the team was heads-down on a launch. After: the agent checks every autopilot item twice a week and alerts immediately when something stops.
Before: "update the spreadsheet" as a standing meeting action item that never happens. After: people talk. The agent records. The database stays current because the interface is a conversation, not a form.
The agents don't replace the marketing team. They replace the project management overhead that eats 30% of a small team's week. The team does creative work. The agents track it.
Wispr · jabondano · 🦞