The editor is the last mile

Every CMS vendor now has an agentic story. MCP (Model Context Protocol) servers, content APIs, agent tooling. Vendors are shipping integration guides and racing to connect AI to their content repositories. The plumbing is getting built, and it matters.

I think the conversation is pointing at the wrong problem.

The infrastructure trap

The current framing treats "agentic CMS" as a connectivity challenge. How do agents access the content repository? How do they understand the schema? How do they push changes back?

These are important engineering problems, and they're being solved quickly. MCP is becoming the standard interop layer. Structured, API-first content gives agents something to reason about.

The part that isn't being solved is what happens after the agent gets in. Connecting an agent to your CMS is a prerequisite. It's not the product. The interesting question isn't how agents access content. It's how they produce anything worth publishing.

And that question leads somewhere the infrastructure conversation doesn't go: back to the editor.

The editor is the last mile

Agents without editorial direction produce volume, not value. They can generate, translate, tag, optimize. They can do it fast and across thousands of pages. That judgment, the decision about what to produce, for whom, and in what voice, is what makes the output meaningful.

The editor's role is shifting. Not disappearing, but transforming. From writer to director. From producing every word to shaping what agents produce and deciding what gets published.

This is a more demanding role, not a lesser one. Directing well requires a clearer understanding of intent than writing does.

I've experienced this firsthand. My own publishing workflow is agent-driven from research through scheduling. Agents brainstorm, outline, draft, review against a voice guide, prepare social posts, and publish. My role at each stage is the same: decide whether the output is worth moving forward. I write less than I used to. I think harder about what I want to say and why it matters.

The CMS interface hasn't caught up with this shift.

Two philosophies are emerging. One optimizes for automation: agents that publish while you sleep, generate pages on a schedule, handle SEO without asking. It's a compelling pitch.

It also sidesteps a hard question: who reviews what published while you slept? Where is the trust boundary between routine and high-stakes?

The other philosophy optimizes for the collaboration surface. Agent-proposed changes appear in review panels. Nothing touches live content without human sign-off. The editor approves, rejects, or modifies.

I think the second is closer to right.

This pattern has played out before. When PageMaker and QuarkXPress arrived in the 1980s, desktop publishing eliminated mechanical production as a barrier. Anyone could lay out a page.

The result wasn't the end of graphic design. It was the opposite. Design judgment became more visible and more valued once the mechanical work no longer obscured it.

The same thing is happening now. When agents handle the production layer of content, the editorial layer becomes the differentiator. The craft shifts from writing to directing. And the CMS needs to be designed for that shift.

What this means

The CMS that wins the agentic era isn't the one with the most agent features. It's the one that makes the editor the best possible place to direct agent work.

Humans and agents need to work in the same space, not in linear handoffs where an agent produces and a human reviews. The governance layer needs to be built in, not bolted on: role-based permissions, review workflows, quality guardrails that agents respect the same way humans do. And the editing interface needs to be designed for directing, not only writing.

The editing interface becomes the product. Not the API layer underneath it.

The harder problem is on the other side of the pipe. It's the place where human intent shapes agent output. Where editorial judgment gets encoded not as a manual review step, but as the architecture of the tool itself.

For CMS builders, that's where the real craft is moving. The editor isn't being removed from the process. The editor is the process. That's worth designing for.