In 1970, disk cost $1 million per gigabyte.

When Codd designed the relational model, keeping every version of every fact was unthinkable. So UPDATE overwrites the old value with the new one. This was a reasonable tradeoff under impossible constraints.

Alice’s salary was $90,000. Now it is $100,000. Both of these are true. The first is a historical fact. The second is a current fact. UPDATE erases the first to store the second — not out of malice, but because there was no room to keep both.

The constraints have changed. Disk is a million times cheaper. Memory is abundant. We can keep everything now. We just haven’t updated the model.

A fact is a triple: entity, attribute, value.

[alice, :salary, 90000]   ;; true until Tuesday
[alice, :salary, 100000]  ;; true since Tuesday

Both facts exist. Both are timestamped. Neither destroys the other. You can ask “what was Alice’s salary last month?” and get an answer, because the answer was never erased.

This is not a new idea. It is how RDF works. It is how Datomic works. It is how reality works.

What is new is taking this seriously.

Not as a graph database feature. Not as an event sourcing pattern. As the foundation. The only data structure. User data, schemas, queries, relationships, rules, violations, tasks — all triples. All queryable. All traveling through time.

One representation. For everything.

McCarthy needed seven operators to build eval — the function where Lisp becomes aware of itself. quote, atom, eq, car, cdr, cons, cond. From these, everything else is derivable.

We need seven primitives to build a domain operating system.

  STORAGE           COMPUTATION       ABSTRACTION

  assert           query             bind
  retract          derive            type
                   match

Every form in the system — objects, actions, queries, rules, views, processes — decomposes into combinations of these seven. No form requires an eighth.

This is the test of a well-designed kernel: the surface is rich, the foundation is minimal.

In Lisp, eval is the moment the language becomes transparent to itself. Programs are lists. eval interprets lists. Therefore programs can inspect and transform programs. Code is data. The map is the territory.

We are one step away from this.

Today, when you define an entity type — say, Employee with attributes name, email, department — the system stores the definition as a JSON blob. One opaque string. The query engine cannot inspect it. You cannot ask “which entity types have a required email field?” using the same tools you use to ask “which employees are in Engineering?”

The fix is obvious once you see it: decompose the blob. Store each attribute definition, each relationship, each validation rule as its own triple. Schema becomes data. Data becomes queryable. The system describes itself using its own primitives.

[Employee,  :et/name,       "Employee"]
[emp-name,  :attr/name,     ":employee/name"]
[emp-name,  :attr/type,     "string"]
[emp-name,  :attr/required, true]
[emp-name,  :attr/owner,    Employee]

Now you can ask:

(query
  (from (type AttributeDefinition) a)
  (where (= (field a required) true))
  (link a belongs-to et)
  (select (pick et name) (pick a name)))

“Which entity types have required attributes?” A question about the system, answered by the system, using the system’s own query language.

This is eval. Not in the Lisp sense — we will always have TypeScript as a host language. But in the sense that matters: one representation for everything. User data. Schema. Queries. Rules. All triples. All queryable. All time-traveling.

That is the root.

When schema is data, and data is queryable, and queries can trigger rules, and rules can spawn actions, and actions create tasks, and tasks present documents, and documents capture facts, and facts feed back into rules —

you get a closed loop.

Zero manual intervention. The system defines the problem, creates the remedy, assigns the work, captures the result, and verifies the fix. Using the same seven primitives.

This is not a feature. This is a consequence.

A consequence of taking one representation seriously.