Three thoughts that looked unrelated
I was thinking about BBSing, William Gibson’s Neuromancer, and Walid Saad at roughly the same time.
Wintermute, in the novel, is an artificial intelligence that never sits in one place. It coordinates through people, machines, interfaces, and partial representations of itself. That shape — a mind operating across a world it does not contain — stayed with me. Years later I borrowed the name for my own AI reasoning and orchestration engine. Not an attempt to recreate the character; a reference to the architectural distinction.
On the surface this is what nonlinear thinking looks like when it is being unhelpful. One thread is thirty-year-old computer culture. Another is a 1984 novel and the orchestration system that took one of its AIs for a name. The third is research on cognitive world models and agents reasoning inside structured environments.
Inside reference · cognitive world models
The question is not “can an agent have memory.” It is closer to: what does an agent actually need to carry inside itself when it operates in a world that exists independently of it?
A world model is one answer. It compresses high-dimensional sensory input into a compact latent state the agent can run forward, so planning happens inside the model rather than inside the environment. MetaMind: General and Cognitive World Models in Multi-Agent Systems by Meta-Theory of Mind (Wang, Shelim, Saad, and Ramakrishnan, 2026) takes that into the multi-agent case, where the hard part is interdependent dynamics and long-horizon planning with collective awareness — under no central supervisor and no explicit communication channel.
Their mechanism is a meta-theory of mind. Each agent predicts and plans over its own beliefs, and also runs that inference backward, reconstructing the goals and beliefs implied by its own behavior. That self-reflective loop is metacognition learned without labels, and the paper generalizes it from first person to third by analogy: an agent infers a neighbor’s goals and beliefs from limited observed behavior, and adapts to a collective intention nobody announced.
That is why the work belongs in this essay. Every agent’s model is local, compressed, and assembled from whatever that agent happened to observe — and coordination has to survive that condition rather than wish it away. An agent’s representation of the world is not the world. It is the discipline FidoNet enforced between a node and the network, and the layering Gibson drew between Case, Wintermute, and cyberspace, arriving in the vocabulary of learned models.
The departure is in the direction of travel. MetaMind’s constraint is the absence of a channel: belief about other agents is reconstructed inside the observer, and quality lives in the accuracy of that inference. This architecture assumes a channel exists and constrains what may cross it — an attributable observation or proposal, adjudicated locally before it becomes belief. That is not a correction of the paper. It is a different systems concern: theirs is inference without communication, mine is authority under communication. Both refuse a single shared mutable state.
The BBS taught me that the node is not the network. Gibson gave me a vocabulary for intelligence operating inside a persistent world it does not own. Saad’s group gave me a formal way to think about the third piece: an agent carrying a compact internal model of a world larger than itself, and still having to act while that model stays partial.
They were not three thoughts.
They were the same systems problem showing up in three different vocabularies. Different nodes over a durable interchange protocol. Different intelligences inside a persistent cyberspace. Different cognitive agents holding local models of one shared environment. Each arrangement refuses the same shortcut.
The reasoner is not the world.
The rest of this follows from that sentence. If the world is durable and external, the cognition inside it becomes replaceable. If cognition is replaceable, agents need some way to hand each other findings without handing over authority — attributable emissions instead of shared mutable memory. That is what makes claim is not belief a load-bearing rule rather than a slogan, and it is what the reasoner-substitution experiment later in this piece exists to falsify.
BBSes were worlds before we called them worlds
I grew up BBSing. A bulletin board system was technically a computer answering a modem, but that description misses almost everything that mattered. A good BBS felt like a place.
It had identity. Presence. Rooms. Message bases. Doors into other programs. Permissions. Persistent history. Other people who might be there now or might answer tomorrow. A sysop who knew the topology. And, with systems like FidoNet, messages could cross from one independently operated node to another.
Inside reference · FidoNet was interoperability, not sameness
FidoNet did not require every machine to become the same machine. The durable layer was the protocol around exchange: addressing, message structure, session behavior, and routing. That is the historical rhyme here—the shared world survives heterogeneity because the interchange contract is stronger than the node implementation.
The important part was not that every node ran the same software. They did not. The durable thing was the structure around the message: who sent it, where it was going, how it moved, and enough shared protocol for another machine to understand what had arrived.
Constrained computers forced a useful discipline. The intelligence of the node and the persistence of the world were not the same thing.
Case and Wintermute occupy different layers
Back to the novel, because the layering is the part that earns the name. Henry Dorsett Case is a console cowboy — a gifted operator whose real habitat is cyberspace. Wintermute is the hidden coordinator of the operation Case is recruited into. Cyberspace is neither of them.
Case moves through the network. Wintermute coordinates across it. Neither one is the network. The world persists outside the mind currently navigating it.
Inside reference · actor, coordinator, world
The architectural split is useful even if the literary analogy ends there: Case is a situated actor; Wintermute is a distributed coordinator; cyberspace is the persistent environment. Collapse those layers and replacement becomes migration. Keep them separate and replacement becomes substitution.
That distinction is the entire point of the book, and it is the distinction modern AI systems keep collapsing.
Put enough conversation into a model context and it appears to know a world. Give it a few tools and it appears to inhabit that world. Keep the session alive long enough and the model begins to feel like the durable thing.
Swap the model. Move providers. Lose the context window. Rebuild the application around a different reasoner. Suddenly you discover how much of the “world” was really just implicit state trapped inside one cognitive runtime.
My Wintermute is much less cinematic. It is an AI orchestration and agent control plane: a stable boundary between applications, model providers, tools, policy, durable sessions, and a portable world model. The point is not to build one giant personality. The point is to let different reasoners inhabit the same operational world without making that world depend on any one model vendor or context window.
Wintermute started pushing me toward a harder boundary: the model should reason about the world, but the model should not be the world.
That led to a portable world model — explicit project ontology, explicit interpretation rules, bounded retrieval, provenance, confidence, and structural corrections stored outside any one provider’s hidden state.
Then came the more important question. If one agent learns something, how should that knowledge move to another agent?
Saad makes the boundary explicit
This is where Walid Saad’s work stops being a citation and starts doing architectural work. In MetaMind, the useful object is not a giant shared memory that every agent reads and writes. Each agent carries a cognitive world model: a compact representation assembled from its own observations, beliefs, and predictions. Coordination has to emerge while those representations remain local and incomplete.
The paper pushes that problem into a particularly hard regime. Its agents do not get an explicit communication channel for announcing what they want or believe. They infer the internal state of other agents from behavior, using a meta-theory-of-mind mechanism to reason about goals, beliefs, and collective intention. The interesting systems fact is not simply that the agents can coordinate. It is that coordination does not require their internal models to collapse into one canonical mind.
That gives me the missing boundary. A cognitive system may construct a representation of the world, but the representation is still not the world itself. And if several cognitive systems are going to inhabit one durable environment, interoperability should not require transplanting one agent’s cognition into another. It should occur at the boundary between cognition and representation.
Interoperability belongs at the boundary between cognition and representation.
My architecture takes the inverse constraint from MetaMind. Their question is how much collective awareness can be recovered when no communication channel exists. Mine assumes the channel exists and asks what is safe to put through it. The answer cannot be “belief,” because belief carries the receiver’s authority. What can cross is evidence about the world: an observation, a proposal, provenance, confidence — something another cognitive system can independently evaluate without surrendering its own model.
That is the turn from world models to epistemic emissions. An emission is not one mind copying itself into another. It is a cognitive system externalizing a piece of its representation as an attributable artifact. The receiving system can inspect it, reject it, combine it with other evidence, or project it into local state. The cognition can be replaced. The artifact can remain. The world does not have to forget what was learned just because the reasoner changed.
And that gives the reasoner-swap experiment a sharper claim. If the durable representation survives substitution of the cognition that produced or consumes it, then what survived was never merely hidden state in a model. It was a primitive of cognitive interoperability.
Inside reference · inevitable nomenclature failure
It’s a Saad Walid and we’re just living in it.
With apologies to Walid Saad, the Max Weinberg 7, and peer review.
Claim is not belief
The easiest answer would have been shared mutable memory. Agent A changes a record; Agent B reads the changed record. Fast, convenient, and epistemically dangerous.
Instead the architecture became append-only.
observation → proposal → local adjudication → projection
An agent may emit an observation. It may propose a change. But the receiving side does not automatically inherit the sender’s belief. It receives an attributable claim and decides locally whether that claim becomes part of its projected world.
Claim ≠ belief.
Inside reference · the anti-telepathy rule
Shared mutable memory makes every writer partially sovereign over every reader’s world. Epistemic emissions reverse that: one agent can say what it observed and what it proposes, but another agent owns the decision to project that claim into local state. Communication moves evidence; authority does not hitchhike with it.
This is where reading about cognitive world models turned into a primitive of my own. MetaMind reaches collective awareness without a channel: each agent infers what its neighbors must want and believe from their observable behavior, by analogy to itself. That is the harder research question — how much coordination is reachable with no messages at all. My problem is the inverse, and more mundane. The channel exists. I want it to carry evidence without carrying authority.
That sounds like a small distinction. It changes the whole system.
Provenance becomes reconstructible. A bad agent cannot silently overwrite canonical state. Contradictions remain visible instead of being flattened. And authority stays local: a message about the world cannot smuggle in permission to act on the world.
The smallest experiment I could build
Once the primitive existed, I wanted to test the narrowest possible claim without hiding behind an expensive live-model demo.
The experiment uses two heterogeneous agents and one known architectural boundary in the world model. In my communications architecture, Tilden and Stokoe are separate layers. The ground truth says they must not be collapsed into one another.
In the control, Agent A transfers opaque conversational context to Agent B. The correction exists as prose inside a blob of prior conversation.
In the treatment, Agent A transfers structured epistemic emissions: an observation and proposal with provenance. Agent B adjudicates the proposal locally and builds its own projection.
Then I swap Agent B’s reasoner.
The test is not whether the replacement model is smarter. The test is whether replacing the thing doing the reasoning changes the durable semantic world it is reasoning about.
Cognition is replaceable; the world remains coherent.
The first harness is deliberately deterministic. No live OpenAI-versus-Anthropic bake-off. No claims about consciousness, cognition, or information theory. Just a falsifiable architectural proposition with fixed ground truth and observable invariants.
Then the repository became a laboratory
This is where the experiment took an unexpected turn.
If the experiment is deterministic, versioned, and parameterized, the repository already has almost everything needed to operate it as a small computational laboratory.
- The local runner is the laboratory.
- The repository is the lab notebook.
- Git history is provenance.
- Committed summaries are the evidence record.
- Wintermute is the experimental subject.
- Cloudflare remains the world runtime, outside the lab.
Inside reference · executable scholarship
Git is already a provenance machine. A deterministic local runner adds repeatable execution; committed summaries add retained evidence; pull requests add a review surface. None of that magically creates academic peer review. But it does create something unusually close to a runnable lab notebook where the claim, apparatus, result, and lineage can occupy one addressable graph.
The runner fans the experiment across a seed matrix. Every trial records the Git SHA, experiment identifier and version, seed, experiment-definition hash, ground-truth hash, control and treatment metrics, and the final pass condition. A local aggregation step collects the independent trial outputs and fails if the invariant does not hold.
That means a pull request can become something more interesting than a software review.
A PR can state a hypothesis. The local runner can execute the protocol. The summaries can preserve the evidence. Review can challenge the apparatus, ground truth, metrics, or interpretation. Merge can establish a permanent experimental lineage.
Not peer review in the formal academic sense. But the primitives suddenly rhyme with it.
The type system joined the experiment
The strangest confirmation came from TypeScript.
The first CI run failed because the append functions returned a broad epistemic-event union even when the function itself knew it had appended a specific kind of event. The runtime model said observations, proposals, and adjudications were distinct objects. The type system was correctly complaining that the API did not preserve that distinction strongly enough.
The cleanup was not to cast the errors away. It was to make the API tell the truth.
Inside reference · when the theory reaches the compiler
This is the part worth watching. Once “observation is not proposal” stops being prose and becomes a type-level invariant, the architecture gains teeth. The compiler starts enforcing an epistemic distinction that began as a conceptual one.
Now the same invariant exists at several layers at once: conceptually, claim is not belief; structurally, observation is not proposal and proposal is not adjudication; experimentally, those distinctions must survive reasoner substitution; operationally, CI refuses a change that breaks the contract.
The theory is beginning to constrain the software mechanically. That is usually a useful sign.
What the first experiment does not prove
Restraint matters here. A deterministic harness can prove that the architecture behaves as specified under the conditions encoded in the harness. It cannot prove that arbitrary models will communicate efficiently, select useful emissions, resist every adversarial claim, or maintain coherent beliefs in a large dynamic world.
So the first experiment is frozen as calibration rather than embellished into a grand claim. The next experiments can change one dimension at a time: real heterogeneous model providers, contradictory and stale emissions, spatially indexed episodic memory, selective emission based on cognitive value, and communication efficiency against full-context transfer.
The apparatus should be stable enough that when an experiment fails, the failure tells us something about the changed condition instead of about the laboratory itself.
The old architecture was hiding in plain sight
Which brings me back to the BBS.
A FidoNet message could leave one machine, cross a network of independently administered systems, and arrive somewhere running different software because the message format and routing semantics were more durable than the implementation of any particular node.
The modern version of that idea is not “make AI look like a BBS.” It is more fundamental: intelligence should be allowed to vary without taking the shared world down with it.
Case could jack in and out. Wintermute could work through partial representations of itself. The matrix remained.
BBSing was the experiential prototype of persistent digital places. Cognitive world models supplied a vocabulary for agents situated inside them. Wintermute became the implementation substrate. Git turned out to be the laboratory, almost by accident.
Four threads, separated by decades and disciplines, converged on the same primitive:
persistent actors + persistent places + events + memory + communication + federation
That is the useful kind of nonlinear thinking. Not jumping randomly between ideas, but recognizing the same architecture before the vocabularies catch up with one another.
Inside reference · the article is now part of the argument
This page is intentionally no longer self-contained. The prose is a projection; the links expose observations and prior work; each expandable reference preserves an attributable edge; Git preserves the page’s own revision history. The essay does not merely describe a graph of knowledge. It behaves like one.