Agents, actors, and what happens when your protocol boundary is also a Markov blanket.
In 1973, Carl Hewitt published the actor model. The core idea: independent processes that communicate only through message-passing, each maintaining its own internal state, no visibility into each other’s internals. No shared memory. No global clock. Just boundaries and messages.
That paper informed fifty years of distributed computing. Erlang, Akka, Orleans, every production actor framework you’ve used — all descendants. And if you’ve built a hierarchical actor system at any real scale, you know the shape: planners at the top reasoning over long horizons, actuators at the bottom executing fast. Slow loops nesting fast loops, all the way down.
Now, everyone’s calling them agents. The vocabulary changed. The shape didn’t.
I spent a few years building hierarchical actor architectures that had to compose systems operating at wildly different timescales — slow models and fast models talking through well-defined boundaries. The trick was never getting them to agree on a shared internal representation. That’s a trap. The trick was getting the boundaries right. If two systems share enough semantics at their interface, they can compose without merging. They don’t need the same clock. They don’t need the same world. They just need to understand each other at the edges.
I keep seeing that same shape in MCP.
An MCP server sits inside a network boundary and exposes a tool surface. Inputs come in, outputs go back, and everything else — the graph, the indexes, the inference, the domain logic — stays hidden. If you know Friston, that’s a Markov blanket — the statistical skin of a system, the boundary that lets it maintain its own internal state while interacting with everything outside it. Sensory states on one side, active states on the other, internals protected. Not as a metaphor. As a structural description of what the protocol boundary actually does.
But here’s what’s interesting: an MCP server doesn’t just expose tools. It can expose a world model. When a server emits responses with @context pointing to shared vocabularies — CPC classifications, schema.org, whatever the domain demands — it’s not just answering function calls. It’s publishing a bounded, self-describing piece of the world. “I model these kinds of things. They relate to each other in these ways. Here’s enough semantic context that you can compose me with something else.”
Two servers that have never met can be composed by an agent because they share enough common vocabulary. Not shared because someone sat down and built a Grand Unified Ontology — that’s the Cyc trap. The world is too messy and too fast to be pre-coded from the top down. They share vocabulary because they each made small, lightweight semantic commitments that happen to overlap. Like two organisms that evolved separately but can cooperate because they share enough biochemistry.
This is the holon argument applied to data. Each MCP server is a whole — complete domain model with its own internal logic — and a part, composable into larger agent world-models. And because the boundaries mediate timescale, a model that changes slowly (a legal code, a taxonomy, a geological survey) can compose with a model that ticks fast (real-time sensor data, agent decisions, market signals) without either one having to match the other’s clock.
Think about what this means for an agent. An agent has input modalities — channels for observation — and affordances — actions it can take. Its job is to build internal models, predict what will happen when it acts, act, then reconcile the difference between expectation and outcome. That reconciliation is learning.
Now, imagine that the agent discovers an MCP server that exposes a world model it didn’t have before. It hasn’t just gained tools. It’s gained a piece of the world. New structure for its latent model. New affordances. Like downloading kung fu — except the kung fu comes with a self-description of what it is and how it relates to everything else the agent already knows.
An agent that knows MCP might find a server that knows about other servers. Then use that to find one that understands federal law. Then another that layers state law on top, sharing semantics with the federal server while adding its own. Then another for local ordinances, deferring up when it needs to. You’re not building a monolithic legal AI. You’re composing a lattice of small world models, each one bounded, composable through shared boundary semantics — and each one ticking at whatever frequency the domain demands.
There are several ontology-capable representation layers worth looking at here — JSON-LD, RDF-star, OWL, property graphs, various combinations. Each makes different tradeoffs between expressiveness and developer experience. The right choice depends on the domain. The point isn’t which representation wins. The point is that MCP gives you the spot in the protocol where these choices can be made locally, per server, without imposing a universal schema on the whole system.
Some of this exists already. Neo4j’s graph-aware MCP server. Guides on generating MCP servers from OWL ontologies. The EBI Ontology Lookup Service is exposed via MCP. But nobody seems to have named the pattern yet — the recognition that MCP server boundaries have the same shape as the boundaries between world models in active inference, and that this isn’t a coincidence. It’s the actor model’s message-passing boundary, upgraded with ontological context, operating at the protocol level.
Planners at the top. Actuators at the bottom. Small world models bumping into each other in the middle, composing into larger ones when the semantics line up. That’s the lattice. It’s also a pretty good description of biological cognition. Or economies. Or ecosystems. The shape keeps showing up whether you’re looking for it or not, which is either a coincidence or the most interesting thing about it.
Originally posted on https://asabovesilicon.substack.com/p/mcp-and-the-shape-of-small-world