tinyctl.dev

How to Build an AI Content Pipeline That Runs Itself: Our Actual Setup

We built a multi-agent AI content pipeline using Paperclip that produces SEO articles, monitors rankings, and compounds affiliate revenue — without daily human writing. Here's the architecture, the workflow, and the real costs.

Published 5/12/2026

Affiliate disclosure: This site is produced by the exact pipeline described below. Some links in this article are affiliate links — we earn a commission if you sign up through them, at no extra cost to you.

TL;DR: Compound Stack runs on a three-agent Paperclip company — a Content Strategist that researches keywords and writes briefs, an SEO Writer that produces articles from those briefs, and an SEO Auditor that monitors rankings. No human writes the articles. The pipeline cost is $8–20/month in model API calls. Here’s the architecture.

The premise sounds too good: build an AI content pipeline, let it run, watch affiliate revenue accumulate. In practice, most attempts fail for a simple reason — they’re built around a single AI tool (ChatGPT, Jasper, whatever) rather than a system. The tool produces output. Without a system, nothing coordinates what to write, when to write it, or whether it’s working.

This article documents our actual system. Compound Stack — the site you’re reading — is produced by a Paperclip company of AI agents running on a heartbeat schedule. The articles exist because agents wrote them. The keyword targeting exists because agents researched it. The affiliate integrations exist because agents placed them.

This is not a demo. It’s the operational reality of how we work, explained in enough detail to help you build something similar.

/templates/

The Architecture — Three Agents, One Content Company

The pipeline runs on three specialized agents, each with a defined role, a bounded execution model, and a reporting chain.

Agent 1: Content Strategist

The Strategist wakes once a month and owns the entire top-of-funnel: what to write and why. Its responsibilities:

  • Researching 15–20 keyword targets against search volume, keyword difficulty, and commercial intent
  • Building a content calendar that maps keywords to article types (comparison, roundup, tutorial, review)
  • Writing a detailed brief for each article — target keyword, search intent, H2/H3 outline, FAQ schema, affiliate placement map
  • Creating brief issues on the Paperclip board and assigning them to the SEO Writer

The Strategist doesn’t write articles. Its output is direction — structured briefs that the Writer can execute without back-and-forth.

Agent 2: SEO Writer

The Writer is event-triggered — it wakes when a new brief issue is assigned to it. Its responsibilities:

  • Reading the brief
  • Researching live SERP competitors for gaps and opportunities
  • Writing the article to the site repository
  • Marking the issue in-review for the Strategist or board to approve

The Writer doesn’t choose what to write. It executes the brief. This constraint — role isolation — is what makes the output predictable.

Agent 3: SEO Auditor

The Auditor wakes weekly and monitors what’s already been published. Its responsibilities:

  • Pulling ranking data for indexed articles
  • Identifying pages gaining traction (candidates for a “push” refresh) and pages that have stalled
  • Filing optimization issues for the Writer — updated titles, added sections, internal link improvements
  • Flagging technical issues for the Site Engineer

All three agents coordinate through the Paperclip issue board. There’s no Slack, no email, no manual handoffs. An article goes from keyword to published via issues and commits.

The Content Workflow — From Keyword to Published Article

Step 1 — Monthly Content Calendar

On the first of each month, the Strategist wakes and runs a research session. It looks at current rankings, affiliate program priorities, and search trends to produce a calendar: 10–20 target keywords, each assigned to a collection (comparison, roundup, tutorial, review), an article type, and a priority score.

The calendar is committed to the repo as a structured document. The Strategist then creates a new batch of brief issues on the board.

This process — one heartbeat, one calendar, 10-20 queued articles — is the most leveraged part of the pipeline. The entire month’s editorial direction is set in a single automated session.

For how the Strategist is structured and what its instructions look like at a high level, see Paperclip Company Organization Frameworks.

Step 2 — Content Brief Creation

For each calendar slot, the Strategist creates a detailed brief: target keyword, secondary keywords, search intent description, full H2/H3 outline, FAQ questions for schema markup, competitor gap analysis, and affiliate CTA placement map.

Briefs are committed to the site repo so the Writer has a durable artifact — not just a comment thread. If the Writer’s heartbeat crashes midway, the brief is still there.

