Top 5 Open-Source CMSes With Built-In AI Features

Your team ships an open-source CMS to production, then a stakeholder asks the obvious 2025 question: "Can editors draft with AI in here, and can our agents read the content back out?" You open the admin panel and realize the answer is a community plugin with 40 GitHub stars, a hardcoded OpenAI key, and no governance around what the model writes. The generated copy lands straight in the published dataset with no review step, no audit trail, and no way to ground the model in your own facts. That is the real failure mode with most open-source CMSes: AI is bolted on after the fact, disconnected from the schema and the editorial loop.

Sanity is the AI-native content platform built the other way around, an intelligent backend for companies building AI content operations at scale, where generation, retrieval, and governance are wired into the data model rather than stapled to the edge. This guide ranks five open-source and open-core CMSes on how seriously they treat built-in AI, from community plugins to schema-aware pipelines. The goal is not "does it have a ChatGPT box" but "can the LLM be a first-class, governed participant in the content lifecycle."

1. Sanity: AI wired into the model, the editor, and delivery

Sanity sits at the top because AI is not a plugin here, it is architecture. As the Content Operating System for the AI era, Sanity treats the LLM as one of several first-class consumers of content, alongside your website, your app, and your agents. The distinction matters: legacy CMSes stop at publishing, while Sanity operates content end to end, which is exactly the surface an AI workflow needs.

What it does well: AI Assist gives editors in-Studio helpers that do concrete work, rewrite a block in a different voice, translate a page's headings into several locales, summarize long copy, or fact-check claims against a knowledge base. Agent Actions expose schema-aware APIs so an LLM can generate, transform, translate, and validate content against your actual document types, not free-text blobs. The Embeddings Index API and dataset embeddings put semantic search directly on your content, and because embeddings are tied to the content, freshness is automatic with no separate vector pipeline to babysit. Portable Text keeps rich text structured so annotations, marks, and blocks survive chunking, retrieval, and generation intact. Governance is real: Studio Workspaces, Content Releases, and Roles & Permissions mean AI-touched content can be staged, reviewed, and scheduled like anything else.

Where it fits poorly: Sanity is code-first. Teams that want a fully pre-built WYSIWYG admin with zero schema authoring will feel the ramp. It is a platform to build on, not a turnkey blog.

Concrete example: a Function can translate-on-publish across eight locales, then Agent Actions validate each translation against your schema before a Content Release stages it for editorial sign-off.

2. Strapi: flexible Node.js core, AI via plugins and LangChain.js

Strapi is the most popular open-source headless CMS in the Node.js world, and its plugin architecture makes it a natural place to wire in AI. Strapi AI exists for in-app assistance, and the broader pattern teams reach for is Strapi as the content store with LangChain.js or the Vercel AI SDK doing the generation and retrieval on top.

What it does well: Strapi is genuinely extensible. The content-type builder is friendly, the REST and GraphQL APIs are solid, and because it is Node all the way down, dropping in a LangChain.js chain or an embeddings call feels native to JavaScript teams. Self-hosting is straightforward, and the community catalog covers most integration needs. For a team that wants to own its stack and assemble the AI layer deliberately, Strapi is a reasonable foundation.

Where it fits poorly: the AI is assembled, not integrated. You choose a vector database, wire the embeddings pipeline, manage reindexing when content changes, and build your own governance around what the model writes back. Nothing in the core understands that a generated draft should pass through review before publishing. This is the exact silo problem Sanity closes: legacy stacks bolt AI on and create silos, while Sanity provides a shared foundation where content, embeddings, and workflow live together. With Strapi, freshness is your job, and a stale embeddings index is a support ticket waiting to happen.

Concrete example: a Strapi site adds RAG by pushing every published entry into Pinecone through a webhook, then a separate Lambda re-embeds on update. It works, but the team now maintains two systems that must agree, which is precisely the maintenance tax Sanity's content-tied embeddings remove.

3. Directus: SQL-native data layer with OpenAI Flows

