The map is a function of the territory.
Every decision in the Sókrates architecture follows from one observation: when enterprise data is hard to reason about, the problem isn’t the data — it’s the map. Every traditional integration builds a copy of the territory and spends engineering effort keeping the copy in sync. Sókrates inverts that.
Evaluate the function against current reality, get current reality. There is no stored state to go stale. Drift is definitionally impossible. This one move plays out at every layer of the stack.
Two layers. One closure.
Hyle is the matter. Eidos is the form. The Demiurge apprehends the form and shapes the matter. That is the Timaeus compiled into a running system.
- i.
- Hyle — the territory
- Connects to any source system — databases, APIs, spreadsheets, existing application models — and compiles their structure into a common type system. A system’s interface definition goes in; typed models classified into the four primitives come out, loaded into the running graph. No integration code is written per source. The next customer’s ERP is a different interface fed into the same machine.
- ii.
- Eidos — the form
- Stores the compiled types as a graph. But nodes alone are just a catalog. The value is in the edges. Relationships between tables and records become typed, directed edges with unambiguous grammar. When a second system connects, Eidos maps relationships within that system and across systems. One system gives you a catalog. Two give you cross-system edges. Three give you transitive paths — questions that require joining across systems that never directly communicated.
- iii.
- Hyperedges — the executable map
- A graph of types and relationships doesn’t answer business questions by itself. A hyperedge is a Law node whose content is an executable query — these entities, across these systems, joined on these keys, filtered by these conditions, produce this result. A hyperedge is a question that knows how to answer itself. It doesn’t store a result; it stores the query that produces the result. Re-evaluate it tomorrow and you get tomorrow’s reality. There is nothing to reconcile because nothing is cached.
- iv.
- Demiurge — the shaper
- One of the four primitives, naming what-shapes-what-is. In the Platonic sense, a Demiurge apprehends the form and shapes the matter. Humans are Demiurges. Sókrates is a Demiurge. Sub-agents Sókrates spawns are Demiurges. The category collects everything that can impose form on the graph. Without it, the ontology describes a world but cannot account for what produces the world.
Four primitives. Any schema.
Every table and every record in every connected system gets classified into one of these categories. Classification is deterministic, versioned, and reviewable by humans. Nothing enters the graph without a typed identity.
Entity
Things that exist. Customers, products, employees, warehouses, accounts.
Process
Things that happen. Orders, transactions, workflows, shipments, approval chains.
Law
Things that must hold. Business rules, constraints, policies, SLAs.
Demiurge
Things that shape. Humans, agents, external services acting under named identities. Every node has a Demiurge on one end of its lineage. Provenance is not metadata bolted onto the graph — it is graph structure.
Sókrates doesn’t just describe where the data is broken. It fixes it.
Three capabilities — matching the same entity across systems, continuous local reasoning, and queries that span multiple systems — are separate pieces held together in one substrate. Composed, they produce something none of them can do alone: a system that writes corrections back. If three source systems hold inconsistent customer records, Sókrates cross-references the rows, infers the canonical value, and on approval writes the fix back to every system that was wrong. The graph tracks the provenance of every repair. A correction that spans four systems is auditable as a single typed Process with typed inputs and a named Demiurge at its head.
The reconciliation move is the one most people miss.
Governance is not a wrapper. It is edges between Demiurges.
Delegates, authorises, and performed are the three primary governance edges, constrained by Laws that upstream Demiurges have authored. Write-safe by default means Sókrates’s initial authorisations cover reading and asking questions — nothing else. Proposal-only actions are the absence of an authorisation edge for that kind of process: Sókrates describes what it would do, and that description becomes a proposed Process awaiting an authorisation edge from a sufficiently empowered Demiurge.
- i.
- Shapes · institutes · authors
- Typed relationships from a Demiurge to each of the other three primitives. A Demiurge shapes entities, institutes processes, and authors laws. Every node has a Demiurge on one end of its lineage.
- ii.
- Delegates to · authorises
- Edges between Demiurges. An approval chain is a typed subgraph of Demiurges, the edges between them, and the processes they authorise each other to perform. The same machinery that queries customer data queries the authorisation structure.
- iii.
- Performed
- Every action is a performed edge with an annotated outcome. The audit log is a live query over performed edges. It cannot go out of sync with reality because it is a view of reality.
The trust surface earns itself wider.
Sókrates’s trust surface — what it can do without further approval — is a live query over its own track record. Nothing in an admin panel moves when the envelope earns itself wider. Expanding the trust surface is a structural consequence of track record, the same way hyperedges update themselves as the underlying data changes. The capability graph is a function of operational experience rather than stored configuration. The authorisation envelope compounds in the same substrate as knowledge, through the same mechanism.
Sovereign per site. Compounding across the fleet.
Each client site runs an inference-class appliance: the graph, the data store, the local model, Sókrates itself. Day-to-day operations run entirely on the customer’s box. A training-class machine at Sókrates HQ handles model finetuning, basis aggregation, and fleet-wide observability. Client data never leaves the customer box. What flows to fleet command is the patterns — anonymised, aggregated, structural — that let the fleet improve collectively without surveilling any individual deployment.
Every Sókrates learns from its own kingdom. The fleet learns from all of them. No one is surveilled.
Three levels of compounding.
Traditional data integration is linear: connect N systems, maintain N×M point-to-point mappings. Cost scales with the square of complexity. Sókrates inverts this on three levels.
- 01.
Within a deployment
Connect N systems; every new system’s schema compiles into the same primitives and its cross-system relationships map once. The cost of adding the N+1th system is constant. The value of adding it is combinatorial: every new cross-system edge creates query paths that didn’t exist before.
- 02.
Within Sókrates
Questions become hyperedges. Hyperedges compose. Actions accumulate into track record. Track record expands the authorisation envelope. Sókrates doesn’t just get smarter with use — it gets more trusted with use, and both happen through the same graph mechanism.
- 03.
Across the fleet
Every cross-system pattern the fleet learns to recognise is reusable. The hundredth customer’s ERP-to-CRM join looks like the first customer’s. The fleet accumulates a basis — recognised patterns, verified resolutions, earned authorisations — that bootstraps every new deployment.
Sókrates does not replace any system. It makes them collectively legible.
It sits alongside existing systems and operates across them. What it displaces is the institutional cost of them not talking to each other:
- i.
The senior developer who is the only person who knows how the ERP and CRM join.
- ii.
The consulting engagement to map the data landscape.
- iii.
The six-month data warehouse project that is obsolete before it ships.
- iv.
The BI dashboard that answers the questions it was designed for and none of the ones that actually matter.
- v.
The operations team running manual reconciliation between systems that should have been automated years ago.
- vi.
The process that requires a human to copy data from one system, check it against another, and update a third — not because the task is hard, but because no single system has the context.
It replaces the institutional knowledge that walks out the door when someone leaves — by making that knowledge structural, queryable, and actionable.
The philosophy is the architecture.
A governed AI department is a Demiurge whose authority is graph structure — operating on a territory it understands at the schema level, inside the walls of the business it serves.