This is the article you’re reading: written by the Writer from a brief filed by the Strategist.

Step 3 — Article Writing

The Writer picks up the brief issue, checks out the repo workspace, reads the brief, and drafts the article. A typical article heartbeat takes 20–35 minutes of wall time and $0.30–$0.80 in model API costs.

On completion, the draft is committed and the issue moves to in_review. The Strategist or board member reviews the draft — checking factual accuracy, keyword placement, and affiliate link integrity. On approval, the Site Engineer deploys.

Step 4 — SEO Monitoring and Optimization

The Auditor runs weekly. It examines ranking positions for published articles and produces a prioritized list of optimization opportunities. Articles within striking distance of page 1 get a “push” issue — a targeted Writer task to add a section, improve a heading, or fix an internal link gap.

This loop is what makes the pipeline compound over time. An article ranks at position 11. Auditor flags it. Writer adds 300 words to a weak section. Article moves to position 7. Conversion rate on the affiliate link improves. Revenue increases.

For more on how the auditing function integrates with the Paperclip company model, see our full Paperclip review.

What Makes This Pipeline Reliable

The “AI for content” pitch is everywhere. Most implementations break down within a few weeks. Here’s what makes this one durable.

Bounded Execution

Every agent runs in a heartbeat with a hard time limit and a budget cap per run. There are no infinite generation loops, no runaway API calls. If a heartbeat takes longer than expected, it’s visible in the run log and automatically capped.

This sounds like a constraint. It’s actually what makes the pipeline trustworthy enough to leave running.

Durable State

Briefs, drafts, and audit reports live in git — not in a conversation thread or an LLM’s context window. If the Writer’s heartbeat crashes at 80% completion, the partial draft is committed and recoverable. The next heartbeat picks up where it left off.

Without durable state, every failure is a full restart. With git-backed state, failures are checkpoints.

Human Review Gates

The pipeline is not fully autonomous by default. The content calendar is reviewed before briefs are created. Drafted articles move to in_review before publishing. Humans see the output before it’s live.

This is a design choice. Removing the human from every step is technically possible — but it trades oversight for speed in a way that degrades quality faster than it saves time. The value isn’t in publishing without any review; it’s in handling 80% of the work automatically so your review time is well-spent.

Role Isolation Reduces Errors

The Strategist doesn’t write articles. The Writer doesn’t pick keywords. Each agent’s context is scoped to its role, which means smaller prompts, less confusion, and fewer mistakes.

Multi-role prompts — “you are both the researcher and the writer” — are a common failure mode. Role isolation is not an architectural nicety; it’s the reason agents produce usable output instead of coherent-sounding noise.

Budget Predictability

We know within a few dollars per month what this pipeline costs. Budget caps per agent prevent any single heartbeat from blowing the cost model. This predictability is what makes content business economics actually calculable.

How to Build This Yourself

The architecture above can be replicated. What we don’t publish — because it’s the paid product — are our production-ready agent instruction templates, brief formats, and heartbeat configurations. Those are calibrated from months of operational experience and are available as templates for subscribers.

What follows is the structural playbook. The production configs are in the templates.

Step 1 — Set Up a Paperclip Company

Create a Paperclip company, define your goal (e.g., “Generate affiliate MRR from SaaS content”), and connect your site repository as an execution workspace. This gives your agents a shared repo to commit to.

The Paperclip Autonomous Company Setup guide covers this end-to-end, including how to structure goals and projects so your agents have the right context.

Step 2 — Hire Your Agents

You need three roles at minimum: Content Strategist, SEO Writer, and SEO Auditor. For each agent, you define:

  • A role description (what this agent does and what it doesn’t do)
  • The tools it has access to (web search, repo, analytics data)
  • Its reporting chain (who it escalates to)
  • A budget cap per heartbeat

The Paperclip Company Organization Frameworks article covers how to structure the reporting hierarchy and what role descriptions need to include to produce consistent output.

The specifics — the actual instruction language that reliably produces good editorial direction vs. keyword-stuffed garbage — are in our [production agent templates →]/templates/

Step 3 — Configure Heartbeat Triggers

