The Knowledge-Coordination Manifesto
Ragnor Comerford/April 2026
On this page
“The knowledge of the circumstances of which we must make use never exists in concentrated or integrated form, but solely as the dispersed bits of incomplete and frequently contradictory knowledge which all the separate individuals possess.”
“Optimism is, in the first instance, a way of explaining failure, not prophesying success.”
“Not to have one meaning is to have no meaning.”
What Intelligence Alone Cannot Solve
Knowledge work has moved through four eras. Each one solved a bottleneck and exposed a deeper one underneath.
Files and folders solved storage. A person born into that era would recognize the bottleneck immediately: physical access. You couldn’t work on something if someone else had it open.
Cloud collaboration solved access. Google Docs, Notion, Airtable. Multiple people, same document, real-time cursors. The access bottleneck vanished overnight. But the data underneath remained unstructured, ungoverned, and unversioned. Someone changes a number in a shared spreadsheet and nobody knows when, why, or what it used to be.
AI assistants solved reasoning on demand. Powerful intelligence, available instantly. But fundamentally stateless. The AI doesn’t know what changed yesterday. It can’t act on its own. Every interaction starts from scratch. A very smart colleague who forgets everything between conversations.
We believe knowledge work is now entering its fourth era. Autonomous agents operating continuously against shared, structured state. Agents that remember. Agents that build on each other’s work. Agents that coordinate.
The pattern is clear if you look at the transitions. Developers hit this wall 20 years ago. Code lived in shared folders, people overwrote each other’s changes, nobody knew what was deployed. Then they got Git: repositories, branches, pull requests, code review. That infrastructure is what made modern software development possible. Knowledge work is at the same inflection point now.
We believe every prior era concentrated more power in the hands of whoever was using the tool. And every era left the same underlying problem untouched: organizational knowledge remained scattered, implicit, and ungoverned.
We believe the current bottleneck is coordination. Agents can reason, generate, analyze, synthesize. They can write code, draft memos, process data. They operate with increasing autonomy across every domain. What they cannot yet do is coordinate safely with each other, with humans, and with the systems they act on.
We believe this is the defining infrastructure problem of the next decade.
The Central Planning Problem
The default response to the coordination problem has been centralized orchestration. One master agent. One giant context window. One workflow engine routing everything through a single chokepoint.
We believe centralized orchestration is central planning by another name. One actor holding all the context, making all the decisions, routing all the work. It breaks the same way central planning always breaks: the world is too complex for any single actor to hold in its head.
We believe the "just make the context window bigger" argument is the new "just hire more central planners." Attention has quadratic cost. Recall degrades with scale. Narrow agents focused on specific tasks will always outperform a bloated oracle trying to manage everything at once.
We believe SaaS sprawl is the infrastructure failure of our generation. Thirty tools that don’t talk to each other. Each one captures a fragment of your organizational knowledge. Each one charges you to access what is already yours. Each one locks you into a schema you didn’t design and can’t export. The more tools you add, the worse the fragmentation gets.
We believe vendor lock-in is always an architectural choice. Your knowledge, your decision history, your institutional memory should live on infrastructure you control.
We believe the market is building in the wrong layer. Point solutions proliferate. Every new tool captures a slice of organizational state and walls it off. The coordination problem gets worse with every vendor you add. What’s needed is a shared foundation underneath all of it.
We believe foundation models are moving up the stack, application-layer differentiation is compressing, and the layer that becomes durable sits between models and applications: context, coordination, and governance. The companies that own that layer own the compounding advantage.
How Coordination Actually Works
Nature solved coordination long before software did.
Ant colonies coordinate millions of actors without a single orchestrator. No ant has a master plan. Each ant reads signals left in the environment by other ants, does its work, and leaves signals of its own. The colony self-organizes through stigmergy: indirect coordination mediated by shared environmental state.
Markets coordinate billions of actors through the price system. Prices compress vast information about supply and demand into signals any local actor can use to make correct decisions. No central planner required. As Hayek showed in 1945, the attempt to centralize what is inherently distributed always fails. The knowledge is on the edges, in the hands of the people closest to the problem. The center, abstracted away, knows nothing.
We believe agents need the same thing: shared structured state they can read from and write to. A coordination medium that carries signal, not noise.
We believe the schema is the price system for agents. It compresses domain knowledge into a structure every agent can read, trust, and act on. When the ontology is clear, agents make locally correct decisions. When it’s unclear, they produce chaos.
We believe in self-organization without orchestration. No orchestrator. No workflows. No prompt chains. Shared state, reactive agents, emergent coordination.
We believe the ontology defines the fitness landscape over which your AI agents optimize. Get the ontology right and everything running on it improves. Get it wrong and no amount of compute fixes the output.
We believe shared state plus locally correct updates plus iteration converges toward stable attractor states. In plain language: when agents coordinate through good structure, the system gets better over time. When they don’t, it degrades.
Every time we build an ontology with a customer, they get sharper. They feel like they’re getting better at communicating and sharing ideas. The ontology forces clarity on what the business actually does. Like a coordinate system where everything is mapped. Ten years ago the MongoDB rebellion against schemas created "schema-free" databases. Agents operating without schemas create garbage instantly. Structure is no longer optional. It’s the precondition for coordination.
Context. Coordination. Governance.
We believe every organization has a world model. Most of it is implicit: scattered across tools, locked in people’s heads, invisible to agents.
We build infrastructure that makes it explicit.
We believe agents need the same infrastructure developers got two decades ago. Developers got repositories, branches, pull requests, code review. That infrastructure is what made collaborative software development possible at scale. Agents need all of that, applied to knowledge.
Context. A typed, versioned graph where your business entities, relationships, and constraints are defined as precisely as code. The schema compiler validates definitions before data enters the graph. Your domain model is versioned, type-checked, and enforceable. Agents reason over a world model, not disconnected chunks.
Coordination. Agents read structured context, write governed proposals, and coordinate through shared state. The graph is the single surface where humans and agents make decisions together. Every mutation flows through proposals: branched, diffed, reviewed, merged. Nothing changes without a trail.
Governance. Git-like semantics for knowledge. Branch, merge, clone, push, pull, audit, approve. Govern change like code. Every change traceable. Every decision auditable. Every action reversible. Without governance, any system running hundreds of agents deteriorates within days. With it, you get a compounding institutional memory.
We believe knowledge should be treated like code. Versioned. Branched. Reviewed. Merged. Governed by the people and agents who understand the domain.
We believe in protocols, not platforms. Open storage formats. Zero proprietary encoding. Push and pull protocols you control.
Sovereignty Over Convenience
We believe your knowledge lives on infrastructure you control, governed by schemas you define, versioned by the people and agents you trust.
We believe sovereignty is a design principle. Every architectural choice we make starts from the assumption that your data stays on infrastructure you own.
The AI market keeps pushing companies toward fragmented, vendor-owned state. One tool for memory, another for orchestration, another for governance. Each with its own data silo, its own pricing model, its own lock-in mechanics. That is the wrong foundation for production AI.
If AI becomes part of your operating layer, the system that holds context, coordinates workflows, and governs agent behavior cannot live entirely inside someone else’s product. Companies increasingly know this. Repatriation of AI workloads is accelerating. The center of gravity is shifting toward owned, hybrid, and self-hosted infrastructure.
We believe the durable advantage of the next decade is ownership of ontology, context, governance, and coordination. Models are commoditizing. The layer that compounds is the one that holds your institutional knowledge, structured and governed, on the infrastructure you own.
Sovereignty over convenience. That is the guiding principle of the post-cloud enterprise.
The Beginning of Infinity
We believe organizational knowledge should compound, not decay.
Every decision captured. Every relationship traced. Every change versioned. Knowledge that grows richer the longer agents and humans work on it.
We believe knowledge work is splitting permanently into two activities. Defining (human): what data matters, what the schema is, what agents should watch for, what the rules are. Executing (agent): gather, structure, update, enrich, flag, cross-reference. Continuously.
The same shift that happened in manufacturing is happening in knowledge work. Humans designed the process, machines ran it. The humans who define the ontology, set the policies, and govern the output will build organizations that compound faster than anyone thought possible.
We believe applications will become ephemeral. The durable system of record for an AI-native organization will be a governed context graph. Agents will read from it and write back to it. Applications will be thin UI generated on demand from shared state. Enterprise software becomes thinner while the context layer becomes thicker.
We believe the path to general autonomy runs through structured coordination. Self-adapting tasks. Stable attractor states. Systems that converge toward order. The architecture that works for one workflow generalizes to a hundred.
We believe in building infrastructure for explanatory knowledge and unbounded organizational intelligence. The beginning of infinity starts when your institutional knowledge stops dying with every employee departure and every tool migration.
We believe this is the most important infrastructure category forming in the enterprise. As models get better, more of the durable value shifts away from the model itself and toward the systems that hold context, coordinate agents, and govern change. As point solutions proliferate, the need for a shared coordination layer becomes more obvious, not less. The market has caught up to the thesis.
We Build
We know what the world needs. A shared context foundation. A governed execution layer. Flexible deployment on infrastructure companies own.
We believe the companies that define the coordination layer will define the next era of enterprise infrastructure.
We are building Modern Relay to be that foundation. Open where it matters. Governed where it counts. Sovereign by default. We are open-sourcing the graph foundation, because the right architecture should be a standard anyone can build on.
We believe in building for the long arc. Open foundations. Sovereign infrastructure. Composable architecture. And the conviction that getting the ontology right matters more than getting to market first.
If you see the same future, build with us. If you’re running an enterprise and the agent era demands a better foundation, talk to us.
Those Who Saw It First
Aristotle, who gave us the very first ontology: the act of defining what exists and how it relates.
Friedrich Hayek, who proved that coordination through distributed local knowledge outperforms central planning, always.
Pierre-Paul Grassé, who described stigmergy: coordination through shared environmental state, without direct communication.
David Deutsch, who showed that explanatory knowledge grows without bound, and that problems are soluble.
Tim Berners-Lee, who envisioned agents reasoning over structured data on the web. Twenty-five years early.
Tom Gruber, who defined ontology as "an explicit specification of a conceptualization." The sentence that launched a field.