ActiveGraph
The immutable event log is the agent — the graph is a deterministic projection re-computable by replay. By Yohei Nakajima, successor to BabyAGI. GitHub
What's Peculiar
- Orthogonal component: The append-only event log is primary state; the graph is a deterministic projection rebuilt by replaying the log. State has no independent existence — it is whatever replaying the log produces. Paper title says it directly: "The Log is the Agent" (arXiv:2605.21997).
- Fork-and-diff is a first-class primitive: branch a run at any historical event, replay the cached prefix, diff the two timelines. Time-travel debugging of an agent run is built in, not bolted on.
- Isolation boundary: Persistence/replay, not compute. The threat model is auditability and reproducibility — not sandboxing untrusted code. Event store is SQLite by default (Postgres optional).
- Multi-tenancy: Substrate, not framework — it sits beneath the model/tool/prompt layers rather than wrapping them. Determinism + content-addressed cache make a run independently re-derivable, which is the property a tenant boundary actually needs.
Orthogonal: the log is the agent
Most agent runtimes treat state as the thing and the log (if any) as a side-effect for observability. ActiveGraph inverts this. The immutable event log is the primary store; the graph you query is a deterministic projection re-computable by replaying that log from event zero. Nothing about the live graph is authoritative — replay reconstructs it bit-for-bit.
That single choice forces everything downstream:
- Behaviors propose patches, they don't mutate. A behavior emits a proposed patch with optimistic concurrency; the log is the arbiter of what actually committed. The graph is never written to directly.
- Replay must be deterministic, so model and tool responses are content-addressed — cached keyed on a hash of the request. Two replay modes follow: permissive serves the cached response; strict re-runs live and compares live-vs-recorded.
- Fork-and-diff falls out for free. Because state is a pure function of the log, you can fork at any event, reuse the cached prefix, and replay only the divergent tail — then diff the outcomes.
Relation-behaviors: logic on the edge
The second peculiar move: coordination logic lives on the relation between two objects, not on either endpoint. A relation-behavior subscribes to a graph pattern and fires when the pattern matches.
This is why there is no A2A protocol, no workflow engine, no DAG. Control flow is not authored — it emerges from behaviors subscribing to patterns in the graph. The graph changes, matching behaviors wake, they propose patches, the log records the result, the projection updates, new patterns match. The loop is the substrate, not a scheduler you configure.
Architecture
- Event store: SQLite default, Postgres optional. Append-only, immutable.
- Projection: the graph, deterministically rebuilt by log replay.
- Behaviors: subscribe to graph patterns; propose patches under optimistic concurrency; relation-behaviors carry coordination logic on edges.
- Cache: content-addressed model/tool responses keyed on request hash. Two replay modes — permissive (serve cached) and strict (live vs recorded).
- Fork-and-diff: branch at any historical event, replay with cached prefix.
Validated usefulness
Naming disambiguation
"ActiveGraph" collides with unrelated projects. This page is about the Nakajima event-sourced runtime only. It is not:
- AGENTiGraph — a different agent-graph paper, arXiv:2508.02999.
- Go
activegraph/activegraph — a GraphQL library.
- Ruby
neo4jrb/activegraph — a Neo4j ORM.
The Nakajima project is unambiguously called ActiveGraph; the name is shared, the substance is not.