MCP lets AI agents edit content through Draftbase directly
The Model Context Protocol gives an agent a fixed set of tools to call. No UI to click through. No API to guess at. Draftbase ships an MCP server. An agent can create, publish, and roll back content the same way a person does.
What is the Model Context Protocol
MCP is an open standard for connecting AI agents to apps. It started at Anthropic. It defines how an agent finds a set of tools, calls them with typed input, and reads back a clear result.
Without MCP, an agent that needs to edit content has two bad options. It can drive a browser and click through a UI built for humans. Or it can call a REST API it was never given docs for. Guessing at field names and rules. Both options break the moment the UI changes or a field gets renamed. Neither one is built on a real contract.
MCP replaces both with a defined tool contract. The agent calls create_entry with the fields the schema expects. Not a scraped form. The call either succeeds against real checks, or fails with a clear error. That error is structured too, so the agent can correct course instead of guessing again.
The protocol splits work into two roles. A server, like Draftbase's, exposes a fixed list of tools with typed input and output. A client, like Claude Code or Claude Desktop, finds those tools. It lets the agent decide which ones to call, and when. Neither side needs custom glue code for the other. That's what makes MCP a standard, not just another SDK.
How Draftbase's MCP server works
Tools mirror the REST API 1:1
Template, entry, and media tools map to the same routes a human editor's requests hit. No separate agent-only path. No drift between what an agent can do and what a person can do.
One call per operation, by design
create_template takes every field up front, not one at a time. Token cost is a hard limit on every tool, not an afterthought. An agent that needs five calls to do one thing burns context and money on every edit.
Same schema, same validation
An agent's update_entry call is checked against the exact template schema a human editor is bound by. There is no way around it.
Revisions and rollback as tools
list_entry_revisions and rollback_entry are first-class tools. An agent's mistake is a revert, not a crisis.
This is why the server exposes the same content, revision, and status tools a human uses in the dashboard. Not a narrower or wider set built just for agents. Template, entry, and media tools cover the same three areas the REST API covers. An agent that can list templates can also read, create, update, and delete entries, and manage media. No separate setup per area.
The content itself helps here too. An entry an agent reads or writes is MDX. Plain markdown plus components. Not a deep JSON blob with layers of CMS-internal data to sort through. Less structure to work through means less context spent figuring out what a field holds. It also means a smaller footprint the agent can hold across a whole editing session. No need to re-fetch it. Tokens are scarce for an agent. Draftbase would rather it spend them on writing than on decoding your content.
Login follows the same secure flow a human's login uses. Scoped to one org through the token's claims. An agent never gets more access than the person who connected it.
In practice, a content workflow looks like this. An agent calls list_templates to see what schemas exist. It calls create_entry against the right one with a full set of fields. Then it calls set_entry_status to move it from draft to published once it looks right. Three tool calls. No scraped forms, no guesswork. See the technical setup docs for the full tool list and connection details.
MCP-connected editing vs. traditional API integration vs. no AI access
Teams that want AI content editing today usually pick one of three paths. They skip AI and keep editing manual. Or they build a custom integration against the CMS's REST API, writing tool-calling code by hand. Or they connect an MCP client to a server that already ships the tools.
| Approach | No AI access | Custom AI integration | Draftbase MCP server |
|---|---|---|---|
| Setup cost | None, but no automation | Weeks of custom tool-calling code | Connect an MCP client, tools ship built-in |
| Schema awareness | N/A | Hardcoded per integration, drifts from schema | Always matches the live template schema |
| Safety | N/A, human is the only actor | Depends on how carefully you built it | Same validation plus draft/publish and revision rollback as a human edit |
| Token/request efficiency | N/A | Depends on the integration author | One call per operation by design |
The middle column is where most custom integrations end up over time. They work at launch. Then they quietly drift from the schema as fields get added or renamed. Nothing forces the code to stay in sync with the content model.
Common pitfalls with agent-driven content editing
Teams that connect an agent for the first time usually make one of two mistakes. First, they treat every tool call as equally safe. They let an agent run set_entry_status straight to published with no review step. The fix is a workflow rule, not a missing feature. Second, they build a custom integration before checking whether an MCP server already covers what they need. That just duplicates code an off-the-shelf server already ships.
Here's the angle most AI-CMS pitches skip. The safety story isn't about limiting what an agent can call. It's about what happens after a bad call. Draftbase's rollback_entry tool sits next to update_entry. So an agent's wrong edit costs one revert, not a recovery job. That's a trait of the content model, not the AI layer. Revisions exist for human edits too.
Why MCP adoption is moving fast
MCP SDK downloads grew from about 100,000 in November 2024 to 97 million a month by March 2026. That's a 970x jump in under a year and a half. (Source) As of December 2025, MCP had more than 10,000 active public servers. (Source)
The protocol also changed hands. In December 2025, Anthropic gave MCP to the new Agentic AI Foundation, under the Linux Foundation. OpenAI and Block joined as co-founders. (Source) A protocol backed by rival AI labs is a safer bet for a CMS to build on than one vendor's own tool format.
For a CMS, this shift changes what "AI content editing" means. A chatbot bolted onto a dashboard can draft text. But it still needs a human to copy that text into the right fields. An MCP-connected agent calls the same field-level tools a human uses. The draft lands right in the template, checks already applied.
For an editorial team, the real effect is fewer handoffs. A writer can ask an agent to draft an entry. An editor can ask it to check every required field before a launch. Neither step needs exporting content to a separate tool and back. The tools work on live data in the same org the humans use. Not a staging copy to fix later.
Give your agent MCP-connected AI content editing
Connect an MCP client and start creating, publishing, and rolling back entries through the same schema your team already uses. No custom integration code, no separate write path to maintain.
Frequently asked questions
What is MCP?
The Model Context Protocol is an open standard that lets AI agents call structured tools against an application. Instead of scraping a UI or guessing at an API, an agent gets a defined set of typed operations to call, each with a fixed set of arguments and a predictable response shape.
Is MCP specific to Draftbase?
No. MCP is an open standard, not a Draftbase feature. As of December 2025 it's governed by the Agentic AI Foundation under the Linux Foundation. Draftbase implements a server for it — the protocol itself works with any compliant application, and the same MCP client you use with Draftbase can also connect to other MCP servers.
Can an AI agent publish content without human review?
Technically, yes — the MCP tools mirror the same status-change operations a human editor has, including publish. But every entry keeps its revision history, and rollback is also exposed as a tool, so an agent's edit is never a one-way door. If a team wants a human gate before publish, that's a workflow decision for how the agent is instructed, not a limitation of the tools themselves.
Does the MCP server bypass template validation?
No. An agent calling create_entry or update_entry hits the same field validation a human editor hits, including required fields, min/max constraints, and pattern rules defined on the template. There is no separate write path for AI tools, so a schema change protects both actors equally.
Which MCP clients work with Draftbase?
Any client that supports the OAuth 2.1 + PKCE discovery flow, including Claude Code and Claude Desktop. See the technical setup docs for connection details and the full tool reference, including separate staging and production endpoints.