Strapi MCP vs Contentful Agent Skills vs Cosmic MCP: A Head-to-Head Comparison

Managing content by prompt instead of by dashboard changes what counts as an AI content management system (CMS). Strapi provides a built-in Model Context Protocol (MCP) server, Contentful offers a remote MCP server and Skills, and Cosmic supplies a hosted MCP endpoint.

Strapi MCP tools let an agent in Cursor or Claude manage content through your schema, while Contentful exposes content operations through its remote MCP server and Cosmic provides content and generation tools through its hosted endpoint. They diverge sharply on hosting and permissions. Their approaches to CMS-native generation also differ.

In brief

• Hosting: Strapi runs on infrastructure you control, Contentful offers remote and local servers, and Cosmic provides a hosted endpoint with an optional self-hosted package.
• Tool design: Strapi generates tools from your schema, Cosmic provides a fixed inventory of 18 tools, and Contentful documents its MCP capabilities without publishing a full tool count.
• Permissions: Strapi applies four-level Admin token RBAC, Contentful defaults to governed read-only access, and Cosmic uses per-bucket read and write keys.
• Native generation: Cosmic includes text, image, video, and audio generation in MCP, while Strapi separates MCP operations from Strapi AI and Contentful Skills focuses on coding-agent workflows.

What Makes a CMS an AI Content Management System?

An AI content management system exposes its content operations to AI agents through a machine-readable protocol. An agent can create or update an entry and publish a draft without using the Admin Panel. The MCP standard makes this practical.

Three MCP primitives are resources, tools, and prompts. MCP tool behavior is designed to be model-controlled. CMS tools can therefore be discovered and invoked automatically based on context and user prompts.

So when you evaluate an AI content management system, you're evaluating three things: which tools the server exposes, how permissions constrain what an agent can do, and whether content generation happens inside the CMS or inside the connected AI client.

Each AI content management system built on a headless CMS answers those questions differently. Strapi's MCP server exposes content-type tools generated from your content schema, and MCP-compatible clients connect to the /mcp endpoint with a Bearer token. Cosmic ships a fixed inventory of 18 tools. Contentful provides remote and local MCP options.

Strapi MCP, Contentful Skills, and Cosmic MCP at a Glance

Pick Strapi when you want an open-source stack you fully own with field-, locale-, and document-level permission controls. Cosmic suits teams that want a hosted setup with generation built into the protocol layer. Contentful fits teams already invested there that want a managed remote MCP server. Contentful also provides Skills for coding agents that cover SDK setup, Draft Mode, content migrations, and personalization.

Sources: Strapi MCP server docs, Contentful MCP server docs, and Cosmic MCP server docs.

Architecture and Hosting Model

Where the MCP server runs determines who controls your content pipeline and where your data lives. Strapi's MCP server is built into Strapi and exposed as a route on Strapi's existing HTTP server, so agent traffic is directed to the /mcp endpoint on your Strapi server rather than a separate sidecar process.

Contentful routes agent traffic through its managed remote MCP server by default, while Cosmic provides a managed hosted endpoint and an optional self-hosted stdio package. That trades some control for convenience.

Strapi's server also uses a stateless architecture:

• Each POST request to /mcp creates "a fresh, ephemeral MCP server instance scoped to the authenticated token's permissions."
• No session state persists between requests, so revoking a token or changing its permissions takes effect on the very next request.

That immediacy matters when an AI agent has write access to production content. There is no lingering session to revoke separately after you pull a credential.

Strapi: Open-Source and Self-Owned

The MCP server is a built-in Strapi feature. It is off by default: update the server configuration to turn it on, and it runs wherever your Strapi instance runs. Since the Community Edition is open source, you can deploy it on AWS, Azure, GCP, a VPS, Docker, Kubernetes, or on-prem, with PostgreSQL, MySQL, or MariaDB in production. Data residency is whatever you make it.

Contentful and Cosmic: Managed SaaS

Contentful and Cosmic are both managed platforms, but they package their MCP servers differently. Contentful's remote MCP server is a cloud-hosted, OAuth-secured endpoint with governed, read-only access and space-level tool controls as its default configuration. Contentful also provides a local server option.

Cosmic's hosted endpoint requires only client configuration. It lives at https://mcp.cosmicjs.com/v1/buckets/your-bucket-slug and uses bucket credentials in the authorization header.

Setup and Connecting to an AI Client

