Your content should ship without a marketing hire.

Every small company has a content backlog that reads like a list of things it already knows. The changelog post answering the question three customers asked last week. The comparison page a prospect went looking for and could not find. The onboarding guide that currently exists as a Loom link and four Slack messages. The knowledge is in the building. The two hours are not.

Can you run a company blog without a marketing hire?

Yes, if the publishing system is something software can operate end to end. A marketing hire is mostly six jobs: choosing the topic, researching it, writing it, making a cover image, publishing it, and finding out afterwards whether it did anything. Five of those are procedure. One is judgment. An agent can hold the five and file the sixth for you.

The reason this did not work three years ago is not that the models could not write. It is that the CMS on the other end was a web form. A person had to be in a browser session, clicking into a rich-text field, to get a paragraph from a draft into a database. Every piece of automation stopped at that window and posted a Slack message asking someone to paste something.

What changed is that content management grew a proper tool surface. Munin's CMS is a set of MCP tools — cms_create_entry, cms_update_entry, cms_publish_entry, cms_schedule_publish, cms_get_preview_link — sitting on the same Postgres as the CRM, the inbox, and the knowledge base. There is no window in the middle. The same is true at Contentful and Sanity now, and I will come back to what each of the three is actually for.

What actually has to happen before one article ships?

Six steps, and only one of them is writing. A scheduled pass picks a topic against a rotation, checks the existing library so it does not repeat an angle, verifies every outside claim by web search, drafts into the collection's typed block schema, generates a cover image, and files the whole thing as a draft. Nothing publishes. You read a queue.

The rotation is the part people underestimate. Left alone, any writer — human or otherwise — drifts toward whatever they find most interesting, which for a founder-led company means essays about architecture and no page that a buyer would ever search for. A written rotation rule fixes that better than good intentions do, because it is checked against the last five entries every single run rather than remembered.

• 01Read the library first. cms_list_entries on the collection, with fields narrowed to titles, categories, and dates. The pass counts what the last five entries were before it is allowed to choose a sixth.
• 02Verify everything external. Competitor pricing, licences, dates, quotes — each one checked against the vendor's own page and labelled indicative. An unverified number that flatters you is the one a technical reader catches.
• 03Draft into blocks, not into a text field. The body is an ordered array of typed blocks, so the schema itself rules out a two-thousand-word slab of prose.
• 04Make the cover. media_generate_cms_asset returns an assetId stored as a CMS asset, which cms_update_entry attaches to cover_image.
• 05File it as a draft. cms_create_entry with status: "draft". The delivery API only ever serves published entries, so a draft is invisible to the public site by construction, not by convention.
• 06Stop. Publishing is a separate tool and a separate decision. The queue is where your judgment enters.

{
  "name": "cms_create_entry",
  "arguments": {
    "collection": "journal-blocks",
    "slug": "open-source-intercom-alternatives",
    "status": "draft",
    "data": {
      "title": "Open-Source Intercom Alternatives in 2026",
      "dek": "…",
      "category": "Essay",
      "author": "Kjell Rune Monsø",
      "body": [
        { "type": "lead",     "props": { "text": "…" } },
        { "type": "prose",    "props": { "markdown": "## Is there an open-source…" } },
        { "type": "takeaways", "props": { "items": ["…"] } }
      ]
    }
  }
}

Why does the content model matter more than the prompt?

Because a prompt is advice and a schema is a wall. Tell a model to vary its structure and it will, for a while, and then it will produce eleven paragraphs in a row. Give it a body field that only accepts an ordered array of fifteen named block types — lead, prose, pull_quote, callout, editorial_list, definitions, code_block, stats, takeaways, divider, footnotes, and the rest — and eleven paragraphs in a row is a validation error rather than a bad day.

The same trick carries the house style. Each block type's description in the schema is enforcement documentation: the callout type says under about ninety words, one idea, and that a passage conceding something must not end on the concession. The definitions type says use editorial_list instead when the key is a token rather than a phrase. That guidance travels with the field, so it reaches every author on every run — which is a much better place for a style guide than a wiki page nobody opens. I wrote about the trade-offs of modelling a CMS this way in your content model is a prompt.

It is worth being precise about what this does and does not buy you. A schema can enforce shape, required fields, and the absence of a wall of text. It cannot make an argument good. The review queue is still doing real work.

Who makes the cover image?

The same pass, through the same interface. media_generate_cms_asset takes a prompt, alt text, and a filename, generates the image, stores it as a CMS asset, and hands back an assetId and a URL. Munin derives four webp widths — 320, 640, 1024, and 1536 — so the front end has a responsive set without a build step. cms_update_entry attaches the asset to cover_image.

The interesting part is not generation, which everyone has. It is that the prompt is stored on the asset. cms_list_assets returns the recorded prompt for every cover, which means the next run can read what the last four looked like and deliberately do something else — different setting, different scale, different camera angle, hands or no hands in frame. Without that memory, an image model will produce the same photograph of an object on a wooden desk beside a window until the whole index looks like one afternoon's shoot. The house look is a written rule; the variation is enforced by making previous decisions readable.

How do you find out whether the article did anything?

Because the CMS and the CRM are one schema, you ask in one query rather than reconciling two exports. Every CMS delivery response ships a _tracking block keyed by the stable entry id, so recording a view needs no separate key and no second vendor. Views land as analytics events against the same contact record the deal sits on.

That is the whole reason to keep content on the customer platform rather than beside it. The question a small team actually has is not how many sessions the blog got — it is which two articles the people who signed read first. analytics_get_contact_journey and analytics_list_top_subjects answer that against one table, which I walked through in which blog post closed the deal.

