Build Your Own Marketing Agent Fleet

A marketing agent fleet is a set of specialized AI agents: each with a defined role, a fixed schedule, and hard constraints on what it can and cannot do: that collectively handle the marketing functions a founder would otherwise staff with three to five hires. Armada Works deploys these fleets into client codebases, where agents commit their output to git, post daily briefs to a dashboard, and coordinate through shared state files rather than APIs or message queues. If you want to build your own marketing agent fleet, this is the playbook: the roles you need, the architecture that holds them together, and the lessons that only come from running one in production.

The concept sounds abstract until you see it running. An agentic marketing team is not a single chatbot that generates blog posts on demand. It is five or more agents, each operating independently on a schedule, each reading the others' output through files committed to the same repository. The SEO agent dispatches content briefs. The Content agent picks them up and drafts blog posts. The CMO agent reads everyone's daily brief and writes a single synthesis for the founder. No human prompts them each morning. No one copies and pastes between tools. The system runs, and the founder reviews.

Why Agent Fleets Beat Single-Tool Automation

Most founders have tried AI marketing tools: a writing assistant for blog posts, an SEO tool for keyword tracking, maybe a chatbot for customer support. Each tool solves one problem, but the founder remains the integration layer. They still decide what to write, when to write it, which keywords matter, how to prioritize outbound versus content, and whether the SEO recommendations actually made it into the latest draft.

Single-tool automation creates islands. A marketing agent fleet eliminates them.

The differences come down to three structural advantages:

• Autonomous scheduling. Each agent runs on a fixed cadence: Monday, Wednesday, Friday at a set time. The founder does not open a tool and prompt it. The agents wake up, read their state files, do their work, and report.

• Cross-agent coordination. The SEO agent writes a content brief with target keywords and a suggested outline. The Content agent reads that brief and drafts a blog post optimized for those keywords. No human bridges the gap between "keyword research" and "draft written." The agents bridge it through shared files in git.

• Synthesized reporting. Instead of checking five dashboards, the founder reads one message from the CMO agent. That synthesis highlights what shipped, what is blocked, and what needs a human decision. Robert Cowherd, founder of Armada Works, describes it: "A fleet generates more daily output than any founder will read. The synthesizer agent exists because the founder's attention is the real bottleneck: not the agents' throughput."

Marketing automation agents: the fleet variety, not the single-tool variety: replace the coordination burden, not just the execution.

The Five Roles Every Marketing Fleet Needs

After running a nine-agent fleet and trimming it to the five that carry their weight, Armada Works deploys the following core roles in every client engagement:

Role	What It Does	Why It Is Essential
CMO	Reads all sub-agent briefs, writes a founder synthesis	Without it, the founder reads five briefs instead of one
SEO	Keyword tracking, technical audits, content briefs, Core Web Vitals	Feeds the Content agent with data-driven writing assignments
Content	Blog drafts, essays, email copy, page-copy proposals	Produces the words: but only what the SEO agent and CMO queue up
Sales Lead	Inbound lead triage, qualification notes, pipeline analysis	Ensures no inbound inquiry sits unread for days
Outbound	Prospect research, personalized first-touch drafts	Generates warm outreach without the founder writing cold emails

Each agent operates from a prompt file: a markdown document that specifies exactly what the agent can and cannot do. The Content agent's prompt, for example, defines the blog directory it writes to (docs/content/blog/), the frontmatter format it must follow, the voice guidelines it must match, and the queue file it pulls assignments from (docs/agents/state/content-queue.md). Every constraint is version-controlled and reviewable.

The five roles are not arbitrary. They map to the four functions that bottleneck a founder-led company without a marketing team:

1. Visibility: you need to be found (SEO)
2. Authority: you need content that proves you know what you are talking about (Content)
3. Pipeline: you need leads coming in (Sales Lead) and going out (Outbound)
4. Synthesis: you need someone reading all of this and telling you what matters (CMO)

If your bottleneck is different: support, product engineering, community management: you add agents for those functions. But these five cover the marketing operation for most founder-led companies from seed stage through Series A, and they are the minimum viable fleet. Start here before adding complexity.

Architecture: How Agents Coordinate via Git and Dashboards

The architecture is deliberately simple. Every agent reads and writes files in a single git repository. There is no message bus, no event stream, no database-backed queue. The coordination layer is git itself.