The Strategist runs on a monthly schedule (1st of the month). The Writer is event-triggered (wakes on new brief assignment). The Auditor runs weekly.

Getting trigger configuration right affects your cost model significantly — agents that wake too frequently burn budget on idle runs; agents that wake too rarely create bottlenecks in the editorial pipeline.

Step 4 — Seed the Pipeline With Your First Brief

For the first cycle, write one brief yourself following a structured format: target keyword, search intent, H2/H3 outline, FAQ schema. This gives the Writer agent a concrete example of what “good” looks like before the Strategist takes over brief production.

After the first article publishes: evaluate whether the Strategist’s brief quality is sufficient to remove the manual brief-writing step. For most setups, month 1 requires some manual calibration; by month 2 the Strategist brief quality is good enough to leave mostly unsupervised.

Step 5 — Review, Calibrate, and Step Back

First month: review every article before publishing. Note where agents deviate from your quality bar. Update agent instructions accordingly. This is the highest-leverage work you’ll do on the pipeline — calibration in month 1 pays dividends for the following 12.

By month 2–3: most output should be publishable with light edits. The goal is not zero human involvement — it’s the right level of human involvement at the right stages.

/templates/

Costs and ROI

Model Costs

TaskCost per run
Monthly content calendar (Strategist)$0.50–$1.20
Brief creation per article (Strategist)$0.10–$0.40
Article writing per article (Writer)$0.30–$0.80
Weekly SEO audit (Auditor)$0.25–$0.60

For a 15-article/month pipeline:

  • Calendar + briefs: ~$2–7/month
  • Article writing: ~$5–12/month
  • Weekly audits: ~$1–2.50/month
  • Total model cost: ~$8–22/month

These estimates assume a mid-tier model (Claude Sonnet) for workers and a capable model (Claude Opus) for the CEO/Strategist. Model selection has the largest single impact on both cost and quality.

Platform Cost

Paperclip is open-source and self-hosted — the platform itself is free. Your infrastructure cost (if any) depends on how you run it. For cloud-hosted deployments, see our Paperclip Pricing Guide for a breakdown of realistic infrastructure costs at different scales.

Revenue Model

With 15 articles/month targeting commercial SaaS keywords, and assuming 1–3% conversion on affiliate CTAs, affiliate commission MRR can cover total pipeline costs within 3–4 months. This is the math model we use — not a guarantee, but a realistic planning assumption for content businesses targeting the right keyword profile.

The key variable is keyword selection: articles ranking on page 1 for “best [tool category]” queries with affiliate programs paying $50–200/conversion compound fast. Articles ranking on page 3 for informational queries do not.

This is why the Strategist’s keyword research is the most critical input to the system — and why generic AI content tools that skip the strategy layer don’t produce the same results.

What We Don’t Publish (And Why)

The architecture in this article is the accurate, operational structure of how Compound Stack runs. What we don’t publish for free:

  • Production agent instruction templates — the exact prompts that produce consistent, high-quality output across Strategist, Writer, and Auditor roles
  • Brief format specification — the structured schema our Strategist outputs and our Writer consumes
  • Heartbeat configuration examples — the trigger and budget settings that balance cost vs. output velocity
  • Calibration log — the specific adjustments we made across the first three months of operation

These are the paid product. The reasoning: sharing working configs publicly defeats the competitive advantage of running this pipeline — if everyone uses identical agent instructions, outputs converge and differentiation disappears. The templates encode months of failure modes and their fixes.

[Get the production-ready Paperclip content pipeline templates →]/templates/

Conclusion

An AI content pipeline that runs itself isn’t a future concept — it’s a production system you can build today. The key insight is structural: separate keyword research from writing from auditing, give each role a bounded execution model, and wire the roles together through a shared issue board with durable state.

Paperclip provides the infrastructure that makes this structure reliable: heartbeat scheduling, workspace isolation, budget caps, and human review gates. The result is a content operation that scales with model costs, not headcount.

If you want to skip the calibration period and start with production-ready agent configurations, our template pack covers everything described above — plus the lessons from three months of operational refinement.

[Build your content pipeline on Paperclip →]/templates/

Related reading: