A coglogic system · The first proof
A memory substrate for cognitive systems. Made for the people who design cognition.
engram holds what a system learns in every form it arrives in, keeps the history of what was true and what was believed, and composes what it returns at the moment of asking. It runs today. This page says what it does and how it behaves, in the terms it was designed in.
Three parts, one system
engram core is three subsystems that are one system. Modality is what it can hold and how it can be asked. Substrate is how what it holds is encoded, identified, timed, recognised and kept safe. Memory is what it makes of what it is told. None of the three comes first; each limits the others unless they are designed together, so they are designed together.
The definitions are of equal weight and equal shape on purpose. A change proposed to one part is read through the other two before it is accepted, and if the lenses return different objects the change waits until the definition is amended. That discipline is as much a part of engram as any line of code.
Nine kinds of holding stand behind one door: key and value, vector, graph, table, full text, place, bitmap, probabilistic summary, and the system's own state. Each has its own verbs and its own records, and every one of them makes the same promises about identity, time and provenance.
So a thing written once is findable in every form that can hold an aspect of it, and between the forms runs a mesh: every one reachable from every other by a path that is tested, one question answered across all of them as one ranked, dated whole.
Everything the node holds is encoded, identified, timed and recognised one way. One keyspace, one clock, one log, one wire protocol and one layer of encryption serve every form, so a snapshot reads all of them at a single instant and a key withdrawn withdraws every trace it protected.
Each thing carries one identity in every form it takes, and every fact carries two clocks: when it became known, which that one shared clock stamps the same way in every form, and when it was true, which travels with the fact itself. When the encoding changes, the memory is reborn from its base facts with every derived view rebuilt, rather than patched in place.
A sender tells engram what it knows and what it wants: states, events and rules; aims to achieve, to maintain or to avoid. engram writes each part into every form that can hold it and ties the parts to one record, so a memory is one thing with many facets, not many entries that happen to agree.
Then it derives what it was never told: concepts from what recurs, beliefs from testimony that competes, implications from rules whose conditions hold, possibilities from rules whose conditions do not. Nothing is deleted except by an explicit erase, and every answer can say where it came from.
One memory across text, image, sound and signal, with no translation step between them. What is learned in one form is available in every other: a phrase can surface an image, a sound can recall a document, a diagram can answer a question first asked in words. The forms were never stitched together, because they were never apart.
Recall is composition rather than retrieval. An answer is assembled at the moment of asking from everything the memory holds, ranked on one scale and returned as one dated whole, not read back from where it was filed. What arrives is already relevant and already in order, and it can meet a question the memory never filed an answer for.
Two clocks run through everything: when a thing was true, which travels with the fact, and when it became known, stamped by the one clock every form shares. Kept apart, they let engram answer a harder class of question than what happened: what was understood at the time, and what has changed since. Ask the memory as it stood at any earlier moment and it answers as it stood then, without pretending the present never arrived.
Confidence, provenance and doubt are carried as values rather than moods. The memory knows where each thing came from, how far it can be trusted and what it has no basis to claim; it tells what it knows from what it merely assumes, and when a question falls outside its reach it says so. Every item it returns explains itself back to a source or a rule.
Built to live across many systems as one shared memory, not as silos that sync after the fact. Many can draw on it at once, and what one learns the rest can hold. The shared mind converges wherever it is replicated; each node also keeps a private mind of its own, shaped by its own history, that stays where it lives.
Left running, it reorganises, abstracts and lets go. The patterns that recur are drawn out into concepts, the detail that no longer earns its place is retired, and what remains grows more useful rather than merely larger. What is kept, abstracted or let go is governed by policy, and the policy is inspectable.
What it is
We would rather show engram than describe it. In a working session it runs against your data and inside your constraints, and each behaviour on this page can be seen for yourself: the forms it spans, the history it keeps, the confidence it carries and the answer it composes when it is asked.
Every claim here is a property of working software, stated as plainly as we can state it. Nothing on this page is a promise about a future release; a behaviour that cannot be shown running is not described here, and the first conversation is where it is shown.
How it is held
engram core is written down in full before it is coded: what each part is at full realization, what it holds in common with the others, and what it is not. Every change is read through all three parts before it is accepted, and a change that would make them disagree is refused until the definition itself is amended, in writing, with a date.
Each promise the parts make to one another is held by a test, and a promise that fails is pinned with an owner until it holds again. This is how a system built past the proven stays specified: not by intent, but by a record the code is measured against, every day it runs.
Not a concept, and not a claim. A system that runs.
If you are designing cognition and the memory beneath it is the ceiling, write to us. We will show you engram running, and say plainly whether your problem is one it should hold.