AI content operations

AI Drafts Belong in the CMS Where Your Editors Already Approve Work

How to integrate an AI content workflow with WordPress, Sanity, Strapi or Webflow so drafts land unpublished and editors approve them inside the CMS.

On this page

AI content pipelines tend to lose their time after the model finishes. The draft sits in a document, a chat thread or the AI tool's own dashboard until someone copies it into the CMS, repairs the formatting, retypes the metadata and finds the person allowed to publish. We think the approval chain belongs inside the CMS. The CMS already knows who may publish, already gives editors a queue and already emits the events a pipeline needs, so the AI should write drafts through the API as a user that cannot publish, and editors should approve them in the screen they use every day.

This guide draws on the vendors' own documentation for WordPress, Sanity, Strapi and Webflow, read on November 6, 2026: draft states, review workflows, roles and webhooks, then a field mapping table and a worked pipeline. If you are still deciding how much autonomy an agent should have at all, our explainer on what agentic AI is covers that ground first.

Start with a writer account that cannot publish

The best practice for integrating an AI content workflow with a CMS and its approval chain is to give the pipeline its own CMS user and choose a role that lacks the publish capability. A role without that capability holds even when the model misreads its instructions, and every other rule depends on it.

WordPress shows the idea clearly. WordPress describes the Contributor as "somebody who can write and manage their own posts but cannot publish them." Its capability table gives publish_posts to Authors, Editors and Administrators, and edit_others_posts only from Editor up. The same table holds a catch: Contributors lack upload_files, so an AI account at that level cannot add images. Promoting it to Author fixes images and also grants publish_posts. We would keep image upload as a separate step, or build a custom role that has upload_files and leaves out publish_posts, before handing a model the publish button.

Four more rules follow from the first:

  • Send the state on every write. Strapi publishes when the status is missing, and a single false in Webflow queues an item for the next site publish.
  • Review where the content lives. Edits, comments and the final publish happen in the CMS editor, so the approved version is the shipped version.
  • Let events report back. A webhook, or a scheduled status check where we found no webhook, tells the pipeline when a draft was published, returned or discarded.
  • Write provenance into the entry: the model, the brief ID and the sources the draft relied on, in fields an editor can see. That pairs with the checks in keeping an agent's product claims accurate.

What each CMS calls a draft, a review and a publish

A headless CMS content workflow runs on three API surfaces: how a draft gets written, where the approval workflow lives, and which webhook reports a publish. Each vendor's documentation answers those differently.

CMSHow the API writes a draftThe default to watchWhere review happensWhat reports back
WordPressPOST /wp/v2/posts with status set to pendingFive possible statuses; send one on every callpending posts, published by an Editor or AdministratorWe found no outgoing webhook in the REST pages we read; check status on a schedule
SanityA document stored under the drafts. pathAt most one draft per documentThe draft document; Content Releases on certain Enterprise plansGROQ webhooks, which skip drafts unless you enable "Drafts and versions"
StrapiPOST /api/:pluralApiId?status=draftNo status means publish immediatelyReview Workflows on Enterprise, with a required stage for publishingentry.publish, plus review-workflows.updateEntryStage on Enterprise
WebflowPOST /v2/collections/{collection_id}/items with isDraft: trueisDraft: false queues the item for the next site publishThe item's status, read from isDraft and lastPublishedcollection_item_published and collection_item_unpublished webhooks, or lastPublished on the item

WordPress

The WordPress REST reference lists five values for a post's status on create: publish, future, draft, pending and private. We have the pipeline send pending, which keeps AI drafts in their own pile, apart from the half-written drafts editors keep for themselves. For credentials, WordPress says "As of 5.6, WordPress has shipped with Application Passwords," created from the user's edit page and passed to REST requests over HTTPS with Basic Auth. Create one on the AI account and nowhere else.

Sanity

Sanity keeps a draft under the drafts. path, a release version under versions., and the published document with no prefix; publishing copies the draft into the unprefixed document. Two lines on that page shape a pipeline. "A document has at most one draft at a time," so an AI rewrite of a live page lands in the same draft an editor may already be changing, and the pipeline should check for an existing draft before it writes. "Neither drafts nor versions are served to unauthenticated requests," so preview links need an authenticated client.