Cosmic requires fewer setup steps in the configurations documented here. Strapi asks for a config change plus a token, while Contentful's setup depends on whether you use the remote or local server.

For Strapi, turning on the server requires one config change in config/server.ts. The MCP setting sits alongside the server's host, port, and app settings.

Restart Strapi and the endpoint is live at http://localhost:1337/mcp. Next, create an Admin API token under Settings → Admin tokens. Strapi rejects Content API tokens with a 401; only Admin API tokens work. The token's permissions directly control which MCP tools the AI client sees. From there, AI client configuration varies by client. Cursor uses streamable-http in .cursor/mcp.json:

// .cursor/mcp.json
{
  "mcpServers": {
    "strapi-mcp": {
      "type": "streamable-http",
      "url": "http://localhost:1337/mcp",
      "headers": {
        "Authorization": "Bearer YOUR_ADMIN_TOKEN"
      }
    }
  }
}

Claude Code connects over http:

claude mcp add strapi-mcp --transport http http://localhost:1337/mcp -H "Authorization: Bearer YOUR_ADMIN_TOKEN"

Run /mcp inside Claude Code to confirm the connection. Claude Desktop can be the awkward one: although Claude's connector docs support Streamable HTTP, local Claude Desktop MCP setups may still require bridging HTTP/Streamable HTTP servers through npx mcp-remote.

Claude Desktop launches MCP commands with a minimal environment rather than your shell's, so a bare npx is often not on its PATH, especially with a Node version manager (nvm, fnm, Volta). You may need to point command at the absolute path to npx and add an env.PATH entry. It is a one-time fix.

Cosmic's hosted setup is credentials-only. For Cursor, add the following to .cursor/mcp.json; Claude Desktop uses the same cosmic server object in its MCP configuration:

// .cursor/mcp.json
{
  "mcpServers": {
    "cosmic": {
      "url": "https://mcp.cosmicjs.com/v1/buckets/your-bucket-slug",
      "headers": {
        "Authorization": "Bearer your-read-key:your-write-key"
      }
    }
  }
}

No server to run, no config file changes on the CMS side. Contentful provides remote and local MCP setup options, with the remote server authenticating through OAuth and requiring no local server setup.

Available Tools and Content Operations

Strapi generates tools from the schema, Cosmic publishes a fixed inventory, and Contentful describes capabilities without publishing a full count.

Strapi generates its available tools from your Content-Types. Each Collection Type gets up to eight tools: list, get, create, update, and delete, plus publish, unpublish, and discard_draft when Draft and Publish is active on that type. Single Types get up to six, with no list tool and with create and update merged into a single write tool. A log utility tool is available in development mode only.

Because the toolset mirrors your schema, an agent connecting to a travel blog sees different tools than one connecting to an e-commerce catalog. Strapi also exposes a plugin API, strapi.ai.mcp.registerTool, for registering custom tools when the built-ins don't cover custom controllers, aggregations, or multi-step flows.

Cosmic's inventory is fixed at 18 tools across four categories: five object tools (list_objects, get_object, create_object, update_object, delete_object), four media tools including upload_media, five Object Type schema tools, and four AI generation tools.

Contentful's documented MCP capabilities cover managing entries and assets, exploring and updating content types, environment management, migrations, bulk content updates, and SEO checks.

Asset upload runs as a two-phase flow: call create_upload_session to receive an uploadHandle and uploadUrl, PUT the binary, then call upload_asset. Contentful's developer docs don't enumerate the full tool list, so there's no confirmed tool count to compare against Strapi's or Cosmic's.

Where Strapi Draws Its Boundaries

Strapi documents four notable MCP limitations. Media upload isn't supported through MCP: "Media fields accept existing media asset references but the MCP server cannot upload new files," so you upload through the Media Library or upload API first, then reference assets in tool calls.

Dynamic Zone fields "are passed as untyped arrays in tool schemas," with no description of each component's internal structure, which means agents work partially blind inside Dynamic Zones. The list and get tools don't support nested population for relations. And custom fields registered via plugins can fall back to an unknown type if the registry isn't populated when tools are registered.

There's also no bulk operation support in the built-in server. Updating the SEO description on every blog post can require an agent to make 200 individual calls, which is rough on tokens and painfully slow. No resolution is documented. If bulk agent-driven edits are central to your workflow, factor this in.

Native AI Content Generation

Cosmic embeds generation directly into the MCP server as four first-class tools:

