What to Look for in a CMS for AI Agents

I build websites by talking to an agent. Claude Code writes the components, Cursor edits the styling, and I review the diffs. The coding part works now. The part that still breaks is the content management system behind the site.

Most CMS products were designed for a human clicking around a dashboard, and an agent can't click around a dashboard. So the moment you want an agent to read a page, draft a post, or add a feature, you discover whether your CMS was built for that or just bolted a chat box onto an old admin panel.

If you build with AI agents, the only question that matters is whether the agent can reach your content and your code directly. Everything else is secondary.

This is a buyer's checklist, and it applies to any CMS you're weighing, not just mine. I'll use Slim Minima as a worked example because it's the one I know inside out, and I'll be honest about where it's young.

The short version

Pick a CMS where the content is reachable over an API and an MCP server, you extend it by writing code instead of hunting for plugins, it emits machine-readable output like llms.txt and per-page markdown, the schema is typed so an agent can reason about it, you own the database and code outright, and it's cheap enough to run throwaway versions while you iterate.

Miss three or more and the agent spends half its time working around the tool instead of building your site.

1. The content has to be reachable by code

This is the first filter, and it eliminates a lot of options. An agent works through tools, so to touch your content it needs an endpoint it can call. Two things matter, and they're different.

A REST API lets the agent read and write content programmatically: list posts, fetch a page, create a draft. Most serious CMS products have this now. Check that it covers writes, not just reads, and that auth is a bearer key rather than an OAuth dance the agent can't complete on its own.

An MCP server is the newer and more useful piece. MCP, the Model Context Protocol, is an open standard for exposing tools to AI clients. When a CMS ships one, your agent gets named tools like "create post" that it calls directly inside Claude, ChatGPT, or whatever client you use, with no glue code in between.

You say "draft a post from these notes and add the hero image," and the agent calls create_post and add_image without opening the admin panel once.

Slim Minima exposes both: a REST API at /api/v1 (pages, posts, categories, media, settings, blocks catalog) and an MCP server at /api/mcp with tools like get_page, create_post, update_post, add_image, and find_post_by_title, all on the same hashed API key. One honest caveat: there's no delete tool over MCP on purpose, so destructive cleanup still happens by hand or via the CLI.

If a CMS gives you neither a write API nor an MCP server, cross it off.

2. You extend it by writing code, not by hunting for plugins

Here's where the old model and the agent model split hard. The traditional CMS answer to "I need a feature" is "find a plugin." That made sense when a human searched a marketplace, read reviews, and installed something. It makes no sense for an agent, which can't judge whether a plugin is maintained, safe, or compatible.

What an agent is good at is writing a small, self-contained piece of code when the surface area is clear.

So the question becomes: when you need a custom feature, can the agent add it by writing one file, or must it reverse-engineer a plugin ecosystem? A CMS where features live in code is one an agent can extend. You point it at the pattern, it writes the file, you review the diff.

In Slim Minima a content block is a single file at src/blocks/<name>/index.tsx that default-exports defineBlock. You register it in one array in src/blocks/registry.ts, and from there the editor palette, settings form, validation, API, and public renderer all pick it up automatically. An agent builds a new block in one pass because the contract is one file and one import.

The honest tradeoff: there's no plugin marketplace and no one-click install. If you want Stripe checkout or a booking form, the agent writes a block plus a server action plus the SDK integration. That's more work than clicking "install" on a mature WordPress plugin, and WordPress genuinely wins on breadth of ready-made functionality.

The bet is that an agent writing the exact code you need beats adopting someone else's plugin. For a custom build I think it wins; for a kitchen-sink site of off-the-shelf parts it doesn't. More on that in why WordPress doesn't work well in the AI age.

3. It outputs content that machines can read

Your site has two audiences now: people and models. AI search tools and agents read your pages to answer questions and to understand your content before editing it, and if your CMS only emits a pile of div soup, both struggle.

Look for two things. First, an llms.txt file and ideally a full-text markdown dump, so an agent or AI search crawler can read your whole site as clean text in one request instead of scraping HTML. Second, per-page markdown, so the agent can fetch one page before it rewrites it. Clean markdown instead of HTML means fewer mistakes and less wasted context.

Slim Minima serves a /llms.txt index, a /llms-full.txt markdown dump of the whole site, and per-page markdown at /<slug>.md and /blog/<slug>.md. Public pages are server-rendered, so a crawler gets real HTML, not an empty shell waiting on JavaScript. There's standard SEO plumbing too (canonical URLs, JSON-LD, sitemap, RSS), which matters because AI-friendly and search-friendly are mostly the same job. More on that in does free hosting hurt your SEO.

4. The schema is clean and typed

An agent reasons better about a system it can see clearly, and a typed content model is documentation it can actually use. If your fields are loosely defined or buried in opaque configuration, the agent guesses, and guessing produces invalid drafts and broken validation. A typed schema means it knows exactly what a "post" is before it writes one.

