Intelligence Density

The question we get most

"How is this different from just running Claude Code, OpenClaw, or ChatGPT over my files?"

It's a fair question — those tools are genuinely excellent, and from a distance both things look like "AI plus your data." But the comparison contains a category error, and once you see it, the two products stop looking similar at all.

An agent tool is compute: a brilliant contractor who visits your archive, reads whatever you point at, reasons impressively, and leaves — taking the understanding with it. Next session, it's a stranger again. A node is state plus policy: a resident process that ingests continuously, maintains a measured model of your world, and governs who may query it.

Everything else follows from that one difference.

Density: intelligence as an asset, not an event

When an agent answers a question about your life, it re-derives its understanding on the spot — reading files into a context window, inferring structure, then discarding all of it at session end. The intelligence is real, but it's an event. It happens, then it's gone, and you paid for it in time and tokens each time it happens.

A node computes understanding once, at ingestion, and keeps it. By the time you ask anything, the entities are resolved, the graph is bonded, the meaning-space is clustered, the novelty of every arriving item has been scored, and the day has been measured for how much it moved the model of you. Five distinct mathematical readings of one life — trajectory, geometry, topology, macrostate, dynamics — maintained while you sleep (how your node measures has the full breakdown).

That's what we mean by intelligence density: understanding per byte per query, compounding. Computed once, amortized over every question, every routine, every app, and every person you've chosen to share with — forever. An agent's understanding amortizes over exactly one conversation.

And density has a direction. The node's objectives aren't "complete the task you typed" — they're defined over you: protect attention (what gets filtered stays filtered, because surfacing rejected noise is itself noise), surface what you missed that matters, admit novelty deliberately rather than accidentally, and measure whether your world's structure is growing. Those aren't vibes; each has a number behind it and a ledger underneath it.

The part an agent can't bolt on

Here's a concrete thing your node knows that no session-based tool can: how much today changed you. The node maintains a decayed distribution of your apparent interests and scores each day by the divergence it induces. A hundred routine items measure near zero. Five genuinely new things spike. A quiet weekend that introduced a new person and a new place registers as more significant than a thousand familiar browser tabs — because significance is measured against your baseline, not counted in items.

A context window has no yesterday. A vector store has no derivative. This measurement is only possible for a system that was there the whole time.

The second thing an agent can't bolt on is the trust plane. Sharing a device agent means sharing the keyboard — there is no partial handover. A node shares through permissions with ceilings: this person gets summaries, that app gets only what it wrote, everyone's access is one click to stop, and every answer carries receipts. Which is what makes scale even thinkable: a locally hosted life designed to serve requests at volume — from your apps, your routines, your agents, and the people you've permitted — because the expensive thinking already happened at ingestion, and most requests read measured state at database speed. The language model steps in only to narrate. A million requests against an agent tool would be a million reasoning sessions; a different physics entirely.

Agents are clients

So is this node-versus-agent? No — and this is the part we enjoy most. Agent tools are the node's best customers. An agent that queries a node stops being an amnesiac with a filesystem and becomes an informed actor with a measured world-model and enforced boundaries.

We know because that's how this system was built: the attention layer described above was implemented by a coding agent querying the node it was extending — through the same permission system it was helping build. Run your favorite agent. Give it a node. Each is what the other is missing.

The honest coda

Our discipline on this blog is to say what's measured and what's designed. Measured: the five readings run in production; the two independent novelty instruments agree (r ≈ 0.8 in live testing); the daily digest ships every morning with its ledger behind it. Designed, still being earned: formal null-model calibration of the surprise measure, fitted rather than hand-picked decay parameters, and labeled ground truth for verdict precision — all in active progress, because "your files remember, your node measures" is only a good line if the measuring holds up to the same scrutiny we'd give anyone else's.

An agent is a brilliant visitor. Your node is a resident.