AI Blog Pipeline: Inspectable Agent Workflow

One developer fact-checked nine AI-written blog drafts line by line. Eight needed fixes. The drafter had invented rejected alternatives, a rate-limit error and a fix for that error, none of which ever happened (DEV Community).

That's the part most agent-pipeline guides leave out. They draw three boxes, research, write and publish, and stop there. They don't cover verification, failure handling or what a run costs.

This post walks through our own pipeline at Ryterr as a worked example. For each handoff, you'll see what the stage passes on, where it can break and what keeps a bad post from going live. The goal is a finished article, not a draft.

Why one prompt can't ship a finished post

When one model call researches, writes and checks its own work, nothing independent ever checks it. The model grades its own homework.

Splitting the work up helps. Anthropic's multi-agent research system outperformed single-agent Claude Opus 4 by 90.2% on its internal research eval (Anthropic via GitHub summary). As the Anthropic team put it: "The essence of search is compression: distilling insights from a vast corpus."

Splitting also adds new ways to fail. The MAST study analyzed 5 multi-agent frameworks across 150+ tasks. It found 14 failure modes in three groups: specification, inter-agent misalignment and task verification (Hugging Face Papers).

So separate stages only help under two conditions:

• Every handoff is visible, so you can see what each agent received and produced.
• The verification stage can block output, not just leave comments on it.

The rest of this post follows how Ryterr writes a post as the example.

Handoffs 1 and 2: research, then draft

Research comes first, and it takes most of the time. Our pipeline takes 4 to 6 minutes per post because it runs real web research. In our own words: "the pipeline takes 4-6 minutes per post. It's not instant." (Ryterr blog).

That's the tradeoff. You wait a few minutes, and in return the sources are real pages, not the model's memory.

Brand facts come from your own site. Ryterr reads your public website and saves your product, prices and voice, and each fact is stored with the quote it came from (Ryterr). The drafter can't invent a $49 plan when the saved fact says otherwise and points to the exact sentence on your pricing page.

The next problem is context. One builder ran a 9-agent pipeline: research, distill, outline, write, fact check, rewrite, edit, SEO and quality score. Early on, agents repeated each other's research and writers hallucinated examples. The biggest reliability gain came from tighter context control: "Each agent now sees only the outputs it needs." (Medium case study).

That points to the handoff contract between research and drafting. Research should pass the drafter:

• The source URL
• The verbatim quote that supports each fact
• The fact itself, stated plainly

Summaries alone aren't enough. A summary gives the verifier nothing to check later. A quote does.

Handoff 3: claim verification as a first-class stage

This stage exists because citations break more often than you'd guess. A study of commercial LLMs and deep research agents found that 3 to 13% of citation URLs were hallucinated and 5 to 18% didn't resolve. Deep research agents produced more citations per query but hallucinated URLs at higher rates (arXiv, Reference Hallucinations).

In one cross-model audit, 58.3% of hallucinated citations fell in the "probable real" category and 31% were near misses. Only 6.0% were outright fabrications (arXiv, How LLMs Cite). The audit found that most hallucinated references resembled real publications. URL liveness checks alone cannot establish whether a source supports a claim.

The numbers get worse in some domains. Across six simulated mental health literature reviews, GPT-4o fabricated 19.9% of all citations, and 45.4% of the real-looking ones had bibliographic errors (JMIR via EurekAlert). Newer models do better on some tests. A legal benchmark found early GPT-4o models at 1.23%, against about 25% for earlier GPT-3.5 models (arXiv, legal hallucination benchmark). Lower rates still mean some errors, and the verifier has to find them.

So the verifier has to compare each claim against the source text. CoreMesh, a small tech blog, built a CLI called claimcheck that does this with an open-weight model. It extracts checkable claims from a draft and checks them against the sources the draft itself links to. One rule keeps it honest: "Every claim must quote the draft. A claim whose quote isn't in the draft is dropped." It caught a claim saying PEP 814 candidates were certain, when the source listed them only as possible candidates (DEV Community).

Our version is called Trace. It checks each statistic, price, name and date against live sources. The Review tab lists every claim Trace checked and the page it checked against (Ryterr how it works). On our sample post about deploying Next.js to an Ubuntu VPS, all 25 claims were verified with zero open review warnings (same source).

One honest limit: checking a claim against its source shows the source says it. It doesn't prove the source is right. That's why the Review tab shows you the page, so you can judge it.

Quality gates: what fails and how it's caught

It helps to map failures to the MAST categories. A secondary summary puts the approximate shares at 41.8% specification and design, 36.9% inter-agent misalignment and 21.3% verification (Future AGI Substack). Treat those as rough figures, since they come from a summary and not the paper itself.

Each category shows up in real pipelines:

• Specification: the drafter fills gaps with plausible fiction. That's how one builder ended up with an invented rate-limit error and fix in 8 of 9 drafts (DEV Community).
• Inter-agent misalignment: agents undo each other. In the 9-agent pipeline, fact-checkers rewrote whole articles and editors undid corrections (Medium case study).
• Verification: the check runs, but nobody can see whether it ran.