It's a quieter criterion than the API, but it compounds: the cleaner the shape, the fewer rounds of correction.

Slim Minima is TypeScript end to end, with Zod schemas validating block props and content inputs. Each block declares its fields and schema in the same file, so the valid shape is explicit, and pages and posts share a predictable model the agent learns once. Drizzle runs the database with parameterized queries, so the agent isn't hand-assembling SQL.

5. You own the database and the code

This one isn't about today's convenience. It's about what happens when you want to leave, or when the vendor changes the rules. A hosted CMS that keeps your content in its own system and bills you per request is fine until it isn't: the day you want to move, your content is trapped in their export format and your customizations don't come with you.

An agent can't fix lock-in; it can only work within whatever access the vendor allows. Ownership means the database and the code are yours, so if the project vanished tomorrow you'd still have a running site and the source to maintain it.

Slim Minima is MIT licensed, the code lives in your own GitHub repo, and the content sits in your own Neon Postgres database, with no per-request billing and no proprietary content store. If I disappeared, you'd keep the code and the data and could self-maintain or fork it. That's the honest answer to "what if this young project stalls," and I wrote about the reasoning in why I built Slim Minima.

Headless CMS products often score well on ownership too, and some self-host; what many lack is a built-in visual editor, so your non-technical client still can't edit without you.

6. It's cheap to run while you iterate

Building with agents means building fast and throwing a lot away. If every iteration costs money or a per-seat fee, you'll iterate less, which is the opposite of what agents are good for. So the last criterion is mundane but real: a stack that's free or near-free at low traffic lets you experiment without watching a meter, and you only pay when there's real traffic, which is exactly when paying is fine.

Slim Minima runs on free tiers of Vercel, Neon, and Cloudinary, which conservatively covers roughly 10,000 to 30,000 monthly visitors before you pay anyone. The only mandatory cost is the domain, a couple of dollars a year. When you outgrow the free tiers you move to paid plans of the same services without changing the code. I broke down the limits in how far the free stack stretches.

Where this approach falls short

It's built for content and marketing sites, not real-time apps. There's no websocket layer, so write-heavy or live-collaborative projects aren't a fit.
"No plugins" means you or your agent write the code for anything custom. That's more upfront effort than installing a mature plugin, and an older CMS has a larger plugin ecosystem.
Slim Minima specifically is young (v0.1.3) and largely a solo and community open-source project. The MIT license is the safety net, not a big company behind it.

Most of these aren't unique to one product. Any code-first, agent-friendly CMS trades plugin breadth for control. Decide which side your project sits on.

Who this checklist is for

Build with this approach if you work through Claude Code, Codex, or Cursor and want the agent to touch content directly; if you build sites for clients and want the handoff to actually end at ship; or if you're cost-sensitive and want to own your stack. (On how the data stays safe, see is Slim Minima secure.)

Skip it if you need a real-time application, a no-code drag-and-drop builder with zero source code, or a site assembled entirely from off-the-shelf plugins.

Frequently asked questions

What should I look for in a CMS when building with AI agents? Six things: a read-and-write API plus an MCP server so the agent can reach content, code-based extension instead of a plugin marketplace, machine-readable output like llms.txt and per-page markdown, a clean typed schema, full ownership of the database and code, and a low cost to run while you iterate. Miss three or more and the agent fights the tool.

What is an MCP server and why does a CMS need one? MCP, the Model Context Protocol, is an open standard for exposing tools to AI clients. A CMS with one gives your agent named tools like "create post" or "add image" that it calls directly inside Claude, ChatGPT, Perplexity, Grok, or Cursor, without you writing glue code. It's the difference between an agent that can edit your site and one that can only describe how it would.

Is WordPress a good CMS for AI agents? WordPress has a REST API and a large plugin ecosystem, which are real strengths. The friction is that its model centers on plugins and a click-based admin agents can't operate well, with no native MCP server. It can work, but it wasn't designed for an agent to extend by writing one file.

What are the limits of a code-first CMS like this? You extend it by writing code, so custom features take more upfront work and the off-the-shelf plugin breadth of an older CMS is larger. It's built for content and marketing sites, not real-time or write-heavy apps. A young open-source project also carries bus-factor risk, which an MIT license and a database you own are meant to offset.

My verdict

Run any CMS through these six checks before you commit, and weight the first two hardest: a write API with an MCP server, and code-based extension. Those two decide whether the agent does the work or just narrates it.

For a custom marketing or content site built by an agent, where you want to own the stack and keep costs near zero, Slim Minima fits well, with the honest caveats that it's young and you write code for anything custom. If you need real-time features, a no-code builder, or a deep plugin catalog, choose something else.

What to look for in a CMS when building with AI agents