The instrument

Build a coordinate.

Choose a value on each axis. The tuple that assembles is a cell — a complete description of how a running system is structured, advanced, isolated, and checked. The character of the cell falls out of the choices.

c = ⟨ choose a value on each axis ⟩

0 / 9 axes set · character —

F
Formalism
THE KIND OF MACHINE
K
Composition
HOW STATES COMBINE
C
Concurrency
HOW TRANSITIONS RUN
I
Isolation
WHERE THE BOUNDARY IS
R
Reactivity
WHAT DRIVES THE STEP
A
Self-reference
WHAT THE MACHINE KNOWS OF ITSELF
T
Thermodynamic class
LANDAUER FLOOR
V
Verifiability
WHAT CAN BE CHECKED
τ
Lifetime
HOW LONG IT HOLDS

The composition (K) and self-reference (A) axes are the two that bend the character of the cell most. Hierarchical + reflective is the cascade. Atomic + opaque is the flat machine. Dynamic-structure + reflective is the autonomic regime — and the cell most systems are still walking toward.

The map, today

Cells already partially occupied.

The map is not blank. Decades of work have placed real systems at known coordinates. Each entry below names a class of running system, its coordinate, and which of the three temporal functions — memory, context, understanding — it holds first-class. The cells that hold all three are sparse.

O1

Cognitive architectures (ACT-R, Soar, CLARION, Sigma, LIDA)

F=integrated · K=OR-hierarchical · C=sequential to parallel · I=encapsulated · R=event-driven · A=introspectable · T=L₁ · V=invariant-tested · τ=checkpointed
holds: memory · context · understanding

The convergent integrated architecture the field has been building since Newell (1990). Working memory plus long-term declarative plus long-term procedural memory, perception and action coupled. The Common Model of Cognition (2017) is its abstract characterization.

O2

Durable workflow engines

F=HSM · K=OR-hierarchical · C=distributed · I=process · R=event-driven · A=introspectable · T=L₁ · V=invariant-tested · τ=durable
holds: memory · context

State-machine orchestration over an event log, with the running state surviving host restarts. Memory and context are first-class; understanding is left to whatever queries the engine.

O3

Hierarchical statechart applications

F=HSM · K=OR-hierarchical · C=sequential · I=encapsulated · R=event-driven · A=opaque · T=L₀ · V=model-checked · τ=ephemeral
holds: context (with history pseudostates → partial memory)

The dominant cell for reactive embedded and UI logic. Hierarchy gives context; history pseudostates give partial memory; runtime introspection and forward reasoning are absent.

O4

Erlang/OTP supervision trees

F=actor · K=OR-hierarchical · C=distributed · I=process · R=event-driven · A=runtime-modifiable · T=L₁ · V=invariant-tested · τ=durable
holds: memory (per-actor) · context (per-actor)

Per-actor state, supervised hierarchically, with hot code replacement. Memory and context within each actor; cross-actor understanding is left to the protocol.

O5

Memory-augmented neural networks (NTM, DNC, memory networks)

F=agent graph · K=atomic · C=parallel · I=encapsulated · R=event-driven · A=opaque · T=L₂ · V=unverified · τ=ephemeral
holds: episodic memory (substrate-level)

Neural networks with explicit external memory matrices, attention-based read and write. Graves and colleagues at DeepMind demonstrated reasoning over family trees and the London Underground. Episodic memory becomes substrate-level; context and understanding remain implicit.

O6

Hierarchical Temporal Memory

F=HTM · K=OR-hierarchical · C=parallel · I=encapsulated · R=reactive · A=introspectable · T=L₁ · V=unverified · τ=checkpointed
holds: memory · partial understanding (sequence prediction)

Cortical-column-inspired sequence learning over sparse distributed representations. Memory and forward prediction held by construction; verified reasoning over the future is not the design point.

O7

Modern LLM-agent memory stacks

F=agent graph · K=sequential · C=sequential · I=encapsulated · R=event-driven · A=opaque · T=L₂ · V=unverified · τ=checkpointed
holds: memory · context

Working scratchpad plus episodic retrieval plus semantic stores plus a context window, coordinated by an orchestrating graph. Memory and context are explicit; understanding is folded into the model that consumes them.

O8

TLA⁺ specifications (offline verification)

F=TLA⁺ spec · K=AND-parallel · C=any · I=any · R=any · A=opaque-at-runtime · T=L₂ · V=model-checked · τ=ephemeral
holds: understanding (offline, over reachable states)

Specification-time reasoning about every reachable state of a system, exhaustively. Understanding of the future is rigorous; the runtime that the specification describes is a separate artifact.

These are coordinates, not rankings. Each cell holds what it was built to hold; the periodic structure makes legible which functions are first-class at each and which are absent. The cells that hold all three at once — the temporal cells — are the ones the predictive face below names structurally.

The predictive face

Cells the structure predicts.

The strongest use of a periodic structure is prediction. Where a cell is sparse but every axis that flanks it is well-occupied, the structure says a system should exist there. Ten such cells fall out of the nine axes.

P1

The reflective hierarchical controller

F=HSM · K=OR-hierarchical · C=cooperative · I=encapsulated · R=event-driven · A=reflective · T=L₀ · V=invariant-tested · τ=checkpointed