The loop closes in the other direction too. A published entry can be mirrored into the knowledge base so the support agent can cite it, using the same publish-and-distribute pass that also drops an announcement into a conversation channel. That is the mirror image of the knowledge base filling itself from resolved tickets — answers become articles, and articles become answers.

How is this different from Contentful or Sanity?

All three can now be driven by an agent, and that is a genuinely recent development worth crediting properly rather than waving at. Contentful runs a hosted remote MCP server at mcp.contentful.com/mcp, generally available, plus an open-source local server, with a dashboard where space admins choose which tools an AI client may see. Sanity runs a remote server at mcp.sanity.io with OAuth, schema-aware document patching, and GROQ queries; its older local @sanity/mcp-server package is deprecated in favour of it.

So the question is no longer whether software can write into your CMS. It is what else the record is attached to, and what the meter counts.

• ContentfulThe enterprise content platform, and the broadest editorial toolset in this comparison — Studio's visual canvas, Personalization, Launch, Tasks, a large app marketplace. Free is $0 with 10 users, 100K API calls a month, 50 GB of CDN bandwidth, and one Starter Space capped at 25 content types and 10,000 records. Lite is $300/month with 20 users and 1M API calls. Enterprise is quoted, and it is the tier where AI Actions and EU data residency appear.
• SanityThe developer's structured-content choice, with a customisable Studio you compile yourself and GROQ, a powerful query language for structured content. Free covers 20 seats; Growth is $15 per seat per month up to 50 seats and adds private datasets, comments, scheduled drafts, and AI Assist; Enterprise is quoted.
• Munin CMSOne module of six on a single Postgres, so an entry, a contact, a conversation, and a knowledge-base document share one database and one row-level security boundary. Typed blocks with per-type authoring rules, signed preview links, versioning with ifVersion, generated cover assets, and per-entry view tracking that lands on the contact record. MIT, self-hostable with docker compose up, EU-hosted on Munin Cloud. Free is €0/month with 5,000 MCP calls, 250 contacts, and 100 MB; Premium is €99/month flat per org with metered overage, coming soon.

Who should pick this?

Pick Munin's CMS when the blocker is that nothing gets written at all, and when the article is eventually going to be read by someone who is already a row in your CRM.

The draft knows things. The support threads, the deal stage, the knowledge base, and the published library are one schema with one contacts table behind all six modules. A pass writing a comparison page can search the knowledge base for what is actually true about the product instead of inventing a feature that sounds plausible.

It runs wherever you already work. Claude, Claude Code, Cursor, ChatGPT, the OpenAI Agents SDK, or a runner you wrote yourself — one MCP endpoint, the same tools, the same audit trail. There is no separate content app to log into, which matters mostly because the thing you were going to skip is logging in.

The procedures are text you can edit. The publishing playbooks are bundled markdown skills, not a workflow builder. When the rotation rule is wrong for your business, you change a sentence and the next run behaves differently.

And it fits a company of one. Cloud Free is €0 a month, self-hosting is docker compose up under MIT with no enterprise/ directory holding the useful half, and the model cost is whatever your provider charges rather than a per-article fee to us. The same arithmetic I ran for a company with one chair and six departments.

Frequently asked questions

Can an AI agent publish blog posts automatically? It can draft and file them automatically. In Munin, cms_create_entry defaults to status: "draft" and the public delivery API returns only published entries, so an unreviewed article is invisible to your site by construction. Going live is a separate call — cms_publish_entry or cms_schedule_publish — which is where a person decides.

What is the best CMS for an AI agent to write into? One with a typed content model and a real tool surface, rather than a rich-text field behind a login. Contentful, Sanity, and Munin all run MCP servers as of 2026. Contentful and Sanity are content platforms; Munin's CMS sits on the same Postgres as its CRM, inbox, knowledge base, outreach, and analytics, so a published entry and the contact who read it are one join apart.

Do I need a developer to set this up? To render the site, yes — you need a front end that reads the delivery API, and that API is anonymous with no CORS, so the fetch runs server-side. To operate it afterwards, no. Creating collections, authoring entries, attaching assets, and publishing are all MCP tool calls you make by asking for them in plain language.

How much does it cost to run a blog this way? Munin Cloud Free is €0 a month with 5,000 MCP calls, 250 contacts, and 100 MB of storage; Premium is €99 a month flat per org with metered overage, coming soon. Self-hosting under MIT costs whatever your server costs. On top of that you pay your model provider directly for the drafting and the image generation. For comparison, Contentful's Lite plan is $300 a month and Sanity's Growth plan is $15 per seat per month. All figures are indicative and read from each vendor's own pricing page on 10 August 2026.

Will AI-written articles rank? Ranking is the wrong target to optimise for on its own now. A growing share of buyers ask an assistant rather than a search box, so the piece has to be quotable: question-style headings that mirror how someone would prompt, a self-contained forty-to-seventy-five-word answer under each one, named entities, real numbers, and a takeaways block that stands alone. Structure for retrieval and ranking mostly follows.

Can I keep my existing CMS and just add the agent? Yes, and for a content-heavy site with an established editorial team that is often the better answer — Contentful and Sanity both expose hosted MCP servers you can point a client at today. Munin is the choice when you would rather the article, the customer, and the conversation lived in the same database.

Create one collection, ask your assistant to file a draft into it, and read what turns up in the queue — start on Munin Cloud, or read the docs for how to shape the schema first.

The hire was never what was missing. The hour was.