On notifications, Sanity says its GROQ-powered webhooks ignore documents in the drafts. and versions. namespaces by default. A webhook that announces new AI drafts needs the "Drafts and versions" setting switched on; one that reacts to publishes can leave it off. The same page adds a secret that is hashed into the request headers, which your receiver should verify, and notes that "Webhooks are limited to one concurrent request."

Strapi

Strapi carries the riskiest default in this set. The Strapi REST documentation says "a POST request without a status parameter creates the document and publishes it immediately," and an update without status publishes the changes too. Every write from the pipeline needs ?status=draft.

Review Workflows need an Enterprise plan, according to Strapi. The default workflow "is configured to have 4 stages, in this order: To do, Ready to review, In progress, and Reviewed." Each stage names the roles that can move content into it and out of it, and the "Required stage for publishing" setting blocks publishing until an entry sits at the stage you pick. For events, Strapi lists entry.create, entry.update, entry.publish, entry.unpublish and entry.draft-discard, with review-workflows.updateEntryStage on Enterprise only. Publishing saves the draft first, so entry.update arrives just before entry.publish; key approval logic on the publish event.

Webflow

Webflow creates collection items at POST https://api.webflow.com/v2/collections/{collection_id}/items with the CMS:write scope. isDraft defaults to true, and name and slug sit inside fieldData. The Webflow publishing guide reads status from two values: with no lastPublished and isDraft set to false, the item is queued and "Content will be published on the next site-wide publish." A pipeline bug that sends false would ship the draft the next time anyone publishes the site for any reason. The helpful case runs the other way: editing a live item with isDraft: true keeps the live version up while the changes wait in draft, which suits AI refreshes of existing pages. Approval then means an editor publishes the item, or the pipeline sets isDraft to false and calls the publish-item method (publishItem in Webflow's SDK) after a person signs off. Webflow also sends collection_item_published and collection_item_unpublished webhooks, so the pipeline can learn about a publish without polling. We found no review-stage feature in the two Webflow API pages we read.

Contentful

Contentful is the fifth platform buyers ask about. We could not read its current documentation for this piece, so it stays out of the tables. Put the same four questions from the table above to its docs before you build.

Mapping the pipeline's output to CMS fields

Editors approve faster when the draft arrives complete. The table maps what a generator produces to the fields each API expects. Sanity and Strapi fields are whatever your schema or content type defines, so those cells name the job each field does.

Pipeline outputWordPress REST fieldWebflow item fieldSanity and Strapi
HeadlinetitlefieldData.nameA title field in your schema
URLslugfieldData.slug (changing it later breaks old links)A slug field
BodycontentA rich text field in the collectionA rich text field
SummaryexcerptA plain text fieldA summary field
Review statestatus: "pending"isDraft: true at the top levelSanity: an ID under drafts.; Strapi: ?status=draft
Bylineauthor, set to the AI accountA reference fieldA reference or relation field
Topicscategories, tagsA reference fieldA reference or relation field
Provenance (model, brief ID, sources)metaA plain text field editors can seeA field editors can see

A worked pipeline that keeps approval in WordPress

Hypothetical example. A small marketing team runs WordPress with two Editors and wants AI drafts of supporting articles built from approved briefs. No results are claimed here; the example shows the wiring.

  1. A brief is approved in the team's ticket tool. The pipeline pulls it, gathers sources and generates the draft with every mapped field filled.
  2. It writes to WordPress as a Contributor-role account, using that account's Application Password.
  3. It posts a link to the new draft in the editors' channel.
  4. An Editor opens the post in WordPress, edits it, and either publishes it or sets it back to draft with a note.
  5. A scheduled job checks the AI account's posts by status. Published posts get logged with the time from creation to publish. Posts returned to draft send the note back to the pipeline.
  6. Rejection reasons become cases in the agent's test set, the method in writing evaluation criteria and test sets.

