← Research library

Multi-agent content pipelines: researcher, writer, editor, checker

AI-assisted research. This note was prepared with the assistance of AI tools. It may contain errors and is not professional advice. See our Legal Disclosures.

Content is where most marketing teams first put agents to work, and it is also where the limits of a single general agent show up fastest. Fact-heavy pieces need research, writing, editing, and verification, and those jobs pull in different directions.

A single agent asked to "write a blog post about our new feature" has to do all of them at once. It must gather facts, choose an angle, write, edit, and check its own work. It does each reasonably and none especially well. Editorial teams solved this long ago by splitting the work into roles, and content pipelines built from several agents can do the same.

The four roles

A pipeline we often recommend has four specialist roles and a human reviewer at the end. Each role has one job, a narrow set of tools, and a defined output.

  • Researcher: gathers facts from approved sources such as product documentation, release notes, and relevant public information. Its output is a structured fact sheet with sources, not prose.
  • Writer: produces a draft from the brief and the fact sheet. It uses only facts from the sheet and flags anything it needs but cannot find.
  • Editor: reviews the draft for structure, clarity, and voice, then revises it against the brand voice specification and the brief's definition of done.
  • Checker: verifies every factual claim against the fact sheet, confirms required elements such as disclosures, and runs mechanical guardrails. It passes or fails with specific reasons and does not rewrite.

A person reviews the checked draft before publication. The checker's report goes with it, so the reviewer can spend attention on judgment rather than on hunting for typos and unsupported claims.

Why split the work

The first benefit is that each role is easier to evaluate. You can test whether the researcher finds the right facts separately from whether the writer writes well. When quality drops, you know which step to open up instead of rereading a whole draft and guessing.

The second is that each role needs less context. The checker does not need the voice guide, and the writer does not need search tools. Narrower agents tend to be cheaper to run and more predictable, and a smaller model is often enough for the mechanical roles.

The third is that errors get caught earlier. A fact sheet with a wrong date is easy to spot because the date sits alone on a line with its source. The same mistake woven into a polished paragraph reads as settled and slips past tired reviewers.

The fact sheet is the spine

Everything in the pipeline depends on the researcher's output. A good fact sheet lists each claim on its own line, with a source, a date, and a confidence flag. It separates what is confirmed from what is inferred, and it lists the questions the researcher could not answer.

The writer's instructions should treat the fact sheet as the only allowed source of claims. The checker's instructions should treat it as the reference for verification. When both read the same sheet, a claim that appears in the draft but not in the sheet is an automatic failure, which is exactly the check you want.

This is a handoff, and it deserves a contract. We describe the parts of a good one in designing agent handoffs. The short version is that the sheet should carry counts, sources, and uncertainty, and the writer should reject a sheet that lacks them.

A worked example

Consider a hypothetical product announcement for a new reporting feature. The brief asks for a 900-word post, a customer email, and three social variations, all built from the same release notes.

The researcher reads the release notes and the product documentation and produces a fact sheet of 14 claims. Two are marked inferred: the exact plans that include the feature, and the date it reaches all regions. The writer drafts the post and the email from the sheet and leaves both inferred claims out, adding a note asking for confirmation.

The editor tightens the structure and brings the email in line with the voice guide. The checker then finds one sentence in the post that describes a feature from the previous release, which is not on the sheet. It fails the draft with that sentence quoted. The writer removes it, the checker passes the revised draft, and a product marketer confirms the two open claims before publication.

The error the checker caught is the kind a single agent tends to introduce. It knew about the older feature from earlier context and blended it in, and the result read naturally.

Failure modes to watch

Pipelines fail in their own ways. We suggest checking for these signs during the first month of any new pipeline.

  • Fact sheet bloat: the researcher passes everything it found, and the writer drowns in material it does not need.
  • Editor overreach: the editor rewrites claims while fixing style, which reintroduces errors the checker then has to catch.
  • Checker drift: the checker passes drafts it should fail because its instructions grew vague over time.
  • Rubber-stamp review: the human reviewer starts approving whatever the checker passed without reading it.

Editor overreach is the one we would check first. A simple instruction helps: the editor may change wording and order but must not add, remove, or alter any factual claim. The checker can enforce that rule by comparing claims before and after the edit.

What to measure

A pipeline gives you a measure at each stage, which is the main reason to build one. We recommend tracking a few from the start.

  • Unsupported claims caught: how often the checker fails a draft for a claim not on the fact sheet.
  • Open questions per sheet: how many claims the researcher could not confirm, which shows where source material is thin.
  • Human edit rate: how much the final reviewer changes, measured as in our post on human edit rate.
  • Cycle time by stage: where drafts wait longest, so you can see which step is the bottleneck.

When one agent is enough

Pipelines add complexity and latency. For short, low-stakes content, such as internal summaries or social variations from an already approved message, a single well-instructed agent is often the better choice. Pipelines make the most sense for longer, fact-heavy content where accuracy matters, such as product announcements, guides, and comparison pages.

It can seem simpler to ask one agent to write and then check its own work. Self-review helps, but a separate checker with a narrow job and different instructions tends to catch more, because it does not share the writer's assumptions. We explore this trade-off in self-critique loops.

Open questions

We are studying how far the checker can go on its own. Matching claims against a fact sheet is mechanical and works well. Judging whether a true claim is framed fairly, or whether a comparison is balanced, is harder, and we expect that to stay with people for some time. We are also testing whether the checker should see the brief, or whether a checker that sees only the sheet and the draft stays more independent.

How to apply this: for your next fact-heavy piece, split the work into a fact sheet step and a writing step, even if a person does one of them. Then add a check that every claim in the draft appears on the sheet, and notice how much easier errors become to find.

Related research

Put this research to work

Marketix turns these patterns into software: agents, automated workflows, and a hub that keeps people in control. Sign up for early access.