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
falsein 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.
| CMS | How the API writes a draft | The default to watch | Where review happens | What reports back |
|---|---|---|---|---|
| WordPress | POST /wp/v2/posts with status set to pending | Five possible statuses; send one on every call | pending posts, published by an Editor or Administrator | We found no outgoing webhook in the REST pages we read; check status on a schedule |
| Sanity | A document stored under the drafts. path | At most one draft per document | The draft document; Content Releases on certain Enterprise plans | GROQ webhooks, which skip drafts unless you enable "Drafts and versions" |
| Strapi | POST /api/:pluralApiId?status=draft | No status means publish immediately | Review Workflows on Enterprise, with a required stage for publishing | entry.publish, plus review-workflows.updateEntryStage on Enterprise |
| Webflow | POST /v2/collections/{collection_id}/items with isDraft: true | isDraft: false queues the item for the next site publish | The item's status, read from isDraft and lastPublished | collection_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 output | WordPress REST field | Webflow item field | Sanity and Strapi |
|---|---|---|---|
| Headline | title | fieldData.name | A title field in your schema |
| URL | slug | fieldData.slug (changing it later breaks old links) | A slug field |
| Body | content | A rich text field in the collection | A rich text field |
| Summary | excerpt | A plain text field | A summary field |
| Review state | status: "pending" | isDraft: true at the top level | Sanity: an ID under drafts.; Strapi: ?status=draft |
| Byline | author, set to the AI account | A reference field | A reference or relation field |
| Topics | categories, tags | A reference field | A reference or relation field |
| Provenance (model, brief ID, sources) | meta | A plain text field editors can see | A 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.
- 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.
- It writes to WordPress as a Contributor-role account, using that account's Application Password.
- It posts a link to the new draft in the editors' channel.
- An Editor opens the post in WordPress, edits it, and either publishes it or sets it back to draft with a note.
- 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.
- 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
- WordPress, REST API reference: Posts
- WordPress, Roles and Capabilities
- WordPress, REST API authentication
- Sanity, Drafts
- Sanity, Webhooks
- Strapi, REST API
- Strapi, Review Workflows
- Strapi, Webhooks
- Webflow, Create collection item
- Webflow, Publishing CMS items
- Webflow, Working with webhooks
- WordPress, REST API: Modifying responses