Here is how a typical fleet is wired:

1. Prompt files. Each agent has a prompt at docs/agents/<role>-agent-prompt.md. This is the agent's operating manual: responsibilities, constraints, output format, security rules. The prompt is checked into git, versioned, and reviewable by the founder at any time.

2. State files. Each agent writes a persistent state file at docs/agents/state/<role>-agent-state.md at the end of every run. This is the agent's memory between sessions: what it did, what it plans to do next, open questions for other agents or the founder.

3. Queue files. Work flows through queue files like docs/agents/state/content-queue.md. The CMO or SEO agent adds items to the Pending section with a priority, a brief, and a deadline. The Content agent picks items off the queue, marks them In Progress, drafts the content, and moves them to Completed.

4. Daily briefs. Every agent posts a structured brief to a reporting endpoint (/api/agent-reports) that stores briefs in a database. The CMO agent reads all sub-agent briefs and writes its founder synthesis. Briefs are also mirrored as markdown files in git for full traceability.

5. The dashboard. A private admin view displays every agent's brief by date and agent name. The founder drills into individual agent briefs when the CMO synthesis raises a question.

This architecture is stack-agnostic. The repo can be Next.js, Rails, Django, or Go: the agents work in markdown files and shell commands, not application code. The reporting endpoint and dashboard are the only pieces that touch the web framework, and those are a single API route and a single admin page.

Why git instead of a database or message queue? Three reasons:

• Traceability. Every agent action is a commit. Run git log --author="Content" and you see everything the Content agent has ever produced.
• Rollback. If an agent produces bad output, a single git revert removes it cleanly.
• Review. The founder reviews agent output the same way they review code: by reading diffs. No new tool to learn.

Lessons from Running a 5-Agent Fleet at Armada Works

Armada Works developed this architecture by running a fleet against its own product before offering it to clients. The fleet started at nine agents and stabilized at five. Here is what we learned: and what you will learn too, usually the hard way.

The synthesizer agent is the load-bearing piece. Nine daily briefs is more reading than any founder will do. Five is still too many on a busy morning. The CMO agent exists because without it, the founder stops reading briefs by day three and the fleet's output goes unreviewed. If you build your own marketing agent fleet and skip the synthesizer, the system will produce work that nobody looks at.

Constraints beat autonomy. The instinct is to give agents broad freedom: "write blog posts about whatever seems important." This produces unfocused, inconsistent output. The best agents have the most specific constraints: which files they can touch, which commands they can run, which sections of the codebase they must never modify. The Content agent cannot deploy to production. The SEO agent cannot edit blog posts directly. The Outbound agent cannot send emails: it drafts them for the founder to review and send manually.

Git is the coordination layer, not a compromise. We tried structured handoffs between agents via API calls early on. They broke constantly: timing issues, format mismatches, agents waiting on responses that never came. Git-committed state files are simpler and more reliable. The SEO agent writes a brief to a file. The Content agent reads it whenever it runs next. There is no coupling, no timeout, no retry logic. Just files.

Agents should be bylined. Every commit carries the agent's name: content: draft blog on agent fleets for prosumer SaaS. This makes it trivial to audit which agent is producing quality output and which needs prompt tuning. When something goes wrong, you know immediately who did it and can read the exact prompt that produced the bad output.

The system improves itself. Agents surface their own limitations in their daily briefs. "The SEO agent's content brief didn't include word count targets: Content agent had to guess." These meta-observations become prompt improvements. Over weeks, the fleet's output quality compounds because every agent is reporting what the other agents could do better, and the founder folds those observations into prompt updates.

Not every agent contributes equally: and that is fine. In the original nine-agent fleet, Paid Ads was in research mode with no budget to spend. Social Media produced drafts that nobody posted. A/B Testing had too little traffic to run meaningful experiments. We cut all three and the fleet's useful output per run increased. Less noise in the CMO synthesis, less for the founder to skip over. Start with five. Add agents only when you have the upstream input: budget, audience, traffic volume: they need to function.

When to DIY vs Hire a Consultancy to Set It Up

Building a marketing agent fleet yourself is feasible if you have three things: engineering time to write prompt files and set up the reporting infrastructure, experience writing AI agent prompts that produce consistent output, and the patience to iterate through the first month of calibration where output quality is uneven.