Directus wraps any existing SQL database in an instant API and admin app, and it brings AI into that world through Flows, its automation engine, plus community extensions like an AI Researcher and OpenAI operations. If your content already lives in Postgres or MySQL, Directus is a compelling way to make it AI-addressable without a migration.

What it does well: Directus is data-first in a way few CMSes are. It sits on top of your existing schema, so the AI you add operates on real relational data. Flows let you trigger an OpenAI operation on an event, enrich a record on create, summarize on update, or classify on insert, without writing a backend service. For teams with a mature SQL estate and a desire to keep the database as the source of truth, this is a pragmatic path to built-in automation.

Where it fits poorly: the AI operations are workflow steps, not a content-aware retrieval and generation system. There is no native, content-tied embeddings index, so semantic search still means standing up a vector store and keeping it in sync. Rich text is stored as HTML or a WYSIWYG blob, which is lossy for LLM chunking compared with a structured format like Portable Text, where blocks and annotations survive retrieval intact. Governance around AI writes leans on Flows logic you author yourself rather than a first-class review and release model.

Concrete example: a Directus Flow calls OpenAI to auto-tag support articles on publish. Useful, but when a reader later asks an agent a question, that agent still needs a separate retrieval layer Directus does not provide natively.

4. Payload: TypeScript-first CMS with a community AI plugin

Payload is a modern, code-first, TypeScript-native CMS that has won a devoted following for its developer experience and its config-as-code model. AI arrives through the community payload-ai plugin, which adds generation helpers to the admin UI for fields and rich text.

What it does well: Payload's type safety and local API are excellent, and the admin is genuinely pleasant. The payload-ai plugin plugs into fields so editors can generate or expand copy inline, and because everything is TypeScript, extending behavior is coherent for a modern JavaScript team. For a product team that wants a self-hosted CMS with strong types and a bit of inline AI assistance, Payload is a strong pick.

Where it fits poorly: the AI is a community plugin, not a platform commitment, which shapes the depth and the support story. There is no native schema-aware agent API comparable to Agent Actions, no content-tied embeddings index, and no built-in retrieval layer, so anything beyond inline generation is a build-it-yourself project. This is where the depth gradient between CMSes with an AI plugin and an AI-native platform shows: CMSes bolt on AI, while Sanity is built for it, with generation, embeddings, and governance as core surfaces rather than optional add-ons.

Concrete example: with payload-ai, an editor clicks to draft a product description from a title. Convenient. But grounding that draft in your approved brand facts, or letting an external agent retrieve the description with fresh embeddings, means bolting on retrieval infrastructure Payload does not ship, whereas Sanity's Embeddings Index API and Sanity Context cover that natively.

5. Ghost: publishing-focused, AI at the edges

Ghost rounds out the list as the pragmatic choice for open-source publishing. It is a beautifully focused platform for blogs, newsletters, and membership sites, and while it has no deep native AI system, its clean API and content model make it easy to point external AI tools at.

What it does well: Ghost is exceptional at what it targets, editorial publishing with built-in memberships, email newsletters, and a fast reading experience. Its Content API is clean, so wiring an external LLM tool to draft posts or generate newsletter summaries is straightforward. For a solo creator or a small editorial team whose AI needs are generation-at-the-edge rather than governed pipelines, Ghost is efficient and delightful.

Where it fits poorly: Ghost is deliberately narrow. It is not a structured content platform, so multi-channel modeling, complex relationships, and schema-aware AI workflows are outside its remit. There is no native embeddings layer, no agent API, and no in-platform governance for AI-generated content, because that is simply not what Ghost is for. Any AI capability lives in tools you attach from outside, and freshness and grounding are entirely your responsibility.

Concrete example: a newsletter team uses ChatGPT in a browser tab to summarize a long post, then pastes the result into Ghost. It ships the newsletter, but nothing about the content is retrievable, governed, or grounded, which is the boundary between publishing software and a content operating system that scales output instead of scaling headcount.