The write in step 2 looks like this (IDs and meta keys are illustrative, and WordPress makes a custom meta key accessible through the REST API once it is registered with show_in_rest set to true):

{
  "title": "How to size a returns budget",
  "slug": "size-a-returns-budget",
  "content": "Full draft body",
  "excerpt": "One-paragraph summary",
  "status": "pending",
  "author": 42,
  "meta": { "ai_brief_id": "BR-118", "ai_sources": "url1, url2" }
}

On Strapi the same pipeline adds ?status=draft to every write, sets the workflow's required stage to Reviewed, and listens for review-workflows.updateEntryStage and entry.publish in place of the scheduled check.

How do you add AI drafts without slowing publishing?

An AI content generation CMS integration slows publishing speed in two ways: the draft arrives somewhere editors do not work, or it arrives as text someone has to rebuild by hand. Complete field mapping fixes the second. Writing into the CMS fixes the first, because the review queue becomes a view editors already have, the list of pending posts in WordPress or a stage in Strapi, with no second approval tool stacked on top.

The rest is guarding the automatic paths: Strapi's publish-by-default, Webflow's queue on the next site publish, and Sanity's single draft per document, which can collide with an editor's own work. Decide per content type how much review each one needs, using the tiers in our governance operating model for marketing agents, and keep the audit trail that a multi-agent governance layer describes once more than one agent writes.

Measure the time between a draft's creation and its publish event, which your webhook or status check already records. That number shows whether the pipeline sped publishing up, and it feeds the inputs of an AI ROI calculator. The test of a good integration is that an editor approving a draft does nothing different from approving a colleague's, apart from reading the provenance field. If you want a second pair of eyes on the wiring, our agentic AI automation page explains how we work.

Sources

Frequently asked questions

Should an AI content tool be allowed to publish straight to the CMS?
We would keep publishing with people for anything public. Give the pipeline its own CMS account with a role that cannot publish, such as the WordPress Contributor role, and let an editor publish after review. A missing capability keeps holding when a prompt is misread or a script sends the wrong value, which is the failure you are guarding against.
Which WordPress role should an AI writing account use?
Contributor, in most setups. WordPress describes it as able to write and manage its own posts but unable to publish them. The catch is images: Contributors lack the upload_files capability, and the Author role adds upload rights and publish rights together. Handle images in a separate step, or create a custom role that uploads files without publishing.
Does Strapi save entries created through the API as drafts?
Only when you ask. Strapi's REST documentation says a POST request without a status parameter creates the document and publishes it immediately, and an update without one publishes the changes. Add ?status=draft to every create and update the pipeline sends, and test what your pipeline does when that parameter goes missing before launch.
Why does my Sanity webhook stay silent when an AI draft is created?
Sanity's GROQ-powered webhooks ignore documents in the drafts. and versions. namespaces by default. Turn on the Drafts and versions setting for the webhook that should announce new drafts, and keep a separate webhook, with that setting off, for reacting to published documents.
Can Webflow hold an AI draft until an editor approves it?
Yes. The Webflow Data API creates collection items with isDraft set to true by default, so keep it that way. Setting isDraft to false on a never-published item queues it for the next site-wide publish, which means it goes live whenever anyone publishes the site. Publish the item only after a person signs off.

Free tools for this topic

FREE TOOLAI Brand Visibility MonitorDoes ChatGPT recommend you — or your competitor?CALCULATORAI & Automation ROI CalculatorPut a payback date on every automation idea.FREE TOOLAI Readiness ScorecardTwelve questions. Your automation roadmap, scored.

Keep reading

AI & MLThe Governance Operating Model That Lets Marketing Agents Ship Work AloneRead →AI & MLThe Governance Layer Every Multi-Agent Marketing Stack Is MissingRead →AI & MLHow to Keep a Marketing Agent's Product and Pricing Claims AccurateRead →
CATALIST NEWSLETTER

Monthly dose of growth marketing.

Get marketing tips, narratives, guides, and playbooks delivered to your inbox.

Protected by reCAPTCHA — Google's Privacy Policy and Terms of Service apply.