The Shared Substrate
The Oldest Pattern in the World
Somewhere in southern France, about 40,000 years ago, a hunter walked into a cave and painted a bison on the wall.
We don't know the hunter's name. We don't know if the painting was art or instruction or prayer. But we know what happened next: other humans entered that cave, saw the painting, and changed their behavior because of it. They hunted differently. They moved differently. They knew something they hadn't known before, not because anyone told them, but because someone had left a mark on a shared surface.
That mark is the oldest technology in the world. Older than the wheel. Older than fire kept in a hearth. A mark left on a shared environment that changes the behavior of whoever finds it next.
In 1959, a French entomologist named Pierre-Paul Grassé watched termites build cathedral-like structures — some taller than a human — without a blueprint, without a leader, and without any termite communicating with any other termite. Each termite simply deposited a pheromone-laced pellet of mud. That deposit changed the local environment. The next termite to arrive sensed the change and responded, adding its own pellet in a way that was stimulated by the marks already there.
No termite knew the plan. The plan emerged from the accumulated marks on the shared substrate.
Grassé coined a word for this: stigmergy. From the Greek stigma (sign, mark) and ergon (work). Work incited by a sign left in the environment.
But here's what Grassé missed, or at least didn't say: he didn't discover something unique to termites. He named the fundamental coordination mechanism of all intelligence. Including ours.
Forty Thousand Years of Better Blackboards
The blackboard is the medium. It has always been the medium.
Every advance in human coordination technology is the same story: someone built a better blackboard. Not a better message. Not a better messenger. A better shared surface for leaving marks. And each new blackboard solved one limitation of the previous one, while leaving others for the next generation.
The question for our generation is: what properties does the blackboard need now?
Where AI Went Wrong
In 2023, the AI industry discovered that large language models could use tools, follow multi-step instructions, and act as autonomous agents. The obvious next question was: how do you get multiple AI agents to work together?
The industry's answer was orchestration.
LangChain, AutoGen, CrewAI, and dozens of similar frameworks took the same approach: a central coordinator receives a task, decomposes it into subtasks, assigns each subtask to a specialized agent, passes messages between them, and assembles the result. An explicit control flow. A state machine. A conductor leading an orchestra.
This is the equivalent of putting a termite queen in the middle of the colony and having her issue individual building instructions to each worker. Nature tried centralized coordination. It works for small colonies. It collapses at scale.
The failure modes are predictable, because they're the same failure modes that have plagued centralized coordination systems for decades:
One point of failure. If the orchestrator crashes, every agent stops. The work in progress is lost. There is no graceful degradation: just a dead state machine and a pile of half-finished tasks.
Cascading timeouts. Agent A calls Service B, which calls Service C. Service C is slow. Agent A times out. The orchestrator retries Agent A, which queues behind its own still-pending first attempt. The system enters a death spiral of retries and timeouts that amplifies the original failure.
Fragile coupling. Adding a new agent requires modifying the orchestration logic. The agents can't discover each other's work. They can't adapt to a changed environment. They are not autonomous in any meaningful sense: they are subroutines with natural-language interfaces, waiting to be called.
The distributed systems community solved these problems decades ago. Carl Hewitt's Actor Model (1973). David Gelernter's tuple spaces (1985). CRDTs. Partition-tolerant consensus protocols. The academic literature is full of robust, proven alternatives to centralized coordination.
But the AI agent ecosystem ignored all of it and reinvented the 1990s enterprise service bus.
The reason is cultural. The people building AI agent frameworks come from the machine learning community, not the distributed systems community. They think in terms of prompts and chains, not in terms of shared state and partition tolerance. They are solving the wrong problem — "how do I wire these agents together?" — when the right problem is "how do I create a shared environment that lets agents coordinate without being wired together at all?"
What a Formal Stigmergic Substrate Requires
The cave wall was a blackboard without portability. The tablet was a blackboard without scale. The printing press was a blackboard without bidirectionality. The sticky note was a blackboard without structure. The enterprise database was a blackboard without unity. Social networks were a blackboard without trust.
AI agents operating on physical infrastructure: monitoring hospitals, managing power grids, controlling water treatment plants, coordinating autonomous vehicles need the next blackboard. And this time, nothing can be left out.
Transactional coherence
When an agent writes a mark to the substrate, every other agent must see a consistent snapshot: never a half-written observation, never a partially updated state. In a hospital, a pharmacy agent checking medication interactions cannot see the discharge order before the attending physician's notes have been committed. The substrate must make reality coherent before anyone sees it.
In academic terms, this is the problem that Yoshua Bengio identified in his 2019 NeurIPS keynote on "System 2 Deep Learning." He argued that deep learning excels at fast, reactive pattern matching (System 1, in Daniel Kahneman's framework) but lacks the infrastructure for slow, deliberate reasoning (System 2), and critically, that the two systems need to share state without corrupting each other. He described the need. He didn't describe the mechanism that enforces it.
Temporal ordering
Marks must be globally ordered, not just locally timestamped. When three agents write observations within the same millisecond, the substrate must establish a definitive sequence. In a power grid, the order in which events are recorded determines the causal chain that explains a failure. "What happened first?" is not a question you can answer with wall-clock timestamps on independent machines.
Cryptographic auditability
Every mark must be signed, traceable, and tamper-evident. When a regulator asks "who knew what, and when?" the answer must be a mathematical proof, not a log file. A chain of cryptographic hashes, each block signed with a digital signature, producing an audit trail that can be independently verified by anyone with standard cryptographic libraries. This is not a nice-to-have for regulated industries. It is the minimum condition for deploying AI in healthcare, finance, energy, and transportation.
Physical safety
When an AI agent writes a mark that triggers physical actuation — opening a valve, switching a breaker, adjusting a dosage — the substrate must independently verify that the physical world is ready before the command reaches the wire. Not by asking the AI if it's sure. Not by checking a software guardrail. By physically probing the target device at the application protocol layer and confirming it is in a state to safely receive the command.
This is the lesson of the Therac-25 radiation therapy machine, which killed three patients in the 1980s because its designers removed the hardware safety interlocks and trusted software alone. It's the lesson of the Boeing 737 MAX, which killed 346 people because its automated system trusted a single sensor without physical cross-verification. Software guardrails on software systems are necessary but not sufficient. The containment must be deterministic and physical.
Neural-symbolic unity
The substrate must hold both structured knowledge (what happened — the facts, the relationships, the sequences) and semantic understanding (what it means — the concepts, the patterns, the implications) in the same transactional boundary. When a fact is deleted — a patient invokes their right to be forgotten under GDPR — every neural embedding derived from that fact must physically disappear in the same transaction. Not eventually. Not in a batch job overnight. Atomically. Because the law doesn't recognize "eventually consistent" as compliance.
This is the problem that Gary Marcus has been articulating for a decade: pure neural systems hallucinate because they manipulate statistical patterns without grounding in structured reality. And it's the problem that Henry Kautz taxonomized in his 2020 AAAI address, where he identified six patterns of neuro-symbolic integration: none of which described a system where both layers share a transactional substrate and mutations in one cascade to the other.
No previous blackboard — not cave walls, not enterprise databases, not social networks — has provided all five of these guarantees simultaneously. This is the engineering problem I've spent 18 years solving.
The Guardian Cycle
AIONdb is a knowledge graph: a database that stores relationships between things as subject-verb-object triples, queryable through the W3C standard language SPARQL. The name is a play on words: AI-ON-DB. The intelligence doesn't call the database. It lives on it.
But it is built on a radical architectural choice that makes everything else possible.
Every string that enters the system — every name, every relationship, every value — is converted to a 32-bit integer at the boundary and never touched as a string again until output. A triple is 12 bytes: three integers. The entire query engine operates on integer comparisons. No memory allocation in the critical path. No garbage collection pauses. No cache thrashing.
This single decision — made in 2008, refined across two companies and three codebases — is why AIONdb processes 799,000+ results per second on a laptop. Not a cloud cluster. A laptop.
But speed alone doesn't make a stigmergic substrate. What makes AIONdb a substrate is the Guardian Cycle: a three-phase execution model that enforces the coherence guarantees that stigmergy requires.
In Kahneman and Bengio's framework, the Guardian is the mechanism that ensures System 1 (fast reactive processing) settles into a consistent state before System 2 (slow deliberate reasoning) observes it. It is the consistency barrier that Bengio's architecture requires but does not specify.
On March 12, 2026, we demonstrated this with three frontier AI models — Claude, GPT, and Gemini — coordinating through the shared substrate without an orchestrator, without APIs between them, and without any awareness of each other's existence. Each model wrote observations. Each model read the others' observations. Coordination emerged from the marks on the shared environment.
Why This Matters Now
Enterprise AI value is concentrating at four layers of the stack. I've come to think of them as choke points, not in the constraint sense, but in the sense that whoever owns each layer captures the value that flows through it:
Most companies in the AI ecosystem occupy one of these choke points and partner for the rest. A model vendor (Anthropic, OpenAI, Google) provides the execution layer but doesn't own the data. A data platform (Snowflake, Databricks) owns the storage but doesn't govern it for AI agents. A cloud provider (AWS, Azure) provides infrastructure but not the semantic layer.
The system of record is the deepest of the four. NVIDIA's Jensen Huang made the case at GTC 2026: "This is the structured data, the ground truth of business. This is the ground truth of enterprise computing." Models don't reason their way to truth; they get coupled to it. Whoever owns the substrate where that coupling happens owns the value.
AIONdb occupies all four in a single system. The knowledge graph is the system of record. The Guardian Cycle is the control plane: governance enforced as physics, not policy. The LLM participant is the execution layer: models living inside the substrate as participants, not calling it from outside as clients. And the integer-interned, zero-allocation architecture is the accelerated infrastructure: 799,000+ results per second without a GPU in sight.
This isn't a strategy. It's a consequence of the architecture. When you start from the premise that intelligence coordinates through a shared substrate, and you build the substrate to be coherent, auditable, fast, and safe, you end up occupying the entire stack. Because the stack was never supposed to be separated in the first place.
The Three Problems That Disappear
AI Amnesia
Every enterprise running AI pilots today has the same unspoken problem: the AI forgets everything between sessions. Each conversation starts from scratch. Each agent deployment loses its accumulated knowledge when the model restarts, the API times out, or the vendor changes.
The industry is trying to solve this at the model layer: longer context windows, memory features, persistent threads. But expanding the context window to simulate memory is a fundamental architectural error. It forces the enterprise to re-compute its entire institutional history on every inference call, paying a compute tax to the model provider every time. It is the most expensive possible implementation of "remembering." And it is a vendor lock-in trap: your institutional knowledge becomes inseparable from the specific model's proprietary weights. Switch vendors and the memory disappears.
Memory is not a model capability. Memory is infrastructure.
In a stigmergic substrate, memory is the environment itself. An agent writes an observation: "the compressor in Room 302 is showing vibration patterns consistent with bearing failure." That observation is a triple in the graph, durable, queryable, signed. When the agent restarts — or is replaced by a completely different model from a different vendor — the knowledge is still there. The new agent reads the substrate and knows what the old one knew.
AI Fragility
Three AI agents coordinate a hospital patient discharge: pharmacy review, insurance validation, transport scheduling. In today's orchestration frameworks, they're wired together through a central coordinator. When the insurance company's API goes down — which it does, regularly — the entire pipeline crashes. The patient waits. A human has to manually restart the workflow.
In a stigmergic substrate, these three agents don't know each other exist. The pharmacy agent watches the graph for discharge orders and writes its review. The insurance agent watches for pharmacy clearances and writes its authorization. The transport agent watches for authorizations and schedules the ride. They coordinate through the shared environment, exactly as termites coordinate through pheromone marks.
When the insurance agent's network goes down, the pharmacy and transport agents keep working on other patients. They don't notice. They don't need error handling code or retry logic. When the insurance agent's network returns, it reads the write-ahead log to catch up on what it missed and completes its work.
AI Liability
An AI agent analyzing power grid load is tricked by a prompt anomaly — the 2026 equivalent of a phishing attack — into confidently recommending that a high-voltage breaker be opened. It fires the command.
In every AI system deployed today, that command reaches the wire. The guardrails are software: prompt engineering, constitutional AI, reinforcement learning from human feedback. Software checking software. The industry has confused "semantic alignment" with "physical safety." RLHF and constitutional AI can stop a model from generating a toxic word, but they are entirely useless at stopping a hallucinating agent from opening a high-voltage breaker. This is the Therac-25 architecture — and we know how that ended.
In AIONdb, between the AI's command and the physical wire sits a protocol-specific probe. For a Modbus-controlled breaker, this is a Read Holding Registers command (function code 0x03) that interrogates the physical device. The probe discovers that the breaker is in maintenance mode: a human contractor is working on it. The ReadinessFlag stays locked. The command is rejected at the hardware boundary before it reaches the wire. The AI's hallucination never becomes a physical action.
The dashboard flashes red: ACTUATION BLOCKED. A cryptographically signed violation record is written to the audit ledger. The AI reads its own failure and adapts its behavior. The power stays on. The contractor goes home safe.
This is not a software guardrail. This is deterministic physical containment: the same principle that kept nuclear reactors safe for 70 years, applied to AI for the first time. And it's why this system is insurable when others aren't: an actuary can quantify the failure probability of a deterministic safety system. They cannot quantify the failure probability of an LLM's judgment.
I'm aware the preceding sections make extraordinary claims.
449 formal test reports. Zero failures.
3 provisional patents, 149 claims. USPTO filed.
Full standard conformance. No asterisks.
2023 MacBook Pro, M2 chip, 32 GB RAM.
Sustained throughput. 50 million queries over 10 continuous hours at 1,361 queries per second, with stable memory (no leaks, no growth, no garbage collection pauses). During that test, the system automatically recovered from 20 deliberate failover injections without human intervention.
Intellectual property. 149 patent-pending claims across three USPTO provisional filings, covering: the Guardian Cycle, integer interning, hybrid LSM-Lite storage, zero-copy WASM ABI, selectivity inversion, self-governing compaction, physical actuation safety, and stigmergic agent coordination. The claims are architecturally interdependent: the fast query engine, the Guardian Cycle, and the physical safety probes are legally bound together as a unified system.
Codebase. 193,527 lines of Rust. Not Python glue around someone else's library. Rust: the language you choose when failure is not an option.
The 18-Year Question
In 2008, I asked a question: What would happen if every system and device became contextually aware of my needs and intentions?
I was the Chief Architect for systems that monitored entire provinces: hospitals, transit networks, building portfolios spanning millions of square feet. Every one of those deployments had the same bottleneck: humans manually stitching together systems that should have been aware of each other. I called it the "human middleware" problem. A nurse checking one screen, then walking to another screen, then calling someone on the phone to relay what the first screen said to the person who needed to act on it. That nurse was the middleware. And that middleware doesn't scale, doesn't have a backup instance, and eventually goes home.
The first company taught me what the problem was. The second company taught me what the architecture shouldn't be. The third codebase — AIONdb — is what the architecture should be.
Two companies. Three codebases. 18 years. Not pivots. Convergences. Each one stripped away an assumption that was blocking the real solution.
The first assumption I stripped away was that you need strings. You don't. Intern everything to integers at the boundary. A triple becomes 12 bytes. The query engine becomes pure arithmetic. Suddenly you're processing 799,000+ results per second on hardware that costs less than a month of cloud compute.
The second assumption I stripped away was that you need an orchestrator. You don't. Let agents write to a shared substrate. Let the substrate make truth coherent. Let other agents discover truth through queries. Coordination emerges from the environment. This is how every successful large-scale coordination system in history has worked, from termite colonies to SAP.
The third assumption I stripped away was that safety is a software problem. It isn't. When AI touches the physical world, the containment must be physical. A protocol-level probe that interrogates the device. A ReadinessFlag that gates the wire. Deterministic, auditable, insurable.
These aren't features. They're architectural invariants. You can't bolt them on after the fact. They have to be in the foundation. That's why this took 18 years. That's why it took three codebases. That's why 193,527 lines of Rust exist: because every one of those lines encodes a lesson about what breaks at scale in systems that matter.
What Comes Next
At GTC 2026, Jensen Huang put it simply: structured operational data is the ground truth of enterprise computing. The future of AI isn't smarter models. It's models coupled to the truth that keeps the business running.
The termites already knew this. The cave painters knew it. The Sumerian scribes knew it. Every enterprise that ever deployed SAP knew it, even if they never had the word for it.
The word is stigmergy. The mark left on the shared environment that changes the behavior of whoever finds it next.
For 40,000 years, we've been building better blackboards: each one more persistent, more portable, more scalable, more structured than the last. Cave walls gave way to clay tablets. Clay tablets gave way to printed pages. Printed pages gave way to whiteboards. Whiteboards gave way to databases. Databases gave way to social networks.
Each transition preserved the pattern and added a property. Persistence. Portability. Replication. Bidirectionality. Structure. Scale.
But each transition also left something out. And the thing that was left out became the defining problem of the next era.
AI agents are the next participants in this 40,000-year lineage. They need a blackboard with every property that every previous blackboard provided, and the five that none of them ever did: transactional coherence, temporal ordering, cryptographic auditability, physical safety, and the unity of symbolic truth with semantic understanding.
That blackboard exists. It's called AIONdb: the shared substrate this paper set out to describe, and the first product of MirrorGraph. It's been tested across 440 billion+ result triples. It runs on a laptop. And it's ready.
MirrorGraph builds software that lets autonomous systems act on what’s real. Our first product, AIONdb, holds one living model of reality coherent through change, so systems, people, and agents can act from the same completed, ordered, provable truth.
Founded in Toronto by systems architect Mike Monteith, after three decades building distributed systems for high-stakes operational environments: including healthcare, energy grids, and large-scale infrastructure, with eighteen of those years focused entirely on this problem.
AIONdb was engineered from the memory layer up, with no existing database underneath: lock-free, zero-copy, and cryptographically auditable. It carries 149 patent-pending claims across three USPTO provisional filings, and has been tested through 270 million+ queries producing 440 billion+ error-free result triples, with zero failures.
Mike founded and led ThoughtWire, a Canadian digital-twin company, for over fifteen years, building real-time operating platforms for life-critical infrastructure at scale: smart hospitals, large commercial environments, and complex physical systems. AIONdb is the culmination of that career.
Reality, held coherent.
Reality, held coherent