Agent Design Patterns for Content Pipelines and SEO Metadata
What are effective agent design patterns for end to end AI content pipeline automation and SEO metadata generation? The ones that hold up split planning from writing, run research, drafting, editing and review as separate stages, ground every draft in a knowledge base, give a reviewer agent a veto, and put a deterministic gate in code in front of publishing. Metadata is generated against length limits and validated, a person approves, budgets cap spend, retries are idempotent and every step is logged.
Why does an AI content pipeline need design patterns at all?
A single prompt that says "write a blog post about X" works once. Run it daily and the failures show up fast: invented product facts, an over-long meta description, a post that publishes twice, a bill nobody expected. Each pattern below stops one of those failures. The worked example throughout is the Blog Studio pipeline on CREA's content team, the AI Content Chief of Staff on Nagent, described from its code and public docs.
Pattern: Planner and worker split, The failure it stops: Long drafts that lose structure, Where it lives: Model calls
Pattern: Staged pipeline, The failure it stops: One prompt doing five jobs badly, Where it lives: Orchestrator
Pattern: Grounding and retrieval, The failure it stops: Invented facts and links, Where it lives: Evidence list
Pattern: Reviewer with a veto, The failure it stops: Weak drafts reaching a person as finished, Where it lives: Reviewer agent
Pattern: Human override with a reason, The failure it stops: Silent overrides nobody can audit, Where it lives: Publish path
Pattern: Deterministic publish gate, The failure it stops: Structure rules the model forgets, Where it lives: Code
Pattern: Validated metadata, The failure it stops: Titles and descriptions that break search snippets, Where it lives: Code plus model
Pattern: Human approval gate, The failure it stops: Agents publishing under your name, Where it lives: Workflow
Pattern: Budget caps, The failure it stops: Runaway spend, Where it lives: Atomic reservation
Pattern: Idempotent retries and logs, The failure it stops: Duplicates, and failures nobody can trace, Where it lives: Data layer
What is the planner and worker split?
One agent decides the shape of the work; others do the pieces. In a content pipeline the planner produces an outline as structured data (sections, the question each one answers, target length), and workers write each section against that plan.
Blog Studio's writer does this by length. A draft of up to 2,500 words is written in one call; above that, one model plans the outline and another writes the post section by section, each section told what the earlier ones covered so it does not repeat them. The same split appears one level up: when one ask needs several kinds of content, CREA writes one plan in which each piece names its maker, and approving the plan does not approve the pieces, because each still passes its maker's own approval and budget.
How should the stages of a content pipeline be split?
Give each job its own stage, with its own instructions and its own check. A sensible order is research, draft, edit, review, then the finishing work: images, internal links and metadata.
Blog Studio chains nine agents against a single run record: a topic scout (skipped when you supply the topic), a researcher, a writer, an editor, a reviewer, an illustrator, a linker, an SEO auditor, and a publisher that runs only after a person approves. The product screen puts it plainly: "Type a topic. Nine AI teammates do the rest: research, draft, edit, review, illustrate, link, audit."
Separate stages make failures local: you repair the step that broke instead of starting over.
How do you ground drafts in a knowledge base?
Retrieval first, writing second. The writer uses only an evidence list built before drafting, and anything the list does not support stays out.
In Blog Studio the researcher builds a numbered evidence list from the facts sheet, the Knowledge Hub and public sources. The draft takes up to six Knowledge Hub passages that match the topic, products from Products and services, voice from the brand book and the call to action from your booking link. If the Knowledge Hub has nothing on the topic, the draft is written without it rather than inventing detail, and internal links are never made up.
Then the pipeline checks the draft against that same list in code. Blog Studio's claim check holds every quote to word-for-word text in the item its sentence cites, every figure to an item that states it, and every third-party name to an item that names them and that a reader can open.
Why give a reviewer agent a veto?
Because a reviewer that only comments gets ignored. A reviewer with a veto sends the draft back with reasons, and the writer repairs what it named.
Blog Studio's reviewer reads each draft against the content rules, the brand voice and the evidence list the draft was written from. A rejection loops the draft back to the writer in repair mode, up to three attempts. Repair means only the failing sections go back to the model, and everything that passed is spliced back untouched, so a fix in one section cannot break another. After three attempts the draft goes to a person with the reviewer's reasons attached rather than looping forever.
A reviewer outage fails closed unless the deterministic gate has already passed the post, in which case it passes marked as not AI reviewed. Overriding a rejection of a team draft needs a separate permission that is not part of the workspace admin role.
How should a human override the reviewer?
Allow it, but make the person say why, and keep the reason with the post.
On a post someone writes by hand, Blog Studio's reviewer only advises. The editor shows "The reviewer advises against publishing this post" with its reason. To go ahead, a person with publish permission types Your reason for publishing anyway and clicks Accept and publish. The reason is recorded on the post's review and its timeline, next to the reviewer's original reason and suggestions.
Why should the publish gate be code, not an LLM?
A model reviewer can miss a missing FAQ or a broken link. A function cannot.
Blog Studio runs a deterministic content gate after drafting, after each repair, after linking and again at publish, before any model reviewer. It fixes what code can fix without changing meaning: dashes, a first heading that repeats the title, placeholder images, footnote markers with no public source, and a "What's next" heading. What only a writer can fix holds the post, with one sentence per problem, such as "The FAQ has 2 questions; it needs 3 to 5." The checks cover:
a lead paragraph of 40 to 90 words;
at least 60% of section headings written as questions;
a Frequently Asked Questions section with 3 to 5 questions;
the brand voice's person and contraction rules;
links a reader can open.
No permission overrides the gate. Its numbers live in one file that the writer prompt, the reviewer checklist and the gate all read, so writer and reviewer never disagree.
How do you generate SEO metadata an agent can be trusted with?
Treat metadata as a field with a contract, not a sentence the model writes once. Give the model the limits, check the result in code, repair what is cosmetic and fail what is missing.
In Blog Studio the writer's prompt carries the title limit of 25 to 80 characters and a meta description of 120 to 170 characters. After drafting, code trims an over-long meta description at the last word boundary, turns a slug that is not URL-safe into one that is, and derives tags from the title when none came back. Validation then fails the draft if the title, meta description, slug, focus keyword or excerpt is missing, or if the heading structure is broken. The SEO auditor stage asks a model for the meta description, focus keyword and slug, then runs a readability and heading check that is plain code. At approval, a person can edit the title, meta description and slug before anything publishes.
Where do human approval gates belong?
Where work leaves the building. Drafting and reviewing can run on their own; publishing under your name waits for a person.
Every Blog Studio run ends at Approve. The person sees the title, meta description, slug and body, plus any reviewer feedback, and chooses Send back with feedback or Approve & Publish. Agents on Nagent sit on an autonomy ladder, and no level below L5 Lead publishes on its own.
How do you cap spend in a multi-agent pipeline?
Reserve the budget before the work starts, atomically, and give it back if the work fails. A separate check and record lets two runs both pass.
Blog Studio reserves each run's estimated cost against the workspace's daily blog cap in a single conditional database update, so concurrent runs cannot overspend. If the cap is reached, the run stops with "Daily blog budget exceeded". If the run crashes, the reservation is refunded. The cap is set in credits under Daily blog spend cap in Settings, and the Studio board shows today's spend against it.
How do you make retries safe and the pipeline observable?
Make every step safe to run twice, and log each one.
For retries, Blog Studio writes the post insert-or-update by slug, so approving a run again refreshes the post instead of creating a duplicate, and a run that already published keeps its slug. A short draft gets up to two continuation passes instead of failing. For observability, each stage appends events to the run's timeline, which the run page shows as a Live agent feed beside the draft, citations and visuals, and each side-effecting step writes an action log row, with its duration and cost where the step reports them.
Frequently Asked Questions
What is the most important agent design pattern for content pipelines?
Grounding. Writing from an evidence list, and checking the draft against it in code, removes the biggest risk: confident claims about your product that are not true.
Should an LLM or code check SEO metadata?
Both. A model writes the title and meta description from the finished post. Code checks the length, the slug format and that every required field exists, and repairs what is cosmetic.
How many agents does an AI content pipeline need?
As many as it has distinct jobs with distinct checks. Blog Studio uses nine. A smaller pipeline can merge stages, but keep review and the publish gate separate from writing.
Can a content agent publish without a person?
It can be built to, but it should not publish under your name while it is still earning trust. On Nagent, every Blog Studio post waits for a person to approve it.
What should you do next?
Map your content workflow against the table above and find the first missing pattern. To see these patterns running on your own Knowledge Hub and brand, look at CREA's content team, or book a demo and we will run a topic through the pipeline with you.