The paper proposes ActiveGraph, a runtime that treats an append‑only event log as the sole source of truth for an autonomous agent. Instead of building agents around a language‑model conversation loop and adding logging as an afterthought, ActiveGraph folds all agent state—goals, rules, tool calls, generated artifacts—into immutable events. A deterministic graph is projected from the log by replay, and behaviors react to graph‑shape patterns, emitting new events. The system enforces a determinism contract: behaviors must be pure functions of their inputs, while nondeterministic LLM calls are recorded and later served from a content‑addressed cache, making replay exact. This enables cheap forking at any event, allowing counterfactual “what‑if” analyses without re‑executing the shared prefix, and provides total lineage from high‑level goals to individual model calls. The paper details the architecture (events, objects, relations, behaviors, relation‑behaviors), the replay mechanism (strict vs permissive modes), the forking and structural‑diff primitive, and a worked diligence‑pack example that produces a fully reproducible log of 671 events, 93 objects, and 76 relations. It discusses how the substrate supports self‑improving agents via auditable self‑modification and cheap evaluation of alternatives, compares to existing memory‑layer and blackboard systems, and outlines limitations such as budget caps, replay cost, schema evolution, and distributed contention. The contribution is architectural: an event‑sourced, reactive graph substrate that yields deterministic replay, cheap counterfactual forks, and exhaustive provenance for long‑running agentic systems.
Topics
Inverting Agent Architecture: Log as Primary Substrate
The paper argues for treating the append‑only event log as the agent’s core representation, collapsing goals, rules, tool calls, and outputs into a single immutable stream.
Event‑Sourced Agent Model and Deterministic Graph Projection
Defines events, objects, relations, and behaviors; explains how the graph is a deterministic fold over the log, rebuilt by replay.
Determinism Contract and Content‑Addressed Cache for Replay
Specifies the contract that behaviors must be pure, and how nondeterministic LLM/tool calls are recorded with hash‑based caching to guarantee exact replay in strict mode.
Forking and Structural‑Diff Primitive for Counterfactual Analysis
Introduces cheap forking at any event, reusing the shared prefix from cache, and a structural diff that reports graph topology changes between parent and fork.
Worked Diligence Pack Example Demonstrating Full Lineage
Presents a reproducible investment‑diligence run that generates 671 events, 93 objects, and 76 relations, illustrating provenance from goal to memo.
Architectural Affordances for Self‑Improving Agents
Explores how the event‑sourced log enables auditable self‑modification, rollback, and cheap evaluation of behavior changes via fork‑and‑diff.
Comparison to Memory‑Layer and Blackboard Architectures
Positions ActiveGraph relative to systems like MemGPT, Zep, Mem0, Hindsight, and classic blackboard models, highlighting the inversion of memory vs log.
Limitations, Failure Modes, and Future Work
Enumerates practical constraints such as budget caps, replay cost, schema evolution, side‑effecting tools, and distributed ordering, and outlines next steps.