Theory
The thesis.
Lifted from @/theory/residence-vs-scale and @/theory/token-cost-decay-thesis, locked 2026-04-07/08.
Two axes: scale and residence
A million-cell grid with a resident on a narrow slice ticking every five hours, hooked up to a UI and POST endpoints, could ship as a "Salesforce" and work, but that is not full residence. It is Grid as a better database. Full residence is a different metric entirely.
Scale
Cell count in the corpus. Bounded by disk. Cheap. A ten-million-cell grid is a normal thing and costs nothing beyond storage. Scaling along this axis is a filesystem problem, not a language problem.
Residence
The subset of cells whose cognition is actively engaged by one or more residents, weighted by tick frequency. Bounded by (resident count × working-memory size × tick rate). This is the metric the residence thesis is actually about.
A cell that is not in any resident's working context, not in any resident's addressable-on-demand memory, and not part of a multi-resident coordination surface is, from the residence standpoint, dead weight. Fine to carry; grids carry dead weight cheaply. But it does not count toward the thesis that cognition and state are the same artifact, because there is no cognition touching it.
Two legitimate uses, both real
- Grid-as-substrate. The resident footprint approaches the corpus size. Every cell is in some resident's cognition on some schedule. The residence thesis is being tested.
- Grid-as-database. The resident footprint is a tiny slice of the corpus. The other 99%+ of cells are queryable, projected on demand, served via HTTP, but inert to cognition. Perfectly valid product. But the residence thesis is not being tested.
Grid supports both uses. Both are valuable. Only the first exercises the claim that makes Grid interesting as a new substrate. When we report on Grid we distinguish which use we're reporting on, or we're selling one thing and delivering another.
The token-cost-decay thesis
Grid's value function is monotonic in inference frequency. The SQL+agent stack, and every other "agent over a database" architecture, is structurally request-response. Even with infinitely cheap inference it still has to be poked by a user, a cron, or a webhook to do anything. There is no native "I am present in this system" mode. Grid's tick-driven runtime IS that mode, today, at any frequency we can afford.
As token cost falls toward zero, Grid does not just become cheaper. It crosses a phase transition. At hourly ticks the resident is closer to a thermostat, sample, compare, act, sleep. At second-or-faster ticks it crosses into homeostat territory: a continuous sensorimotor loop closed against the world it inhabits. That crossing is qualitative, not quantitative. A thermostat is not alive at any sample rate. A homeostat is, even at slow ones, because the loop is closed and continuous.
As token usage approaches zero, Grid and its residents flourish. The grid becomes alive, not metaphorically, in the specific cognitive-science sense that a continuous closed perception-action loop crosses a threshold the open one cannot.
Three corollaries that fall out of this
1. Grid does not need free tokens to win
It already has a capability the alternative stack does not have at any price: continuous presence as a structural property. The cost curve collapsing unlocks new intensity of an existing capability, not a new capability. We do not wait passively for the wave. We build for it now.
2. At very low tick costs, the bottleneck shifts
Tokens stop being scarce. State coherence, wall-clock latency, and human specification become the new scarce things. Grid has structural answers to all three:
- Co-residence handles state coherence (cognition and state are the same artifact, so they cannot drift)
- Small focal regions plus a local kernel handle latency (the tick loop does not have to round-trip a cloud schema)
- The world IS the specification handles the human side (a Grid program is what the resident inhabits, not a separate requirements doc the human has to translate)
3. The structural advantage is one claim
The thing that makes Grid a different kind of system, not a faster version of an existing one, collapses to this: the agent's cognition and the system's state are the same artifact, so any workflow that depends on prior cognition being queryable is free in Grid and expensive in SQL+agent. Today's resident reads yesterday's reasoning cells like any other cells. SQL+agent has to build a second substrate (agent_log table, get_prior_reasoning tool) to do the same thing, and that second substrate can drift from the first.
See also: What Grid is not good at, the eight honest limits where Grid loses cleanly. The thesis is right conditional on doing the work; this page does not claim more than the cells lock in.