The fix for misalignment is narrow permissions. The verifier patches claims. It doesn't rewrite prose.

Our gate works like this. Corrections are shown before and after, with the old words, the new words and the reason. A post with an open fact-check finding waits for review, and a scheduled run won't publish it (Ryterr). On the Solo plan, fact-check problems are fixed and checked again (Ryterr pricing).

Observability is the last piece. The same DEV builder found twelve per-profile environment files still pointed at an old tracing address. "The specialist agents had been silently untraced." (DEV Community). If you can't see a stage, you can't gate it.

Handoffs 4 and 5: illustration and publish

Illustration runs off your brand colours, not stock photos. Each Ryterr post comes with a hero image, inline images in brand colours, SEO fields and Markdown and HTML files (Ryterr). Solo includes 5 images per post (Ryterr pricing).

Structure is what separates a draft from a finished article. Every post includes headings, a title, slug, description, an FAQ and a Sources section (Ryterr), plus a fact-check report with the source for each claim (Ryterr pricing). You don't add the metadata after the fact.

Publishing goes straight into your own site through WordPress, Ghost, GitHub, a signed webhook or the Content API, either now or on a schedule. See Ryterr integrations for each connection.

One detail for developers: the Content API allows 100 requests per minute per key and returns 429 with a Retry-After header beyond that (Next.js integration). If you're writing your own publish agent, have it read Retry-After and wait. Don't let it retry in a tight loop.

Cost per finished post

Agent pipelines cost more to run than chat. Agents typically use about 4× more tokens than chat, and multi-agent systems about 15× more (Anthropic via Simon Willison). In Anthropic's eval, token usage alone explained 80% of the performance variance (GitHub summary).

That's the honest catch with multi-stage designs. A five-stage pipeline only earns its cost if the verification stage catches enough errors. A cheap pipeline that skips verification is a different product.

Here's what each stage hands on and what can stop it:

We price per post, not per token. Solo is $29 a month per brand billed yearly ($348), or $35 billed monthly, with 20 posts a month (Ryterr pricing). The math:

• Yearly: $348 ÷ 12 = $29 a month, ÷ 20 posts = $1.45 per post
• Monthly: $35 ÷ 20 posts = $1.75 per post
• Extra posts: $2 credits that never expire

Then add your time. In our own description, the operator touches each post twice: 10 minutes at topic selection and 20 to 30 minutes at final review (Ryterr blog). That's self-reported, and we haven't found an independent cost-per-post audit. Budget $1.45 to $1.75 plus 30 to 40 minutes of your time per post.

Verification isn't an upsell. Every plan, including Free, gets the same live research and the same fact-check report (Ryterr pricing).

FAQ

Can't I just check that each citation URL loads?

No. In one audit, 58.3% of hallucinated citations were probable real works and 31% were near misses, while only 6.0% were outright fabrications (arXiv, How LLMs Cite). The audit found that most hallucinated references resembled real publications. URL liveness checks alone cannot establish whether a source supports a claim. The check has to compare the claim to the source text.

What happens if the fact-check flags something on a scheduled post?

The post waits. A post with an open fact-check finding is held for review, and a scheduled run won't publish it (Ryterr). You see the warning, the source and any proposed correction before deciding.

Does verification guarantee zero errors?

It doesn't. Checking against a source proves the source says it, not that the source is right. That's why we show every claim with its source page in the Review tab, so you can spot a weak source yourself.

Why does a post take 4 to 6 minutes instead of seconds?

Live web research takes time. Our pipeline fetches and reads real pages before drafting, which is where most of the 4 to 6 minutes goes (Ryterr blog). A model writing from memory alone is faster, and that's when invented citations show up.

I build my own publish agent. Will it get rate limited?

Possibly, if it's aggressive. The Content API allows 100 requests per minute per key and returns 429 with a Retry-After header beyond that (Next.js integration). Read the header and back off for that long.

Sources

• Ryterr blog: Fact-check AI blogs to build authority
• Ryterr blog: Scale to 3 posts a week without hiring
• Anthropic: How we built our multi-agent research system (GitHub summary)
• Simon Willison: Anthropic's multi-agent research system
• Hugging Face Papers: Why Do Multi-Agent LLM Systems Fail?
• Future AGI: Why do multi-agent LLM systems fail
• Medium: I built a 9-agent AI pipeline that researches, writes and fact-checks articles
• DEV Community: AI blog drafts fact-checked, my drafter invented a bug
• DEV Community: claimcheck, Gemma 4 fact-checks my AI blog drafts
• arXiv: Detecting and Correcting Reference Hallucinations
• arXiv: How LLMs Cite and Why It Matters
• JMIR via EurekAlert: GPT-4o citation fabrication
• arXiv: Legal hallucination benchmark

Run one post and read its receipts

Start one of your 2 free posts on Ryterr, no card needed, using a topic from your own backlog. When it finishes, open the Review tab, pick three claims and click through to each source page to confirm the wording matches. Check the before and after corrections and any open warnings, and confirm a flagged post would wait for you instead of publishing on schedule. If you're comparing tools, score each one with the Soro alternatives checklist.