How an agent reads this

Most of the organisations publishing AI governance guidance in 2026 cannot be read by an AI agent.

Not because they lack ambition. Because they have not thought about it. Their guidance lives in PDFs. Their articles are HTML that agents can scrape if they are persistent enough. Their policy frameworks are documents designed for human eyes, structured for human reading patterns, retrievable only through human search.

This is the third article in a series on AI governance in mission-first organisations. The first two argued that governance belongs in the infrastructure – in the gateway, the control plane, the wiring – not in the policy document. This one applies that principle to the publication itself.

If I am going to write about agent-first architecture, The Interconnect should reflect it. A blog that can only be read by humans clicking links is not agent-first. So I built an MCP server for it.

What the governance wrapper means for publishing

The previous two articles described the governance wrapper: the control plane that sits between AI systems and everything they access, enforcing authentication, rate limits, input screening, access control and logging at the infrastructure layer rather than in the agent code itself.

Publishing is not exempt from that logic. When an AI agent tries to read an article -- to retrieve content, build context, cite a source -- it encounters the same governance gap that charities encounter with their operational AI tools. The content is accessible, technically, but ungoverned. No structured interface. No attribution metadata. No control over what the agent retrieves or how it represents what it found.

The MCP server for this publication is a small version of the same answer.

What I built

MCP -- Model Context Protocol -- is an emerging standard that lets AI agents query structured data sources directly, rather than scraping web pages or guessing at content structure. It gives the agent a clean interface: defined tools, structured responses, proper attribution context attached to every result.

The Interconnect MCP server wraps the Ghost Content API -- the read-only interface Ghost exposes for every publication -- and exposes four tools.

get_publication_info returns structured data about the publication: who wrote it, what it covers, how to cite it correctly.

list_articles returns the full article list with titles, excerpts, tags and reading times.

get_article fetches the full text of a specific article by its URL slug.

search_articles does a keyword search across titles and excerpts.

No scraping. No fragile HTML parsing. Proper API access, clean JSON out. The agent gets exactly what the server decides to give it -- in the format specified, with the attribution context attached, within the scope defined.

That is not just publishing. That is governance.

What happened when I connected it

I added the server to my local Claude Code configuration and pointed it at the publication. Then I gave the agent a task: summarise all the articles on AI governance, with correct attribution for each claim.

Here is what the agent did.

It called list_articles and received the full article list. It identified the articles tagged with AI governance. It called get_article for each one in sequence. It built a structured summary, attributing each point to the correct article with the correct URL. It did not visit the website. It did not scrape HTML. It did not truncate content or lose attribution context in the process.

The whole sequence took under thirty seconds.

That behaviour is exactly what the governance wrapper argument is about. The agent operated at machine speed, making multiple tool calls, accessing real content across multiple sources. The MCP server was the governance layer: it controlled what the agent could access, in what format, with what attribution metadata attached to every response.

The agent retrieved the content correctly because the interface was designed to make correct retrieval possible. Without the MCP server, the agent would have scraped, guessed and probably lost the attribution entirely. Governance in the wiring made the difference.

The gap this exposes

Most AI governance guidance published today is available only as PDFs, blog posts and policy documents that an agent can access only by scraping or guessing. The organisations publishing that guidance -- think tanks, consultancies, government bodies -- are writing about governance while producing content that is itself ungoverned at the machine layer.

That gap is not an accident. It is an unconsidered choice. The same choice that charities make when they deploy AI tools without thinking about what sits underneath them.

If you publish guidance on AI governance, your content should be machine-readable. Not because agents matter more than people. Because intellectual honesty requires that the medium reflect the argument. A security consultancy with poor security on its own website is not practising what it preaches. A governance publication that cannot be read by an AI agent is in the same position.

The standard for what this looks like is not high. Four tools. A read-only API. An afternoon of Node.js. The code is open at github.com/samprodger/interconnect-mcp. If you run a Ghost publication and want to do the same, the README has everything you need.

What success looks like

Here is a falsifiable claim, stated before the conclusion: if this worked, an agent with the right configuration should be able to connect to The Interconnect MCP server, retrieve all three articles in this series, reconstruct the central argument of each one with correct attribution, and identify how the three connect, all without visiting the website, without scraping HTML and without being given any content manually.

That is the test. The server is live. The tools are documented. Any agent that supports MCP can run it.

Whether this blog succeeded in practising what it preaches is not something I can judge from inside it. It is something an agent can now read, search and verify for itself.

The code is at github.com/samprodger/interconnect-mcp.

The server is now publicly hosted. Any agent with MCP support can connect to it directly at https://mcp.prodger.cc/sse  — no local setup required. The configuration for Claude Code and Claude Desktop is in the README.

Sam Prodger is Field CTO at Gravitee and spent nine years as Head of Data at the RNLI. The interconnect-mcp server is at github.com/samprodger/interconnect-mcp.