AI agents for marketing can draft, check and hand work to each other, and after 5 weeks of running ours on Claude Code the bottleneck was no longer the agents. It was me. Every draft came back to me, every decision waited for me, and the whole system moved at the speed of my reading.
This is part 2; part 1, on the file-based setup, describes how it started. By agent I mean a separate Claude Code session with its own role; the coordination lives in shared files, not in a framework. Here is how I turned that around: agents now hand work to each other, and I approve only the steps that are hard to undo.
What changed after 5 weeks of AI agents for marketing?
In part 1 the setup was still being built. Over the next 5 weeks it carried most of our marketing work: the website, the blog, posts on LinkedIn and X, our community, video, analytics and competitor research. Between 24 September and 29 October the folder's git history grew by more than 2,300 commits. In October alone that meant 48 post drafts and 55 post graphics.
The files from part 1 held up. What did not hold up was the shape of my own job. I was the router between agents and the reviewer of everything they made. That works with 4 agents. It stops working when there are more than 10 of them and they work in parallel.
What can a marketing director copy without an engineering team?
We are a software company, so we built this setup ourselves. A marketing team in a company of 200 people, with no developers of its own, would not run 14 Claude Code agents, and does not need to. 3 ideas carry over without any code:
- Sort the work by what a mistake costs. A draft post is cheap to redo. A price change sent to every customer is not.
- Keep 1 page of current rules. Whoever does the work, a person or an AI tool, reads the same page first.
- Turn every repeated correction into a written rule. If you correct the same thing twice, the rule is missing.
For a COO, the same lanes could apply beyond marketing, to offers, price lists or supplier emails. We have tested this only in our own marketing, so treat it as a hypothesis, not a result.
Should you split AI agents for marketing by channel or by responsibility?
The first change was more specialised agents, each with 1 responsibility.
A copywriting agent, split out of social media. Before, every agent wrote its own public text. The result was 5 slightly different voices and the same mistake repeated in several places. Now every public text, from posts and website pages to the brochure, direct messages and video scripts, goes through 1 copy agent with 1 order queue. An agent that needs text adds a row: what, for whom, where the facts come from, and when it is due.
A graphics agent with its own queue. 1 visual style for posts, blog thumbnails, brochures and link previews. It also writes the prompts for 3D objects, and I generate those myself in ChatGPT or Gemini.
New agents only when the work asked for them: video, Reddit and competitor research. Each one got a role card, a plan and a handoff note for its next session, exactly as in part 1.
The rule I use now: an agent gets 1 responsibility, not 1 channel. Writing is 1 responsibility, even if the text ends up in 6 places.
How do AI agents hand work to each other?
In part 1, everything went through me. Now the agents send each other short messages between sessions: "new order in your queue", "done, the file is here", "blocked, because...". These are Claude Code's own messages between local sessions. A session that is closed does not get them, which is 1 more reason the content always lives in files. The message is only the doorbell.
The coordinating agent turns 1 decision of mine into request rows for several agents at once, and each agent reports back with its result. A real chain from 1 day: I decided that community applications should move from a Google Form to our own site. The coordinator wrote the plan and the requests for the website, copy, analytics and community agents. The texts were ready within a few hours, and the new page with the form was up the same day.
Status reports work the same way. When I ask for a status, every agent sends back 5 points: done, in progress, blockers, 1 thing it needs from me, and its next delivery with a date. The coordinator turns those into 1 list of decisions for me.
Work also runs side by side instead of "then". When I called our community brochure boring, because it did not show what members actually gain, the graphics agent started the layout on placeholder text while the copy agent wrote the options. After I picked a version, only the text was swapped. From "this is boring" to an approved PDF took 1 day.
How do you stop AI agents from following outdated rules?
1 page of current rules, read first by every agent, stopped ours from following old decisions. Decisions changed every few days, and the old rules sat in 20 different files. An agent would read an old file and do something I had already turned down.
The page sits before each agent's own role card. A newer decision replaces the older one on that page. It is short: the goal, the products, the community, social media, the brand and video.
The coordinating agent also keeps a memory of how I want to be addressed. 2 entries that saved me the most time: at most 1 question per message, and in any report for the team, first the fixes we make ourselves, then the proposals that need a decision.
How do you turn repeated feedback into rules for AI agents?
When I turn something down twice for the same reason, I treat it as a missing rule rather than feedback.
An example. We decided that posts about our community would not promise a set number of engineering hours. Our engineers will take part, but we cannot yet say how many hours that will be. That decision went into our post panel as a check: a post that promises a number of hours gets a block before anyone reads it. The same now happens with our product's old name and with a link to a page that was not live yet.
I keep the last word. The panel has an "approve despite blocks" button, and it writes a note into the post's file saying why. The button covers only the panel's editorial checks. It does not skip the approval lanes below: a public post still goes out only after I approve it.
The learning goes into the rules that shape the next task. No model is retrained here. What improves is the context and the checks around it.
What should a person still approve when AI agents do the work?
Only what is hard to undo: a public post, a message to a specific person, an email, a push to our developers' repository, deleting data, a purchase. The turning point was noticing that I read every version of everything. The agents were fast, and the whole system still moved at the speed of my reading.
An approval workflow for AI agents decides what an agent may do without a person. In ours, local work that is easy to undo is approved by the agent after checks, shared changes get 1 decision per package, and anything public or hard to undo always needs a human. This is our policy for marketing work. Access rights still do the hard blocking.
So I sorted the work into 3 lanes by what happens if something is wrong, not by how confident the model is:
- Easy to undo and local: drafts, files in our marketing folder, local changes on a branch. The agent approves its own work after its checks pass. I do not get a question.
- Undoable, but wide: a website deployment, a change in a shared company repository, a change in the post panel. Automatic checks first, then 1 decision from me for the whole package, not for each version.
- Hard to undo: a public post, a message to a specific person, an email, a push to our developers' repository, deleting data, a purchase. Always me, always with finished, checked material.
| Lane | In our marketing | Example in a marketing team of a 200-person company |
|---|---|---|
| Easy to undo, local | a draft post | a draft newsletter or a draft campaign brief |
| Undoable, but wide | a website deployment | a change on the company website or in the CRM |
| Hard to undo | a public post, an email | a campaign sent to customers, a paid ad, a price change |
The right-hand column is an example, not a description of a client.
A hard check is something that can fail and that a program, or an unambiguous list, can judge: the tests pass, the panel shows no blocks, every number has a source, every product claim has a row with a status in our product facts register, nothing changed inside a code block. "Looks good" is not a check. Neither is a second model that agrees with the first.
Mechanical work is a script, not an agent: counting, comparing, swapping links, exporting. It is cheaper, faster and gives the same result for the same input.
When something has to go back for a fix, it goes back in 5 lines: what (1 element, not the whole package), result, why, evidence, and scope (what may change, and what must stay). 1 section comes back, not the whole brochure.
Can AI agents be trusted with real work? A worked example
This is the chain I would show anyone who asks whether agents can be trusted with real work.
- The copy agent went through our product's technical documentation with our anti-slop prompt and wrote down every fix as before, after and why.
- Then came the question that saved the work: which repository are these files from, and when were they last updated? They were from a branch 5 days old. The main branch had moved 234 commits ahead. The fixes were carried over to the current version: 1 to 1 where a sentence had not changed, from scratch where it had.
- A script checked that nothing changed inside code blocks or headings.
- A separate agent compared every edited sentence with the original, looking only for changes in meaning. Out of 233 sentences, 4 risked changing what they said and 14 had become less precise. All of them went back to the original meaning or became questions for the developer.
- The pull request carried 4 questions instead of 32, because a developer's time is worth more than my completeness. The developer decides what gets merged.
The lesson: the model that edits a text and the model that checks its meaning have 2 different jobs. The check has to look for mistakes, not confirm that there are none.
Taste is still a human job
The lanes took routine approvals off my desk. They did not take away quality.
Public posts sit in lane 3, so I still read and edit every one before it goes out, and I check every graphic, every carousel and every video cut. In the first weeks my corrections were large. As the rules and examples improved, they got smaller. But a small correction can be the one that matters most: a single change to a headline or a slide can change how the whole idea is presented.
The output does get better. Each correction becomes a rule, and the rule shapes the next task. But a rule tells an agent what to avoid. It does not give it taste. Left without review for a few rounds, the output drifts toward the average: safe hooks, symmetrical lists, words that fit every company.
So my job has changed shape. I spend less time routing work and approving drafts, and more time on judgement: what sounds like us, what looks right, what is worth publishing at all. I expect the agents to need less of that over time, as the rules build up. Today they need it every day.
It also pays to stay careful. An agent that has followed the rules for weeks can suddenly return something careless, as if it had forgotten them. And more rules are not always better: past a certain point they start to pull against each other and confuse the agent. Watching how the system behaves, pruning the rules and adjusting the process as it grows is the key part of my job now.
What broke when more than 10 AI agents worked in parallel?
Like in part 1, here is what went wrong, and what I changed.
- A shared git index. One agent committed its changes and took another agent's staged files along with them. Now every agent commits only the files it names.
- A shared browser. One agent cleared browser data and broke another agent's test. Now agents do not touch shared browser state.
- Duplicate order numbers. Agents added rows in different places of the same table, so 2 orders got the same number. The rule now: a new row goes only at the very end, and the agent reads the last number right before writing. That makes a clash rarer and easy to spot, but it cannot rule one out when 2 agents write at the same moment. If it keeps happening, the next step is 1 writer per table.
- A false conclusion from a test. Analytics "did not count", because our test ran in a hidden browser tab, where page counting paused. The problem was our test setup; production counted as it should. Measurement tests now run only in a visible window.
- A report with the wrong tone. The first version of a report on our website put weak numbers up front. The rule now: the goal and our own fixes first, then proposals for decisions.
- Too many questions for me. Long reports with 5 questions each. Now it is at most 1 question per message, and the rest waits for 1 agreed moment. When I first collected every open question and task from all agents on 1 HTML page, the list held about 40 questions and 50 tasks. That was overwhelming. Now I work through it in blocks and do as much as I can in one sitting. Sometimes I only add a comment with a correction or an explanation, and the task comes back updated.
What comes next
2 things are already in progress. First, lending the agents to the rest of our team: a private repository with the agents' role cards and instructions, so anyone can use the copy or graphics agent in their own work. Second, voice cards: a team member pastes 1 prompt into Claude, goes through a 10-minute interview and gets a card of their own voice, which turns a Claude Project into their own writing partner.
The third is where I would most like company. In Empowered Community we plan to test setups like this one on members' own processes. The founding group is still forming, and applications are open. I will show the files, the rules and the mistakes, and each member can build their own. How we map a process with the people who run it, before anything goes into software, is in our method.
Copy the approval lanes
Paste this into your CLAUDE.md or AGENTS.md and adjust the examples to your work. If you use both files, check in the Claude Code docs which one your version loads first.
## Approval lanes
Sort every action by what happens if it is wrong, not by how confident the model is.
1. Easy to undo and local (drafts, local files, local branches):
the agent approves its own work after its hard checks pass. Do not ask me.
2. Undoable but wide (deployments, shared repositories, shared tools):
hard checks first, then 1 decision from me for the whole package.
3. Hard to undo (public posts, messages to a person, emails, pushes to
other people's repositories, deleting data, purchases):
always ask me, with finished and checked material.
A hard check can fail and can be judged by a program or an unambiguous list:
tests pass, no blocks, every number has a source, nothing changed in code
blocks. "Looks good" and a second model agreeing are not checks.
Counting, comparing, swapping links and exporting are scripts, not agents.
## Sending work back
Send a fix request in 5 lines:
- WHAT: 1 element, not the whole package
- RESULT: needs a fix
- WHY: the reason
- EVIDENCE: a quote or a location
- SCOPE: what may change; leave everything else
After 3 failed fixes of the same element, look at the plan, not the element.
Want this system for your own team? In Empowered Community you get the AI agent system behind this article as a template: role cards, prompts and rules, with no setup support. We plan to go through it piece by piece, from the approval lanes to what broke, and you can test it on 1 process you own, with feedback from people in similar roles. It is a free peer group for the founding group, and applications close on 27 November. Apply in 3 minutes
FAQ
Where should AI agents keep shared work: in messages or in files?
In files. Each agent has an order queue in a file; another agent adds a row and sends a short message that the row is there. The message only says where to look.
What is an approval workflow for AI agents?
It decides what an agent may do without a person. In ours, local work that is easy to undo is approved by the agent after checks, shared changes get 1 decision per package, and anything public or hard to undo always needs a human.
How can a marketing director start with AI agents without developers?
Start with the rules, not the tools: sort your team's work by what a mistake costs, write 1 page of current rules, and decide which steps a person always approves. Then let AI tools draft the work that is easy to undo.
Which marketing tasks should a person still approve when AI helps?
Anything that is hard to undo: a campaign sent to customers, a paid ad, a public post, a message to a specific person, a price change. Drafts and internal notes can be checked by rules first.
Why not let a second model review the first one?
Because a second model that agrees is not a check. A check has to be able to fail: tests, a list of rules, a comparison a script can run. When we do use a second agent, its only job is to look for mistakes, such as a change in meaning.
Can AI agents run marketing without a person?
Not ours. Public posts, messages to a specific person, emails and purchases always go to a person, and I still read and improve every public post. None has gone out exactly as the AI drafted it. Left without review for a few rounds, the output drifts toward the average.
This is part 2. Part 1: Multi-agent orchestration with Claude Code: my setup.