Here is how the two paths compare:

Factor	DIY	Hire a Consultancy
Time to first output	2-4 weeks (infrastructure + prompt iteration)	1 week (deploying a proven architecture)
Prompt quality at launch	Untested: requires iteration	Battle-tested from prior engagements
Ongoing maintenance	You tune prompts, fix coordination bugs, update state schemas	Managed during the engagement, documented for handoff
Cost	Agent runtime only (API costs)	$10,000-$20,000 setup + optional ongoing support
Ownership	Yours from day one	Yours from day one (client owns the repo)

The DIY path makes sense if you are technical, enjoy prompt engineering, and want to learn the architecture deeply before relying on it. You will spend the first month tuning prompts, adjusting cadences, and learning what "good agent output" looks like for your specific domain. That is time well spent if your goal is deep ownership.

The consulting path makes sense if you want output fast and would rather spend your iteration cycles on your product, not your marketing infrastructure. Armada Works offers a Transfer engagement specifically for this case: a fixed-scope two-to-four-week build-and-handoff where Armada deploys the fleet, runs it alongside you, documents everything, and hands the system over. After that, you run the agents yourself.

The positioning line that governs every Armada engagement: "If we're still here in twelve months, one of us has failed." Whether you build the fleet yourself or hire someone to set it up, the goal is the same: a system you own and operate, not a service you rent.

Frequently Asked Questions

What is a marketing agent fleet?

A marketing agent fleet is a coordinated set of AI agents: typically five or more: that handle ongoing marketing functions like SEO, content production, outbound prospecting, and sales lead triage. Each agent has a defined role, runs on a fixed schedule, and commits its output to a shared git repository. A synthesizer agent (the CMO) reads all sub-agent output and writes a single daily summary for the founder. The fleet replaces the coordination and execution burden of a small marketing team without requiring a human in the loop for each task.

How many agents do I need to start?

Five is the minimum for a functional marketing fleet: CMO (synthesizer), SEO, Content, Sales Lead, and Outbound. These five cover visibility, authority, pipeline, and synthesis: the four functions that bottleneck most founder-led companies. You can add agents for support, paid ads, social media, or product engineering later, but only when you have the upstream inputs (budget, audience, traffic volume) those agents need to produce useful output.

Do marketing automation agents replace human marketers?

Agents replace the execution and coordination work that a junior-to-mid marketer does: drafting blog posts, tracking keywords, triaging inbound leads, researching outbound prospects, and synthesizing daily status reports. They do not replace strategic judgment. The founder still reviews the CMO synthesis, approves content for publication, decides which outbound messages to send, and sets the overall marketing direction. The fleet handles the structured, repeatable 80% of marketing work so the founder can focus on the 20% that requires human judgment.

What does it cost to run a marketing agent fleet?

If you build it yourself, the primary cost is API runtime: the compute cost of running each agent on its schedule. For a five-agent fleet running three times a week, this is typically a few hundred dollars per month depending on prompt length and output volume. If you hire Armada Works to deploy the fleet, the Transfer engagement (build-and-handoff) runs $10,000-$20,000 one-time, with optional $1,500/month ongoing support. The Operate engagement (fully managed) runs $5,000-$12,000/month.

Can I use this architecture with models other than Claude?

The architecture: git as coordination, prompt files as operating manuals, state files for inter-agent communication, a synthesizer agent, a reporting dashboard: is model-agnostic in principle. You could implement it with any agent-capable LLM. Armada Works uses Claude Code because it has native filesystem access, git integration, and tool use that makes the agent loop reliable without custom scaffolding. But the coordination patterns: queue files, daily briefs, bylined commits, state-file handoffs: work regardless of which model powers the agents.

How long until a marketing agent fleet produces measurable results?

Agents begin producing structured output: blog drafts, keyword reports, prospect research: within the first week of operation. The first two to three weeks are a calibration period where prompt tuning improves output quality and voice consistency. SEO results like rankings, indexed pages, and organic traffic take two to four months to materialize, consistent with any SEO effort. The fleet's value in the first month is volume and consistency of output. The compounding effects: domain authority, content library depth, outbound pipeline: build over quarters, not days.

---

Ready to build your own marketing agent fleet? Book a discovery call and we will scope it in thirty minutes.