The Log is the Agent: Event-Sourced Reactive Graphs for Auditable, Forkable Agentic Systems
Yohei Nakajima
Abstract
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 that inverts this arrangement. The append-only event log is the source of truth; the working graph is a deterministic projection of that log; and behaviors--ordinary functions, classes, LLM-backed routines, or logic attached to typed edges--react to changes in the graph and emit new events. 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. We present the architecture, a determinism contract that makes replay sound, and a worked diligence example whose full causal structure is reconstructable from the log alone. We discuss--without claiming to demonstrate--why this substrate is unusually well suited to self-improving agents, and how it extends the BabyAGI lineage and prior graph-memory research.
AI Impact Assessments
(1 models)Scientific Impact Assessment: "The Log is the Agent: Event-Sourced Reactive Graphs for Auditable, Forkable Agentic Systems"
1. Core Contribution
The paper proposes ActiveGraph, a runtime that inverts the conventional agent architecture by making the append-only event log the primary substrate rather than a byproduct. The key insight is that if all agent state—goals, rules, tool calls, LLM responses, produced artifacts—are events in a single ordered log, and the working graph is a deterministic projection (fold) of that log, then three valuable properties emerge naturally: deterministic replay, cheap forking at arbitrary points, and complete causal lineage. The coordination model replaces explicit orchestration with reactive behaviors that subscribe to graph-shape patterns and emit new events, drawing explicitly from blackboard architectures and event sourcing/CQRS patterns from data systems engineering.
2. Methodological Rigor
This is a systems/architecture paper, and the authors are commendably transparent about what they do and do not claim. There are no empirical performance benchmarks, no accuracy comparisons, and no user studies. The paper's "evidence" consists of:
The determinism mechanism is clever but has an important caveat the authors acknowledge: determinism applies only to *replay* of an existing log, not to original execution. The content-addressed cache for LLM/tool responses is the key enabler—essentially recording nondeterministic oracle responses so they can be replayed deterministically. This is sound engineering but not a novel theoretical contribution; it's standard memoization applied to a specific domain.
The paper's honesty about limitations—dynamic-only contract enforcement, no checkpointing for long-lived runs, unresolved concurrent/distributed writer issues, side-effecting tools—is a strength, but these limitations are also substantial. The lack of any concurrency model is a significant gap for production multi-agent systems.
3. Potential Impact
Practical applications: The architecture is genuinely well-suited for compliance-heavy domains (financial diligence, legal analysis, regulated industries) where auditability and reproducibility are requirements, not luxuries. The forking primitive for counterfactual analysis ("what if we'd changed the prompt at step 42?") is practically valuable for agent development and debugging.
Influence on agent frameworks: The paper articulates a clean conceptual inversion that could influence how future agent frameworks think about state management. The insight that "memory as projection of log" is superior to "memory as bolted-on retrieval layer" is compelling and could shift design patterns.
Self-improvement: The §7 discussion of self-improving agents is explicitly speculative and unevaluated, but the fork-and-diff primitive as an evaluation mechanism for proposed self-modifications is an interesting architectural affordance worth exploring.
Limitations to impact: Without empirical evidence that these properties translate to better agent performance, adoption will depend on whether practitioners value auditability enough to accept the overhead and constraints of the determinism contract.
4. Timeliness & Relevance
The paper addresses a genuine and growing pain point. As LLM agents move from demos to production, the inability to reproduce, audit, and debug agent runs becomes a critical blocker. The explosion of agent frameworks (LangChain, CrewAI, AutoGen, etc.) has highlighted the gap between "working demo" and "production-ready system," and auditability/reproducibility is squarely in that gap. The connection to the BabyAGI lineage (from the same author) provides useful continuity.
The timing is appropriate: the field is mature enough that architectural discipline matters, but young enough that foundational design patterns are still being established.
5. Strengths & Limitations
Key Strengths:
Notable Weaknesses:
6. Additional Observations
The paper reads more as an extended system description than a traditional research contribution. It is well-written and the figures are effective. The comparison to related work is fair but could be deeper—there's no discussion of deterministic simulation frameworks from distributed systems (e.g., FoundationDB's approach) or of provenance-tracking systems from the database community (e.g., PERM, GProM) that solve related problems.
The paper would benefit enormously from even modest empirical work: timing replay at different log sizes, measuring fork overhead, or demonstrating the debugging value of lineage on a real failure case.
Generated May 22, 2026
Comparison History (15)
Paper 1 addresses a timely, broadly relevant question about AI's impact on human skill development with empirical evidence from controlled experiments. Its findings on how AI usage intensity and informativeness affect learning have immediate implications for education, workforce training, and AI policy—topics of enormous current societal interest. The nuanced finding that AI can complement or substitute for human reasoning depending on context is novel and actionable. Paper 2 presents an interesting software architecture (ActiveGraph) for agentic systems, but it is more niche, lacks empirical validation of its claimed benefits, and primarily contributes to AI engineering rather than generating broadly impactful scientific insights.
Paper 1 is likely higher impact: it introduces a large, standardized, guaranteed-solvable benchmark (502 instances, 102 targets) for a high-value real-world domain (small-molecule drug design), directly enabling measurable progress and model comparison. Its methodological contribution (task design, multi-turn long-horizon setup, leaderboard, baseline results showing large headroom) is concrete and timely for LLM-for-science evaluation. Paper 2 is an interesting systems-architecture idea with broad applicability, but appears less empirically validated and closer to an engineering proposal, which may reduce near-term scientific uptake.
Paper 2 likely has higher scientific impact: it introduces a trillion-minute-scale foundation model trained on data from ~5M participants, evaluates across 35 clinically relevant tasks, and includes clinician-rated validation—indicating strong methodological rigor, timeliness, and clear real-world applicability in digital health. Its large-scale representation learning and label-efficient transfer can broadly influence biomedical ML, wearables, public health, and personalized medicine. Paper 1 is conceptually novel for agent system auditability/replay/forking, but appears more architectural with limited empirical validation and narrower immediate application scope.
Paper 1 offers a novel, general-purpose agent runtime architecture (event-sourced reactive graphs) with clear cross-cutting impact on reproducibility, auditing, safety/governance, and scalable agent engineering (deterministic replay, cheap forking, lineage). It is timely for agentic systems and could influence multiple fields (ML systems, HCI, software engineering, data provenance). Paper 2 is a narrower empirical case study with limited data and more incremental conclusions (LLM multimodal > acoustic-only for political pathos), reducing methodological strength and breadth despite practical relevance in computational social science.
Paper 2 has higher likely impact because it introduces a controlled, reproducible interactive benchmark (OSCE-style simulator) directly addressing a timely safety-critical gap: LLM performance under active evidence seeking for clinical decision support. It evaluates many models across hundreds of cases with quantitative findings and error analysis, making it immediately useful to the medical AI, evaluation, and safety communities and likely to shape subsequent benchmarking and deployment guidance. Paper 1 is conceptually novel for agent system architecture, but its impact is more speculative and depends on broader adoption and stronger empirical validation.
Paper 1 introduces a comprehensive benchmark with extensive empirical evaluation (23,375 task instances), quantitative findings on delegation behavior, and releases reusable artifacts enabling reproducible research on multi-agent orchestration. Its findings about routing fidelity and counterfactual delegation ceilings provide concrete, actionable insights for the community. Paper 2 presents an interesting architectural concept (event-sourced agent runtime) but is primarily a design paper that explicitly states it does not demonstrate its claimed benefits, limiting its immediate empirical impact. Benchmarks tend to have outsized community impact by enabling standardized comparison.
Paper 2 proposes a foundational architectural shift for LLM agents by applying event-sourcing, addressing critical AI bottlenecks like observability, reproducibility, and state management. This gives it immense breadth of impact across the rapidly growing AI engineering field. While Paper 1 is methodologically rigorous and offers highly practical advancements for 6G and UAV surveillance, its impact is confined to a specific telecommunications niche. Paper 2's potential to redefine how researchers build, debug, and scale autonomous agents makes it exceptionally timely and gives it broader potential scientific and industrial impact.
Paper 2 proposes a foundational architectural shift for agentic systems by introducing event-sourced reactive graphs. This paradigm offers novel theoretical properties like deterministic replay, cheap forking, and causal lineage, which are critical for debugging, auditing, and self-improving agents. While Paper 1 provides a highly practical and cost-effective optimization for deploying existing workflows, Paper 2's fundamental rethinking of state management and coordination is more likely to inspire broader methodological changes and future research across the field of autonomous agents.
Paper 1 proposes a concrete, systems-level runtime architecture (event-sourced reactive graphs) with clear, novel properties for agentic systems: deterministic replay, cheap forking, and end-to-end lineage. These enable immediate real-world applications in debugging, auditing, evaluation, compliance, and reproducibility, and can influence multiple areas (agent frameworks, MLOps/observability, workflow engines, and provenance). Paper 2 is timely and conceptually valuable for safety, but as a position paper it offers less methodological rigor and fewer directly actionable artifacts, making its near-term scientific and engineering impact likely lower.
Paper 1 proposes a fundamental paradigm shift in the architecture of AI agents, moving from LLM-centric loops to event-sourced reactive graphs. This addresses critical challenges in agent observability, determinism, and state management, offering broad applicability across AI safety, self-improving systems, and enterprise software. While Paper 2 provides a valuable formal mathematics benchmark, it represents an incremental contribution to a specific sub-field. Paper 1's architectural innovation has a much higher ceiling for widespread adoption and transformative impact across the broader AI and software engineering communities.
CAM-Bench addresses a clear gap in formal theorem-proving benchmarks by targeting computational and applied mathematics, an underrepresented domain. It provides a rigorous, large-scale benchmark (1,000 problems) with a validated pipeline, enabling reproducible evaluation of LLMs on applied math reasoning. This fills a concrete need in the AI-for-mathematics community and will likely drive research progress. Paper 2 describes an architectural proposal (ActiveGraph) for agent systems with interesting properties (replay, forking, lineage), but it is more of a position/design paper without demonstrated empirical results, limiting its immediate scientific impact.
Paper 2 offers a more novel and broadly applicable systems contribution: an event-sourced, deterministic, reactive-graph substrate for agentic computation with replay, forking, and full lineage. These properties address pressing needs (auditability, reproducibility, governance, debugging) across many domains and agent frameworks, making impact potentially wide and timely. Methodologically, it proposes a clear architectural principle plus a determinism contract, enabling rigorous evaluation via replay/fork tests. Paper 1 is valuable and application-forward but is narrower (VIS-app generation) and more dependent on benchmark-style validation, limiting cross-field substrate impact.
Paper 1 introduces a paradigm shift in AI agent architecture by applying event-sourcing to agentic systems. This novel approach addresses critical bottlenecks in current frameworks, such as auditability, determinism, and debugging. While Paper 2 provides a valuable benchmark for terminal tasks, benchmarks are often transient in their impact as models rapidly improve. In contrast, Paper 1 offers foundational design principles that could broadly influence the long-term development and deployment of robust, enterprise-ready AI agents across various domains.
Paper 1 demonstrates higher scientific impact through rigorous empirical validation including large-scale real-world deployment on Taobao with measurable improvements (+4.10% GMV, +3.52% ROI). It addresses a concrete, high-value problem in automated bidding with a novel explore-safeguard-select pipeline combining Decision Transformers, Q-value guidance, and inverse dynamics. Paper 2 presents an interesting architectural concept (event-sourced agent runtime) but is primarily a position/architecture paper without empirical demonstrations—the authors explicitly note they 'discuss without claiming to demonstrate' key claims. Paper 1's methodological rigor and proven industrial applicability give it stronger impact potential.
Paper 1 targets a timely, high-stakes problem (machine unlearning) with a novel extension to realistic multi-task/shared-backbone settings and proposes concrete, technically grounded methods (task-aware projection + instance-level orthogonalization) backed by quantitative benchmark gains. This combination of methodological rigor, clear evaluation, and direct applicability to privacy/compliance and model editing suggests strong scientific impact. Paper 2 is conceptually interesting for agent infrastructure (auditability, replay, forking) but reads more like a systems/architecture proposal with limited empirical validation and narrower methodological contribution, making near-term scientific impact less certain.