How it works
Evidence in. Understanding out.
Apollo should be stopped until Q4.
#delivery · 09:14
Ontheia is built around one loop that turns observations into a coherent, living model, and turns that model back into software and action. The shape below is settled direction; the details still being worked out are marked honestly as we go.
The shape
The system is a loop, not a database.
A database is a place you write to and read from. Ontheia is a cycle: reality is observed, reconciled into understanding, and that understanding is used to reveal software and take action — whose consequences become the next observations. Your existing systems don't go away; they stay as the places where work is actually executed. What changes is the semantic and interaction layer that sits across them.
Reality → Observation → Reconciliation → Ontology → Interpretation → Surface / Action → RealityThe loop is the architectural shape. Everything below is one arc of it.Reconciliation
Every observation is evidence, not automatically truth.
A new observation isn't filed straight into the model. It is weighed against everything already understood. Before anything is written, reconciliation asks eight questions of it:
- Identity What existing thing, if any, does this refer to?
- Semantics What does it mean in the current model?
- Belonging Where does it fit in the relationships we hold?
- Consistency Does it contradict what we already understand?
- Time Is this current, historical, or effective in the future?
- Provenance Where did it come from, and how far do we trust it?
- Novelty Does representing it require the model to evolve?
- Usefulness Would a new abstraction actually improve future reasoning?
Mechanically, evidence enters a queue and is reconciled one observation at a time, in order. Two searches run in parallel: one across the whole model — every entity, attribute, relationship and alias it already defines — and one across the instances — the specific people, customers and contracts that already exist. Each returns ranked candidates with scores and the reasons they matched. A judgment step then weighs both against the evidence and, when the picture is thin, asks for more of the surrounding graph before deciding. Similarity only ever retrieves candidates; it never gets to settle meaning on its own.
Open on purpose: the exact matching thresholds, how much context a judgment may pull, and who or what performs governance are still being worked out. What's settled is the discipline — ranked evidence, a judgment that can say “this doesn't fit yet,” and nothing applied without validation.
The model, held honest
A model that can hold what's actually true.
The point of the model is fidelity to reality, which means three disciplines that ordinary schemas skip.
Relationships are real records
A relationship isn't a foreign key. It's a first-class fact with its own endpoints, its own attributes, and the dates it was true.
Time is stored as dates
“For two years” rots the moment it's written. The model keeps the dates a fact was effective, so the same statement still means the same thing a year from now — and the model can be asked what it held at a past moment.
One authority, never two
The system of record is a durable database — PostgreSQL. The graph the reconciler reads is a projection built from it: fast to traverse, but never a second source of truth.
This is also where intelligence stays in its place. When a model suggests a likely relationship, that suggestion doesn't become fact. It enters reconciliation as evidence or a proposal, and becomes part of the organization's understanding only through the governed acceptance process — the same gate every observation passes.
Understanding to action
If it only explained the organization, it would be a dashboard.
Understanding has to connect to doing. When you state an intent, the runtime works over the model and the moment and asks: What matters now? What is the user trying to accomplish? What is uncertain? What decisions are required? What action is appropriate — and authorized?
Out of those answers it composes a surface — a temporary manifestation of organizational reality for a particular context, assembled from the model and the available capabilities rather than chosen from a fixed menu of applications. A surface can take whatever form the situation needs:
- a conversation
- a table
- a form
- a decision workspace
- a report
- a generated mini-tool
- a direct action
- or no interface at all
And behavior lives with the definition, not with a deployment. A rule the organization relies on — an active contract needs a positive response window, total exposure = sum of open invoices — is stored as reviewable data a person can approve at a glance. Actions that reach into outside systems are held the same way: each one content-addressed, sandboxed, metered, and replayable. Nothing runs with ambient authority.
Deliberately open: how surfaces are technically produced, and the full model for authorization, approvals, and rollback. These are the next experiments, not settled claims — which is exactly why they're not drawn as finished here.
Where it stands
The loop is real. The edges are honest.
The loop, the reconciliation discipline, and the model above are settled direction. Who governs changes to the model, how actions are authorized, and how surfaces are produced are open questions — held open on purpose. Next: see what coherence means, or watch the loop run against a week of real evidence.
Watch it run