State Runtime: the agent's world is an event-sourced belief log

1. Contribution / Thesis

Claimed. State Runtime models an agent's world-state as an event-sourced belief log rather than as chat history. Small, outcome-free events — assert, update, supersede, retract — are folded by a pure reducer into a belief state (state = reduce(events)). The design contribution is a discipline: answers are served from the reduced state, never from the raw transcript, and a fact that has been retracted or contradicted is never served confidently. Because the log is event-sourced, world-state is replayable and auditable — one can ask not only what the agent believes but why and since when. The note positions this log as the shared substrate beneath the clarification and skill runtimes: crystallizing a resolved decision is an assert, repeat-task pre-binding is a reduce over those asserts, and retraction forces a re-ask.

NOT claimed. This is an architecture/design note, not an empirical result. It does not claim any measured throughput, latency, accuracy, or generation-quality number — none are reported. It does not claim automatic extraction of high-quality belief events from arbitrary conversation; only the reducer is described as implemented, and conversation-to-event extraction quality is explicitly out of scope. It does not claim any validated scale behaviour for large belief logs, nor a novel algorithm — event sourcing and CQRS-style reduce-from-events are established patterns; the contribution is their application to agent world-state with a zero-false-confident serving discipline.

2. Design

The core abstraction is a fold over an append-only event stream:

state = reduce(events)

Event vocabulary (outcome-free — events record beliefs about the user's world, not task results):

Serving discipline: queries are answered from the reduced state, not the transcript. A retracted or contradicted fact is never served confidently (a zero-false-confident discipline applies directly).

Relation to the other runtimes (at a high level):

3. Evidence / Status

This note reports a design, not a benchmark. Status of each element, stated honestly:

• The reducer (state = reduce(events)) and the four-verb event vocabulary are described as the implemented substrate.
• Replayability / auditability follows structurally from append-only event sourcing.
• The integration with the clarification and skill runtimes is asserted as a design relationship; no measurement is recorded in the source.
• Conversation-to-event extraction is explicitly identified as a separate, unproven concern.

The note's evidenceLevel is carried forward as experimental; readers should treat that label as describing the engineering substrate rather than any quantitative experiment, since this note contains no measurements (see Limitations).

4. Limitations

A skeptical reviewer should note:

• No empirical evaluation. This note contains zero measurements — no sample size, no hardware, no oracle, no metric, no gate. It is a design description; its evidenceLevel: experimental is not backed by reported numbers in this note.
• Extraction quality unproven. The reducer being correct says nothing about whether good belief events can be extracted from arbitrary conversation. Garbage events reduce to a garbage-but-auditable state.
• Parity of structure is not quality of answers. Serving from reduced state guarantees a discipline, not that the underlying beliefs are right.
• Scale unvalidated. No data on reduce cost, log growth, or compaction for large belief logs.
• Conflict semantics underspecified here. The precise resolution rules for concurrent update/supersede on the same belief are not detailed in the source.
• Not novel as a mechanism. Event sourcing / fold-over-log is prior art; the contribution is the agent-memory framing and serving discipline, not the pattern itself.

5. Provenance / Relation

• Internal technical-report record, Octoryn Research, 2026. Author: Ran Tao.
• Substrate beneath the clarification and skill runtimes (crystallize = assert, pre-bind = reduce).
• Implementation: an ahead-of-time compiled native build targeting commodity consumer hardware, deliberately kept free of third-party machine-learning framework dependencies (numerical work delegated only to platform-native primitives).
• Build/run identifiers and version pins are not part of this design note (it specifies no build/run procedure).