The Emergent State Machine (ESM) is an architectural framework for deterministic, interpretable, governable decision systems.
It defines how systems transform observations into governed outcomes while preserving:
- transparency
- replayability
- auditability
- explicit control over decision authority
ESM organizes reasoning into discrete computational frames called turns.
Each turn:
- incorporates observations
- derives signals
- constructs a coherent state
- re-expresses that state in decision coordinates
- determines whether policy is authorized
- produces an outcome (action or no-op)
Environment / Domain
│
▼
Observations (o_t)
│
▼
Signals (S_t)
│
▼
Coherent State (x_t)
│
▼
Projection (y_t = P(x_t))
│
▼
Relevance Determination (g_t = G(y_t))
│
▼
Policy Evaluation (π)
│
▼
Outcome / Action (a_t)
│
▼
Control State Update (m_t)
│
└────────→ next Turn
Turn structure: T_t = (o_t, S_t, x_t, y_t, g_t, a_t, m_t)
Across time: T_0 → T_1 → T_2 → ...
Each turn forms a complete reasoning frame: state construction, evaluation, and outcome determination occur within the same unit of computation. This makes every state transition inspectable, replayable, and governable.
ESM enforces strict separation between:
- Measurement → signals from observations
- Interpretation → coherent state construction
- Relevance Determination → whether policy is authorized
- Authority → deterministic policy selection
This separation ensures:
- probabilistic or generative systems may assist interpretation,
- but cannot directly authorize outcomes.
Signals are organized into a fully resolved, internally consistent state representation.
This state contains all semantic content required for decision-making.
Projection re-expresses the coherent state in policy-relevant coordinates.
Projection introduces no new semantic content.
It is a structured re-representation of an already interpreted state.
Relevance determination defines:
- the authorization boundary for decision-making
It determines whether the current situation warrants policy evaluation, based on conditions defined over the projected state.
Relevance is not limited to threshold checks on individual signals. It may be defined over composite conditions, including relationships among signals and their evolution over time.
Policy is the exclusive source of authority.
All outcomes must be selected:
- deterministically
- explicitly
- under versioned rules
Modern AI and decision systems often entangle:
- interpretation
- decision authority
- generative output
This leads to systems that are:
- difficult to audit
- difficult to reproduce
- unsafe to evolve
- hard to govern
The Emergent State Machine addresses this by:
- making state construction explicit
- separating interpretation from authority
- enforcing a governed decision boundary
- enabling replayable system evolution
Behavior changes only through:
- explicit, versioned modification of architectural artifacts
This repository contains the canonical specification of the ESM architecture.
It defines:
- the execution model
- architectural invariants
- coherent state construction
- projection semantics
- relevance determination
- deterministic policy authority
- Instrumented Deterministic Evolution (IDE)
This repository does not contain application implementations.
The canonical Emergent State Machine architecture specification is located at:
The specification has been updated to align with the current architecture paper and governance framing.
This draft clarifies the architectural boundary between signals, projection, and authority, and reflects the current formulation of ESM as a framework for interpretable situational reasoning and controlled state mutation.
See ESM Spec v1.5.0: spec/esm_spec.md
For systems that require a deterministic and instrumented mutation boundary, the ESM architecture can be implemented using a Controlled Mutation Layer (CML).
A draft ESM Governance Framework is available for early review.
The document outlines how Emergent State Machine systems can remain inspectable, auditable, and operationally accountable as they evolve through structured state mutation and policy-driven decision loops.
This draft focuses on practical governance mechanisms, including:
- mutation boundaries
- policy traceability
- replayable decision history
- controlled system evolution
The framework is still evolving and community feedback is welcome.
See the draft here:
v1.7.0 — Authority Boundary Clarification & Deployment Readiness Read the Paper: PDF
This release refines the core semantics of the Emergent State Machine (ESM) architecture and strengthens its presentation as a deterministic framework for interpretable situational reasoning.
Key Updates Authority Boundary Clarified Policy is now consistently defined as the sole mechanism that produces outcomes when invoked. Interpretation (human or AI) contributes only through signals and projection; commitment occurs exclusively at the policy layer. Relevance Gating Semantics Tightened Relevance gating is more precisely articulated as the deterministic condition under which policy is invoked. Turns that do not meet gating conditions resolve explicitly as no-ops, without policy evaluation. Turn Outcome Consistency Every turn produces a well-defined outcome 𝑟 𝑡 r t
, including explicit no-op outcomes. This ensures a complete and auditable decision record across all turns. Figure Updates and Additions Core architectural diagrams have been updated for clarity and alignment with the refined terminology. New figures further illustrate projection, gating, and system flow. Improved Internal Consistency Terminology and phrasing have been aligned across sections to ensure consistency between formal definitions and narrative explanations. Summary
v1.7.0 strengthens the architectural integrity of ESM by making the decision boundary explicit and eliminating ambiguity around when and how outcomes are produced. The result is a clearer, more inspectable model of decision-making that is easier to implement, evaluate, and deploy.
v1.6.0 — Deterministic Decision Invocation & Structured Relevance Gating
Read the Paper: PDF
This release strengthens the architectural clarity of the Emergent State Machine by making explicit when decision-making is authorized, not just how decisions are produced.
It sharpens the role of relevance gating as a deterministic authorization layer over policy invocation, and clarifies the turn as a complete reasoning frame in which state construction, evaluation, and outcome determination occur together.
Key highlights:
Relevance gating formalized as deterministic authorization over policy invocation Clarification that gating operates over projected state, not individual signals Introduction of composite relevance conditions (patterns, relationships, temporal structure) Turn defined as a complete reasoning unit (no separation between state formation and decision) Stronger articulation of dual-layer determinism: both decisions and their invocation are governed
This version deepens the framework’s core guarantee: that both what decisions are made and when decisions are made are fully explicit, inspectable, and reproducible.
v1.5.0 — Interpretable Situational Reasoning & Projection Formalization
The latest version of the Emergent State Machine architecture sharpens its core contribution: making situational reasoning explicit, inspectable, and governable.
This release clarifies how systems move from raw observations to meaningful decisions by formalizing projection as an explicit transformation from measurable state into policy-relevant structure.
Key highlights:
- Projection defined as explicit coarse-graining into decision space
- Stronger framing of ESM as a system for situational reasoning
- Clearer articulation of the decision boundary (policy as authority)
- Continued emphasis on determinism, replayability, and auditability
This version represents the most complete and accessible articulation of the architecture to date.
v1.4.0 — Architectural Framework & Governance Boundary
This release formalizes the Emergent State Machine as an architectural framework for interpretable situational reasoning, with a clear and enforceable boundary between interpretation and authority.
Key advancements:
- Clarifies the architecture as Signal → State → Projection → Authority (CML)
- Establishes the governance boundary: only policy may authorize state mutation
- Refines the role of projection as explicit, inspectable coarse-graining into policy space
- Strengthens the framing of ESM as a decision system architecture, not a model or pipeline
This version represents the current canonical framing of ESM as a system for governed, auditable decision-making in complex environments.
v1.3.0 — Architectural Reframing & Interpretability Emphasis
This release transitions the language of ESM from a control-system framing toward a broader architectural interpretation of situational reasoning systems.
Key advancements:
- Reframes ESM as an architectural framework, not just a control loop
- Strengthens emphasis on interpretability, auditability, and governance
- Clarifies projection as the mechanism that makes situations visible, not predicted
- Refines narrative around human–AI collaboration at the decision boundary
This version bridges the earlier mathematical formulation and the current governance-oriented architecture.
v1.2.0 — Projection Clarity & Policy-Space Reasoning
This release sharpens the role of projection into policy space as a central architectural component.
Key advancements:
- Defines projection as explicit transformation into decision-relevant coordinates
- Distinguishes projection from prediction and inference
- Clarifies how policy operates over structured situational dimensions
- Strengthens the separation between state representation and decision logic
This version marks the point where projection becomes clearly identifiable as a novel architectural contribution.
v1.1.0 — Deterministic State-Space Formulation & IDE
This release introduces the formal structure of the ESM as a deterministic state-space system with explicit reasoning steps.
Key advancements:
- Defines the turn as the atomic unit of reasoning
- Formalizes the transformation chain: observations → signals → state → projection → action
- Introduces Instrumented Deterministic Evolution (IDE) as the mechanism for system change
- Establishes replayability, auditability, and failure localization as core properties
This version provides the first fully developed mathematical and architectural articulation of the system.
v1.0.0 — Initial Formalization of the ESM Architecture
This release represents the first complete formal draft of the Emergent State Machine architecture.
Key contributions:
- Establishes the turn-based reasoning loop
- Introduces signals, state vectors, and deterministic policy selection
- Frames the architecture as an alternative to opaque, model-centric decision systems
- Begins formalizing the relationship to control theory and state-space systems
This version provides the first end-to-end articulation of the system’s structure.
v0.9.1 — Foundational Architecture: Turn-Based Control
This release captures the earliest formal articulation of the Emergent State Machine as a turn-based control architecture.
Key contributions:
- Establishes the turn-based execution model
- Introduces explicit construction of state from signals
- Frames the problem of entangled interpretation and action in AI systems
- Motivates separation between descriptive reasoning and authoritative decision-making
While later versions refine layering and governance boundaries, this release contains the core insight: making the construction of state from signals explicit as the foundation of interpretable decision systems.
Design narrative describing how the Emergent State Machine architecture emerged.
The Digital Learning Companion (DLC) is one implementation of the ESM pattern:
Additional implementations are welcome.
If you reference the Emergent State Machine architecture in research or technical work, please cite:
Emergent State Machine (ESM) Architectural Specification v1.0.0
Emergent State Machine Project
https://github.com/emergent-state-machine/esm-spec
If you are building systems that require:
- deterministic authority boundaries
- explicit policy control
- structured ambiguity handling
- safe, versioned evolution
We invite collaboration and discussion.