A hierarchical state machine that holds its own structure as a value and can be reasoned about while running. Outside inputs propose transitions; the machine itself authorizes, applies, and checkpoints them.

› Why the structure implies it

Hierarchical state machines are well-occupied. Reflective runtimes are well-occupied. Their conjunction at L₀ — with the machine carrying its own structure — is the cell the structure points to and where production systems are still building toward.

P2

The durable statechart workflow

F=HSM · K=OR-hierarchical · C=distributed · I=process · R=event-driven · A=introspectable · T=L₁ · V=model-checked · τ=durable

A workflow engine whose unit of execution is a Harel statechart, not a graph of activities — depth, orthogonality, and broadcast all expressible, and the running state surviving across host restarts as a first-class promise.

› Why the structure implies it

Durable workflows and hierarchical state machines each occupy adjacent cells. The structure says the cell that holds both is reachable; the model-checked guarantee on the transitions is the predicted addition.

P3

The model-checked ECS

F=ECS · K=AND-parallel · C=parallel · I=encapsulated · R=event-driven · A=introspectable · T=L₁ · V=model-checked · τ=ephemeral

An entity-component system whose schedule and component invariants are model-checked, not only typed. Reads, writes, and ordering constraints are proven non-conflicting before the frame runs.

› Why the structure implies it

Typed ECS frameworks and model-checked concurrent systems are each well-occupied. The cell that holds an ECS with a checked schedule is sparse and consistent.

P4

The distributed behavior tree

F=behavior tree · K=OR-hierarchical · C=distributed · I=message-passing · R=reactive · A=introspectable · T=L₂ · V=invariant-tested · τ=checkpointed

Behavior trees run across hosts, with subtrees as independent actors and ticks as messages. The hierarchical decision tree spans a robot fleet rather than a single agent.

› Why the structure implies it

Single-process behavior trees and message-passing actor systems are each well-occupied. The cell where their composition holds — a tree that scales out without losing its decision semantics — is the predicted target.

P5

The dynamic-structure simulation at scale

F=DEVS · K=dynamic-structure · C=distributed · I=encapsulated · R=event-driven · A=runtime-modifiable · T=L₂ · V=invariant-tested · τ=snapshot

Discrete-event simulations whose model graph rebuilds itself in response to its own outputs — components added, removed, and recoupled while the simulation runs, at a scale that crosses many hosts.

› Why the structure implies it

Dynamic-structure DEVS exists in single-host form. Distributed simulation exists with static structure. The cell where both hold — runtime restructuring at scale — is the structural opening.

P6

The Petri-net game engine

F=Petri net · K=AND-parallel · C=parallel · I=encapsulated · R=continuous · A=introspectable · T=L₁ · V=model-checked · τ=ephemeral

A real-time engine whose synchronization and resource conflicts are stated as a Petri net and checked for reachability before the frame runs. Concurrency expressed in the formalism that was made for it.

› Why the structure implies it

Petri nets formalize concurrency, synchronization, and conflict; real-time engines need exactly those guarantees. The cell that ties the formalism to the substrate is open.

P7

The reflective actor system

F=actor · K=OR-hierarchical · C=distributed · I=process · R=event-driven · A=reflective · T=L₁ · V=invariant-tested · τ=durable

Actors that hold their own behavior as a value and can be rebuilt at runtime, with the supervisor tree as a first-class self-modeling object — the supervised graph itself an actor that observes and modifies its children.

› Why the structure implies it

Actor systems with hot code replacement exist. Reflective metamodels exist. The cell that joins them — the supervisor as a self-aware peer rather than a static authority — is the predicted addition.

P8

The π-calculus orchestrator

F=process calculus · K=dynamic-structure · C=distributed · I=message-passing · R=event-driven · A=introspectable · T=L₁ · V=model-checked · τ=checkpointed

An orchestration layer whose channels and process topology are stated in the π-calculus and verified for deadlock-freedom and mobility before deployment. Names that move between processes carry the right to communicate.

› Why the structure implies it

Modern orchestrators encode an implicit channel-and-process structure. The formalism that was designed for exactly that — mobility, scope, channel passing — does not yet sit under them. The cell is open.

P9

The TLA⁺-runtime-coupled machine

F=TLA+ · K=OR-hierarchical · C=distributed · I=process · R=event-driven · A=runtime-modifiable · T=L₂ · V=model-checked · τ=durable

A running system whose live execution is continuously checked against a TLA⁺ specification it carries with it — the spec is part of the running state, and a transition that would falsify the spec is refused.

› Why the structure implies it

TLA⁺ verifies specifications statically. Runtime monitoring verifies execution dynamically. The cell where the spec is itself a runtime artifact is sparse and well-flanked.

P10

The verified autonomic state machine

F=HSM · K=dynamic-structure · C=parallel · I=encapsulated · R=autonomic · A=reflective · T=L₀–L₁ · V=model-checked · τ=durable

A state machine that chooses its own next move from a model of itself and its environment, restructures its own composition in response, and carries a proof that no restructuring violates its safety invariants.

› Why the structure implies it

Autonomic systems, reflective runtimes, and model-checked machines each exist in separate cells. The structure says the cell where all three hold — an autonomic machine whose self-modification is proven safe — is the long-range target the genealogy is walking toward.

Go deeper

The full method.

The research note Watch the cascade