Chapter 4: Choosing the Content Backend

Sources: Sanity MCP docs; Storyblok MCP Server; Strapi "The Strapi MCP server is out" (May 2026); Payload MCP plugin docs; statichunt git-based CMS 2026. (As of 2026-06-05: the MCP-parity picture has converged — every SaaS and self-hosted vendor here now ships a first-party MCP server. Strapi shipped a native MCP server in Beta on 28 May 2026 (built into core, v5.47.0+, free/self-hosted); Contentful now provides its own first-party MCP server; Payload's @payloadcms/plugin-mcp became extensible (other plugins can inject tools). Also note: Salesforce announced a definitive agreement to acquire Contentful on 1 June 2026 (pending close, ~Q3 FY27) — weigh acquisition-integration uncertainty when selecting Contentful for new work.)

Criteria that actually decide an AI-CMS

Below is the scoring rubric used throughout this report. Weight the columns to your context — a marketing-heavy product weights Editor/visual editing high; an agent-first product weights AI/MCP and structured content high.

1. AI generation & agent ergonomics — Is there an MCP server? Can an agent query, create, patch, and publish with field-level precision? Are there guardrails (validation, draft/release workflow) so agent writes are safe?
2. Structured content fidelity — Is rich text stored as structured JSON (Portable Text) or as an HTML/Markdown string an LLM must parse and risk corrupting? Are references, blocks, and localization first-class?
3. Schema flexibility & migrations — Schema-as-code (versioned, reviewable, agent-mutable) vs. UI-clicked schema vs. SQL migrations. Cost of changing the model at 1,000 pages.
4. Scale to ~1,000 pages (and beyond) — Query performance, API rate/entry limits, CDN behavior, localization multiplier (1,000 pages × 8 locales = 8,000 documents).
5. Total cost of ownership (5-yr) — Subscription vs. infra + ops labor. SaaS pricing that scales on API calls/entries vs. flat self-hosted infra.
6. Lock-in & portability — Can you export everything (content + schema) and leave? Proprietary query language (GROQ) vs. SQL vs. plain files.
7. Editorial experience — Visual/in-context editing, roles, workflow, preview.
8. Operational burden — Patches, upgrades, backups, security — who carries it.

Family 1 — Headless SaaS

Sanity is, as of mid-2026, the de facto reference for AI-native content operations. Its Content Lake stores any valid JSON document; schemas are defined as TypeScript/JS objects in your codebase (schema-as-code), so changes are instant with no database migration. Rich text is Portable Text — structured JSON an agent can read and rewrite without parsing HTML. Its remote MCP server (https://mcp.sanity.io, OAuth or token) is generally available and exposes 40+ tools: GROQ queries, document create/patch/publish, schema fetch/deploy, release workflows, semantic search over embeddings indices, and image generation (Sanity docs). Note that several AI tools consume AI credits (Markdown doc creation, image ops) and can be disabled. Pricing: a production-viable Free tier (generous API limits, ~20 seats), Growth around $15/user/mo, Enterprise custom (luckymedia 2026). The trade-off is GROQ lock-in and usage-metered billing (API calls, bandwidth, asset CDN) that requires modeling.

Contentful is the enterprise governance pick: mature roles/permissions, environments, and content workflows. Its weaknesses for an AI-CMS in 2026 are pricing and agent-readiness. Plans run Free → Basic → Premium with costs from $0 to $2,000+/mo (techsy 2026), historically gated on API calls per month and entry/space limits — server-side rendering that bypasses the CDN cache "hits limits fast" (netsolutions). Schema is UI/config-defined, which is friendlier to non-developers but less agent-mutable. (As of 2026-06-05: Contentful now provides its own first-party MCP server (no longer just "partial/emerging"), and on 20 May 2026 shipped Contentful Skills — a free open-source package teaching AI coding agents like Cursor/Claude Code/Copilot how to build on Contentful. The big caveat: Salesforce announced a definitive agreement to acquire Contentful on 1 June 2026 (pending, expected close ~Q3 of Salesforce FY2027); pricing/roadmap should now be treated as volatile.)

Storyblok is the visual-editing gold standard — component-based drag-and-drop that marketers love — and it launched its MCP server in March 2026 (Storyblok). The server is now GA and exposes 155+ tools over the Management API with an enterprise permission model (execute_readonly for reads; execute_destructive requiring explicit intent for writes/publish/delete). Content is structured (blocks/components as JSON). Pricing starts with a free Starter, then Growth around $99/mo (5 users) up to Elite, with the historic Entry→Business cliff partially addressed by 2026 repricing (g2; storyblok pricing FAQ). Choose Storyblok when non-technical visual composition outranks pure agent ergonomics.

Family 2 — Self-hosted open source

Payload 3 is the momentum pick for TypeScript/Next.js teams. It is TypeScript-first, schema-as-code (collections defined in TS), runs inside your Next.js app (single repo), and gives field-level access control and code-defined workflows with no plan gating (elmapicms 2026; punits.dev). It stores to Postgres or MongoDB. For an AI-CMS this is attractive: your domain model, admin UI, and API are one codebase an agent can read end-to-end; a community MCP server exists, and the Local API lets you wrap agent actions in your own validated server functions. You own hosting, upgrades, and backups.

Strapi 5 is the "batteries-included editor-independence" default: large plugin ecosystem, mature admin UI, roles, media library. Schema is code-ish (content-type builder writes schema files). Crucially, Strapi shipped a native first-party MCP server on 28 May 2026 (Beta) — built into core (exposed as a route on the existing HTTP server, no separate process), requires Strapi v5.47.0+, free/self-hosted only (not a Strapi Cloud feature at launch), covering CRUD + publish/unpublish, with a new scoped admin-API-token system so an agent gets only the tools it needs (strapi.io; as of 2026-06-05 — supersedes the earlier "open RFC, in dev" status). Some advanced RBAC is paid (Strapi Cloud / Enterprise). Choose Strapi when you want a familiar Node stack and a big plugin marketplace, and can babysit Node upgrades.

Directus is database-first: it wraps an existing SQL database and auto-generates REST/GraphQL + an admin UI. It wins when SQL is already the source of truth, analysts expect direct DB access, or migrations are how the org already thinks (dasroot 2026; strapi comparison). For an AI-CMS, Directus pairs naturally with the "custom DB" family below — you keep Postgres authoritative and use Directus for the editorial layer. MCP is community-driven.

Family 3 — Custom database (Postgres / Supabase)

The maximalist option: no CMS product, just Postgres (often via Supabase) as the authoritative store, your own schema, and your own admin UI (or Directus/Supamode on top). Why it is increasingly viable for an AI-CMS:

• One store for content + AI features. Supabase ships pgvector for embeddings, so the same database holds your structured content and the vector index that powers semantic search and RAG — no separate vector DB. Reported builds handle 100K+ documents with sub-50ms indexed queries (supabase docs; descope).
• JSONB hybrid modeling. Relational columns for queryable fields (slug, locale, status, published_at) plus JSONB for flexible block content gives structured fidelity without rigid schema churn.
• Row Level Security (RLS) enforces multi-tenant/role isolation at the database layer — agent and human writes obey the same policies, even if an API key leaks (makerkit; supabase).
• Agent access via the Supabase MCP server (Postgres-level), or, more safely, behind your own validated RPC/Edge Functions so agents never get raw write access.

The cost is you build the editorial UX and governance that SaaS gives for free, and you own all migrations. This is the right floor when content is deeply entangled with application data (e-commerce catalogs, user-generated content, per-itinerary microsites) and you want zero query-language lock-in (plain SQL).

Family 4 — Git-based

TinaCMS, Decap, and Keystatic store content as Markdown/MDX/YAML/JSON files in your Git repo. Benefits: zero database, free hosting on static platforms, full version history, and content that is trivially diffable in pull requests — which dovetails beautifully with agentic workflows where an AI opens a PR you review. TinaCMS adds visual in-context editing plus a hosted backend (Tina Cloud); Decap is the most established (~18k stars, widest backend/SSG support); Keystatic (Thinkmill) has the cleanest Astro/Next.js integration and a generous free tier (luckymedia; statichunt; github/tinacms).

For AI, the agent ergonomics are indirect but excellent at small scale: an agent edits files with ordinary filesystem/Git tools and you get a reviewable diff — the cleanest possible audit trail. The hard limits are scale and relational content: Git CMSes degrade past a few hundred–~1,000 files, have no real query engine (no "give me all posts in category X, locale fr, published last month" without building an index), and localization multiplies file count fast. Great for docs, blogs, and marketing sites; poor for relational, high-volume, multi-locale catalogs.

How each serves the three pillars

AI generation. Best-in-class is a structured store with a real MCP server and validation guardrails: Sanity (40+ MCP tools, Portable Text, releases) leads SaaS; Payload leads self-hosted (single TS repo + Local API wrapping); Supabase leads custom (MCP + RLS + pgvector for RAG). Git-based gives the best review loop (PR diffs) but the weakest query loop.

Structured content. Portable Text (Sanity) and block/JSONB models (Storyblok, Payload, Postgres-JSONB) let an agent mutate a paragraph or swap a block without corrupting markup — strictly better than agents regenerating HTML strings. Plain-Markdown Git CMSes are structured enough for prose but weak for referenced/relational content.

1,000-page scale. This is where SaaS pricing and Git limits bite. Model the localization multiplier (1,000 pages × N locales). Postgres/Supabase and self-hosted OSS scale on flat infra cost; SaaS scales on API calls/entries/seats — cacheable reads are cheap, but uncached SSR and bulk agent writes can spike metered bills. Git-based starts to strain on build times and file counts around this volume.

Scenario-based recommendations

A pragmatic hybrid worth naming

Many strong 2026 stacks combine families: Postgres/Supabase as the authoritative content + vector store, an editorial layer on top (Directus, Payload's admin, or a custom UI), and agents that act through validated server functions/RPC rather than raw MCP write access. This keeps deterministic guarantees (RLS, validation) while giving agents the read/draft power they need — the single most important safety pattern when an LLM can write to production content.

Key Takeaways

• The decisive 2026 axis is agent-readiness: structured content (JSON/Portable Text), schema-as-code, and a first-class MCP server — not the old SaaS-vs-self-hosted split.
• Sanity is the reference AI-native SaaS (GA MCP, 40+ tools, Portable Text, instant schema), with GROQ lock-in and usage-metered billing as the trade-offs.
• Payload 3 is the best self-hosted choice for TS/Next.js teams (schema-as-code, free field-level ACL, single repo, Local API to safely wrap agent writes).
• Supabase/Postgres is the strongest custom option when content is entangled with app data and you want one store for content + pgvector RAG, governed by RLS — at the cost of building editorial UX yourself.
• Storyblok wins on visual editing (MCP GA since Mar 2026, 155+ tools); Contentful wins on enterprise governance and now ships its own first-party MCP server + Contentful Skills (May 2026) — but is under a pending Salesforce acquisition (announced 1 Jun 2026), so treat its roadmap/pricing as volatile.
• Git-based CMSes give the cleanest agentic audit trail (PR diffs) and free hosting but degrade past ~1,000 files and lack a query engine — ideal for docs/blogs, not relational catalogs.
• Always model the localization multiplier (pages × locales) and SaaS API-call/entry limits before committing at 1,000-page scale.
• The safest production pattern is to let agents read/draft freely but write through validated RPC/workflow guardrails, never raw write access to live content.

Key References

• Sanity. MCP Server | Sanity Docs. 2026. https://www.sanity.io/docs/ai/mcp-server — Authoritative spec of the remote MCP server: HTTP transport, OAuth/token auth, 40+ tools, AI credits.
• Sanity. Content Lake. 2026. https://www.sanity.io/content-lake — JSON document store and schema-as-code architecture.
• Sanity. Sanity Remote MCP Server is Generally Available. 2026. https://www.sanity.io/blog/sanity-remote-mcp-server-is-generally-available — GA announcement and agent setup positioning.
• llmcms.org. 7 CMS Platforms With the Best MCP Server Support for AI Agents in 2026. 2026. https://www.llmcms.org/guides/best-cms-mcp-server-support-ai-agents-2026 — Cross-platform MCP readiness incl. Storyblok (Mar 2026) and Strapi.
• Strapi. The Strapi MCP Server Is Out — Wire Agents to Your Content. 2026-05-28. https://strapi.io/blog/the-strapi-mcp-server-is-out-wire-agents-to-your-content — Native first-party MCP server (Beta), v5.47+, scoped admin tokens.
• Storyblok. MCP Server. 2026. https://www.storyblok.com/mp/mcp-server — 155+ tools, execute_readonly/execute_destructive permission model.
• The Next Web. Salesforce acquires Contentful headless CMS for Agentforce. 2026-06-01. https://thenextweb.com/news/salesforce-acquires-contentful-headless-cms-agentforce — Definitive agreement (pending close ~Q3 FY27).
• ElmapiCMS. Payload vs Strapi vs Directus: Which One Should You Pick? (2026). 2026. https://elmapicms.com/blog/payload-strapi-directus-which-one-2026 — Self-hosted feature/ACL/workflow comparison.
• dasroot.net. Headless CMS Comparison 2026: Strapi vs Directus vs Payload. 2026. https://dasroot.net/posts/2026/01/headless-cms-comparison-strapi-directus-payload/ — Architecture/philosophy contrasts (DB-first vs schema-as-code).
• Lucky Media. Best Headless CMS 2026 – Sanity vs Contentful vs Storyblok Compared. 2026. https://www.luckymedia.dev/insights/headless-cms — SaaS positioning and Sanity pricing tiers.
• TECHSY. Contentful CMS Guide: Pricing, API & Code [2026]. 2026. https://techsy.io/en/blog/contentful-guide — Contentful plans ($0–$2,000+), API-call gating.
• G2. Storyblok Pricing 2026. 2026. https://www.g2.com/products/storyblok/pricing — Starter/Growth (~$99) → Elite pricing tiers.
• Supabase. pgvector: Embeddings and vector similarity | Supabase Docs. 2026. https://supabase.com/docs/guides/database/extensions/pgvector — Embeddings in Postgres for content + RAG in one store.
• MakerKit. Supabase RLS Best Practices: Production Patterns for Secure Multi-Tenant Apps. 2026. https://makerkit.dev/blog/tutorials/supabase-rls-best-practices — RLS isolation patterns for governed agent/human writes.
• Statichunt. 7 Best Git-Based Headless CMS for Static Sites in 2026. 2026. https://statichunt.com/blog/git-based-headless-cms — TinaCMS/Decap/Keystatic comparison and scale limits.
• TinaCMS. GitHub — tinacms/tinacms. 2026. https://github.com/tinacms/tinacms — Markdown/MDX + visual editing reference.
• Strapi. Using Claude Code with Strapi: AI-Powered MCP Workflows. 2026. https://strapi.io/blog/claude-code-strapi-mcp-ai-content-workflows — Strapi MCP direction and agent workflows.