ActiveGraph Runtime: Deterministic Agent Coordination

• ActiveGraph Runtime is a coordination substrate that uses an append-only event log and deterministic graph projection to drive agentic behaviors.
• It decomposes system functionality into an event log, reactive behaviors, and a pure function graph update to ensure deterministic state reconstruction.
• The architecture supports low-cost forking and comprehensive lineage tracking, enabling rapid counterfactual experiments and full auditability.

ActiveGraph Runtime is an event-sourced, graph-based coordination substrate for agentic systems, designed to provide deterministic replay, efficient forking, and full event-level auditability. In contrast to conventional agent frameworks centered on LLM loops and memory retrieval, ActiveGraph establishes an append-only event log as its fundamental source of truth. System state is derived exclusively by deterministic projection from this log, while all agent behaviors react to graph state—without direct imperative calls between modules. This approach enables end-to-end lineage of system artifacts, precise state reconstruction, and cheap run bifurcation, offering a substrate for fully auditable and forkable agentic workflows (Nakajima, 21 May 2026).

1. Architectural Foundations

ActiveGraph decomposes the agent runtime into three core layers:

• Event log ($L$): An append-only, totally ordered sequence $L = \langle e_1, e_2, ..., e_n \rangle$, where each event $e$ includes a monotonic identifier, type tag (e.g., "goal.created", "LLM.requested"), structured payload, actor, causal pointer ($\text{caused\_by}(e)$), and timestamp (for external auditing only).
• Deterministic graph projection ($G$): The working graph $G = (V, E, \tau_V, \tau_E)$ at time $t$ is the result of a pure function $\varphi$ folding over the event log prefix $L_{≤t}$; nodes and edges encode all application state, with types and payloads assigned by $\tau$.
• Reactive behaviors ($L = \langle e_1, e_2, ..., e_n \rangle$0): Behaviors are declared by subscription patterns over event types or graph queries, and implement deterministic function bodies $L = \langle e_1, e_2, ..., e_n \rangle$1. All behaviors are invoked reactively whenever new events affect relevant graph substructures.

Coordination is achieved solely via the shared graph; no component issues imperative commands to another.

2. Formal Model and Runtime Semantics

The runtime is specified by:

• Log definition: $L = \langle e_1, e_2, ..., e_n \rangle$2; strict event order is maintained.
• Graph projection: $L = \langle e_1, e_2, ..., e_n \rangle$3 defined by

$L = \langle e_1, e_2, ..., e_n \rangle$4

where each $L = \langle e_1, e_2, ..., e_n \rangle$5 encodes node/edge modifications as a pure transformation.

• Behavior dispatch: Each behavior $L = \langle e_1, e_2, ..., e_n \rangle$6 is a pure function of $L = \langle e_1, e_2, ..., e_n \rangle$7, emitting new events; subscription patterns determine when $L = \langle e_1, e_2, ..., e_n \rangle$8 is triggered.

The invariants enforced are:

• All state arises as a deterministic projection from the log;
• No behavior mutates global state or accesses nondeterministic sources outside the event log and graph;
• All model calls (LLMs, tools) are recorded as event/response pairs, ensuring determinism in replay.

3. Determinism and Replay Contract

ActiveGraph enforces a strict determinism contract:

• Purity requirement: All behaviors are pure, deterministic functions of their inputs (ΔG, trigger event). Forbidden constructs include:
  • Fresh randomness
  • Wall clock or nondeterministic I/O
  • Fresh UUIDs not generated by the deterministic id generator
  • Global mutable state external to the log/graph
• Model/tool call semantics: These are considered nondeterministic at execution but responses are persisted as events. Upon replay, the input hash retrieves the original output; no external call is made.

Guarantee: For fixed log $L = \langle e_1, e_2, ..., e_n \rangle$9, replaying via $e$0 and the prescribed behavior invocation order reconstructs $e$1 and all events in $e$2 exactly. Any deviation in output event at replay index $e$3 signals a non-determinism violation and halts execution. This makes full run determinism and byte-identical artifact regeneration practical and verified for every execution (Nakajima, 21 May 2026).

4. Event Handling and Runtime Algorithms

All event processing follows:

• Event appending and ID generation: Each new event receives a strictly monotonic id and is appended to $e$4.
• Graph update: The event’s mutation is applied via $e$5, updating nodes and/or edges accordingly.
• Behavior dispatch: Upon each event, corresponding behaviors are invoked precisely on matching event types or graph deltas, and may emit further events appended recursively.

Typical algorithmic structure:

$\text{caused\_by}(e)$3

Event-to-graph logic, behavior matching, and event emission are tightly constrained to preserve purity and replayability. Model calls are issued as events, and responses persisted, ensuring external nondeterminism is fully captured and made replayable.

5. Forking and Counterfactuals

ActiveGraph enables low-cost, causal forking of agent runs at any event boundary:

• Fork semantics: For $e$6, a fork at $e$7 produces $e$8, reusing the prefix literally.
• Fork procedure: The new run initializes $e$9 by replaying the shared prefix ($\text{caused\_by}(e)$0 time); all model/tool responses are replayed from cache, not re-issued. New events and states diverge from point $\text{caused\_by}(e)$1.
• Space and computational complexity: Only the divergent suffix incurs additional cost. Prefix events can be shared via copy-on-write if the log backend supports it.

This architecture supports rapid experimentation and ablation: entire counterfactual runs can be forked from any event boundary without expensive recomputation of shared state. Only new, divergent outputs require recomputation or I/O (Nakajima, 21 May 2026).

6. Lineage and Provenance Modeling

End-to-end artifact provenance is embedded at both node and relation levels:

• Object metadata: Each node carries its creating behavior id, the event id responsible, and optionally a full causal chain originating at initial model/tool calls.
• Edge metadata: Each edge retains the originating behavior and event id.
• Lineage graph relations: Canonical relation types include derived_from, addresses, supported_by, and created_at, enabling rich causal queries.

Typical lineage queries traverse from an artifact (e.g., final summary memo) back through assembled_from and created_at relations to recover every model invocation, evidence artifact, and intermediate behavior that contributed to its generation.

7. Illustrative Example: The Diligence Scenario

A concrete instance—agentic due diligence over three companies—demonstrates the full cycle:

• Initialization: Pack load and goal creation yield initial company node(s).
• Planner behavior: Reacts to goal.created, emits company.created.
• Research question generation: A behavior subscribes to new companies, producing associated research questions.
• Evidence and claim extraction: For each question, LLM calls and tool invocations are launched and persisted, with resulting claim nodes and derived_from/document_researcher relations.
• Contradiction detection and synthesis: Downstream behaviors perform consistency checks and memo assembly; LLM synthesis events are fully logged.
• Replay and forking: The entire 671-event sequence is re-executable; forking at an arbitrary event (e.g., to change question template at $\text{caused\_by}(e)$2) generates a variant run whose divergence can be structurally analyzed.

Lineage querying: Given any output node (e.g., the final memo), graph queries can enumerate all contributing model calls and artifacts:

$\text{caused\_by}(e)$4

All run products, intermediate states, and decision points remain traceable and auditable from the single source-of-truth event log (Nakajima, 21 May 2026).