• cosmic_ai_generate_text
• cosmic_ai_generate_image
• cosmic_ai_generate_video
• cosmic_ai_generate_audio

cosmic_ai_generate_video uses Google Veo and is asynchronous, typically taking 30–90 seconds on Fast or 60–180 seconds on Standard, while audio generation offers 13 voices through OpenAI TTS. An agent can generate an image and store it in the bucket's Media Library in a single tool call. Generation consumes tokens, media generation costs more than text, and generated assets count toward your storage quota.

Contentful Skills supports AI coding agents working on SDK setup, Draft Mode, content migrations, and personalization. Contentful Skills helps coding agents build against Contentful.

Strapi deliberately splits the two concerns. Connected AI clients such as Claude or Cursor generate content and invoke MCP tools to write it into Strapi. Generation inside the Admin Panel comes from Strapi AI, a separate feature set. The practical upside of Strapi's split: your generation quality is whatever model you connect, and you can swap clients without touching the CMS.

Permissions and Security Model

Strapi applies controls at more levels than the other models described here. Its permission boundaries operate at multiple levels, all derived from the Admin token, which inherits the owner's admin roles through Strapi's RBAC system and is "automatically re-clamped when the owner's roles change or revoked the moment the owner is deactivated."

1. Tool visibility. If the token doesn't grant delete on Article, the AI client never sees a delete tool for articles.
2. Field filtering. Input and output schemas narrow to permitted fields; a token that can read Article but not its body field never sees body content.
3. Locale filtering. With Internationalization active, the locale parameter narrows per action, so a token might read en and fr but only create in en.
4. Runtime enforcement. Each handler calls Strapi's permission checker on the specific document, so condition-based rules like "only update entries you own" hold even after schema-level narrowing.

Together, these layers keep both tool discovery and each runtime operation within the Admin token's effective permissions.

Contentful's remote MCP server provides governed, configurable access with space- and environment-level tool controls. Admins can set selected tool categories to read-only or read/write.

Cosmic uses per-bucket read and write keys: a Bearer READ_KEY header grants read-only access, while Bearer READ_KEY:WRITE_KEY grants read and write access. A read-only key prevents write and AI generation operations, while read tools continue working. It's a simple, auditable model, but binary. You get read or read-write per bucket, with none of the field-level or per-document control Strapi offers.

Pricing and Licensing

Strapi's open-source, self-hosted model lets you run the CMS on your own infrastructure. Paid tiers on Strapi's self-hosted pricing add features around that core. If you'd rather not run servers, Strapi Cloud provides managed hosting with tiered pricing based on usage and features.

Cosmic and Contentful use managed-service pricing rather than Strapi's self-hosted open-source model. Plan prices, quotas, add-ons, and feature gates change independently of the MCP implementations. Compare the commercial terms directly before making a long-term cost decision.

Which AI Content Management System Should You Choose?

Each platform suits a different type of team.

Choose Strapi if control and ownership drive your decision. You get an open-source CMS, a built-in MCP server, four-level permission enforcement down to individual fields and locales, and a stateless design where credential changes take effect immediately. You also run the infrastructure. Media upload happens outside MCP, and bulk agent operations aren't there yet. For full-stack developers already self-hosting Strapi, turning on the MCP server adds little infrastructure work beyond the existing instance.

Choose Cosmic if you want fewer setup steps for a working agent. A hosted URL plus bucket credentials in a header gets Cursor or Claude Desktop talking to your content. Cosmic alone provides native generation of text, images, video, and audio through MCP tools among the three implementations described here. The coarser bucket-level key model is the main thing to weigh.

Choose Contentful if you're already a Contentful shop. The remote MCP server's read-only defaults suit cautious rollouts, and Contentful also provides a local server option. Contentful Skills covers SDK setup, Draft Mode, migrations, and personalization for coding agents.

Match the MCP Server to Your Workflow

Choose an AI content management system based on server ownership and the operations your agents need. Then decide whether generation belongs in the CMS or the connected client. Cosmic bundles content operations and generation into a hosted endpoint, Contentful layers MCP onto its managed platform, and Strapi gives you a schema-aware, permission-enforced MCP server in software you can self-host.

Test one against a real project. If you're using a Strapi version that includes MCP, turn it on with a config change and an Admin token. Then add the client config. The MCP server documentation walks through each client, and strapi.io has the details on what ships in each edition. Point Cursor or Claude at your own Content-Types and see how an agent handles your actual schema. That test will tell you more than any comparison table.