TL;DR:

  • A content pipeline agent breaks the problem into distinct stages — research, brief, draft, review, optimise, publish — with each stage having clear inputs, outputs, and tool access
  • The most reliable architectures use a human review checkpoint before publishing, not as a bottleneck but as a quality gate that lets the agent handle high-volume work while humans focus on approval
  • Start with a linear pipeline before adding parallelism — getting the single-track flow working first makes debugging far easier

Marketing teams are under pressure to produce more content at higher quality with flatter headcount. AI writing tools have existed since 2022, but a standalone AI writing tool still leaves most of the work on a human: choosing topics, researching them, briefing the AI, editing the output, optimising for SEO, uploading to the CMS, and scheduling publication. The result is a human doing a lot of the same repetitive steps between each AI interaction.

A properly designed AI agent pipeline changes this. The agent handles the repetitive work — research, competitive analysis, drafting, formatting, SEO metadata, CMS upload — while humans handle the parts that genuinely require judgement: approving briefs, reviewing drafts, and making strategic decisions about content direction.

The Pipeline Architecture

A content agent pipeline has six distinct stages. Each stage has defined inputs and outputs, making the whole thing composable and debuggable.

Stage 1: Topic Research

The agent queries search APIs (Exa, Perplexity, or a web search tool) to find what’s performing in your niche right now: trending questions, high-traffic competitor content, emerging news angles, and keyword gaps. Tools: search API, optional Google Search Console integration for your own site’s data.

Output: a ranked list of 5-10 topic candidates with supporting data (search volume estimates, competitor coverage, recency).

Stage 2: Brief Generation

For the selected topic, the agent produces a structured content brief: target keyword, secondary keywords, suggested headline options, recommended structure, key points to cover, and competitors to differentiate from. This is the stage where human approval is most valuable — the brief is short, reviewable in under two minutes, and setting it right prevents wasted drafting effort.

Output: a content brief document, surfaced to a human reviewer for approval before proceeding.

Stage 3: Drafting

With an approved brief, the agent produces a full draft. This is where model choice matters: longer-form, coherent drafting benefits from a more capable model (Claude Sonnet 4.6 or equivalent), while short-form content can be handled by a faster, cheaper model. The agent follows the brief structure, targets the word count, and includes placeholder markers for any claims that need factual verification.

Output: a structured draft with metadata annotations.

Stage 4: Factual Review and Enrichment

The agent identifies claims in the draft that require verification — statistics, dates, product specifications, named sources — and uses search tools to check them. This is a targeted pass, not a full rewrite. Claims that can’t be verified within the tool budget are flagged for human review.

Output: an annotated draft with verified claims, flagged uncertainties, and suggested supporting links.

Stage 5: SEO Optimisation

The agent applies SEO metadata: title tag, meta description, Open Graph fields, header structure, internal linking suggestions based on existing site content, and image alt text. If your CMS supports schema markup, the agent generates article schema. This step is highly automatable and benefits from a specialised tool that checks your existing content inventory for linking opportunities.

Output: a draft with full SEO metadata ready for CMS upload.

Stage 6: CMS Publishing

Using your CMS API (WordPress REST API, Contentful, Sanity, Webflow CMS API, or others), the agent creates a draft post, uploads assets, sets metadata, and assigns to the right category and author. It does not publish automatically — it sets status to “ready for review” and surfaces the CMS link to the relevant team member.

Output: a CMS draft ready for final human approval and publishing.

Implementation Stack

Orchestration: LangGraph works well for this pipeline because it supports conditional edges — you can route to human approval nodes and wait for a resume signal before continuing. An alternative is Temporal, which handles the long-running nature of content pipelines (a complete run might take 20-40 minutes with human approval waits).

Search: Exa or Perplexity API for research-quality web search. Standard Google Search or Bing Search works for competitive analysis but returns less structured results.

Drafting model: Claude Sonnet 4.6 for drafting and SEO optimisation; a smaller model (Claude Haiku 4.5) for classification tasks and brief formatting.

CMS integration: Composio handles CMS API authentication well if you’re connecting to multiple content systems. For WordPress-only shops, the WP REST API is straightforward to call directly.

Human review interface: The simplest implementation surfaces approval requests via Slack using a webhook — the agent posts the brief or draft to a Slack channel with Approve/Request Changes buttons. More sophisticated teams build a lightweight review UI on top of their existing CMS.

Where Pipelines Break

Content pipelines have three failure modes that are worth designing around before you hit them in production.

Hallucinated statistics. Drafting agents invent plausible-sounding figures when they don’t have a solid source. The factual review stage (Stage 4) catches many of these, but a human reviewer should be specifically looking for statistics and their sources in the Stage 4 output.

Brief drift. When the agent’s draft diverges significantly from the approved brief — different angle, different target keyword, different structure — the result is a draft that passes automated checks but doesn’t match what was approved. Adding a brief-compliance check at the start of Stage 5 catches this before the SEO work runs.

CMS API versioning. CMS APIs change. The WordPress block editor API in particular has evolved enough that prompts and field mappings that worked six months ago may produce malformed blocks today. Build in a CMS compatibility test that runs against a staging environment weekly, not just when you’re developing the pipeline.

Measuring Pipeline Performance

Track three metrics: output volume (posts drafted per week), human review time (how long approval stages actually take), and factual error rate (catch this by auditing published posts monthly for claims that turned out to be inaccurate). A healthy pipeline should reduce human time per article to under 15 minutes while maintaining comparable quality to fully human-written content.

Start with a linear pipeline for one content type on one channel. Get it working reliably before adding parallel tracks for different content types or publication targets.