All Topics
All Topics
Technology
Technology
AI
AI
Business
Business
Entertainment
Entertainment
News
News
Programming
Programming
Security
Security
Science
Science
Design
Design
Environment
Environment
Finance
Finance
Crypto
Crypto
Politics
Politics
Sports
Sports
Education
Education
Gaming
Gaming
Art
Art
Music
Music
Health
Health
Books
Books
Food
Food
Travel
Travel
Personal
Personal
Bluesky
Twitter

ActiveGraph: An Event-Sourced Runtime for Auditable, Forkable Agentic Systems

By

[Submitted on 21 May 2026]

5h ago· 2 min readenInsight

Summary

ActiveGraph is a runtime architecture that inverts the typical agent framework design by making the append-only event log the source of truth, rather than bolting logging onto a language-model-first loop. The working graph is a deterministic projection of the event log, and behaviors (functions, classes, LLM routines) react to graph changes and emit new events — with no component directly instructing another. This yields three key properties: deterministic replay from the log, cheap forking of runs without re-executing shared prefixes, and end-to-end lineage from high-level goals to individual model calls. The paper presents the architecture, a determinism contract for sound replay, and a worked example whose causal structure is reconstructable from the log alone.

Source

Hacker NewsActiveGraph: An Event-Sourced Runtime for Auditable, Forkable Agentic Systemsarxiv.org

Key quotes

· 4 pulled
The append-only event log is the source of truth; the working graph is a deterministic projection of that log.
No component instructs another; coordination happens entirely through the shared graph.
This single design decision yields three properties that retrieval-and-summarization memory systems do not provide: deterministic replay of any run from its log, cheap forking that branches a run at any event without re-executing the shared prefix, and end-to-end lineage from a high-level goal down to the individual model call that produced each artifact.
Most agent frameworks are built around the language model: a conversation loop comes first, then tools, then rules, and finally a logging layer bolted on for observability, with state persisted as retrievable 'memory.'
Snippet from the RSS feed
Most agent frameworks are built around the language model: a conversation loop comes first, then tools, then rules, and finally a logging layer bolted on for observability, with state persisted as retrievable "memory." We describe ActiveGraph, a runtime t

You might also wanna read

Comments

Sign in to join the conversation.

No comments yet. Be the first.