The Log is the Agent: Event-Sourced Reactive Graphs for Auditable, Forkable Agentic Systems

• URL: http://arxiv.org/abs/2605.21997v1
• Date: Thu, 21 May 2026 04:55:38 GMT
• Title: The Log is the Agent: Event-Sourced Reactive Graphs for Auditable, Forkable Agentic Systems
• Abstract summary: We describe ActiveGraph, a runtime that inverts the typical agent framework.<n>The append-only event log is the source of truth; the working graph is a deterministic projection of that log.<n>No component instructs another; coordination happens entirely through the shared graph.
• Score: 0.0
• License: http://arxiv.org/licenses/nonexclusive-distrib/1.0/
• 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.

Related papers

• Inference-Time Graph Engineering for Multi-Agent LLM Workflows [51.56038180639833]
  We introduce ReActNet, a training-free framework that compiles a query and a set of role-specialized agents into a sequence of directed communication graphs.<n>We show that ReActNet consistently improves over fixed-topology and learned-topology baselines while maintaining competitive inference cost.
  arXiv  Detail & Related papers  (2026-09-04T23:32:11Z)
• Graph-Based Agentic AI with LangGraph: Workflow Pathways for Long-Running Stateful Business Processes [0.0]
  We present three executable recipes to show how typed state, conditional routing, deterministic tools, retries, interrupts, checkpoints, and traces fit together.<n>LangGraph is positioned by workflow-complexity fit, not as a universal default.
  arXiv  Detail & Related papers  (2026-07-21T17:07:13Z)
• Memory is Reconstructed, Not Retrieved: Graph Memory for LLM Agents [51.30250860677378]
  We propose MRAgent, a framework that combines an associative memory graph with an active reconstruction mechanism.<n>Running on a Cue-Tag-Content graph, our active reconstruction mechanism integrates reasoning directly into memory access.<n>Experiments on the LoCoMo benchmark and LongMemEval benchmark demonstrate significant improvements over strong baselines.
  arXiv  Detail & Related papers  (2026-06-04T11:29:46Z)
• MemGraphRAG: Memory-based Multi-Agent System for Graph Retrieval-Augmented Generation [30.464508917946855]
  Graph-based RAG (GraphRAG) incorporates knowledge graphs to capture structural relationships.<n>Existing GraphRAG methods rely on isolated, fragment-level extraction for graph construction.<n>We propose MemGraphRAG, a novel framework that introduces a memory-based multi-agent system to ensure high-quality graph construction.
  arXiv  Detail & Related papers  (2026-05-30T08:18:53Z)
• GraphReAct: Reasoning and Acting for Multi-step Graph Inference [49.26607058250454]
  GraphReAct is a graph reasoning-acting framework that enables step-by-step inference over graph-structured data.<n>By interleaving reasoning with both retrieval and refinement actions, our framework enables a progressive transition from context expansion to compression.
  arXiv  Detail & Related papers  (2026-05-08T07:09:42Z)
• GraphBit: A Graph-based Agentic Framework for Non-Linear Agent Orchestration [34.588097323063074]
  GraphBit is an engine-orchestrated framework that defines explicitly and deterministically as a directed acyclic graph (DAG)<n>Unlike prompted orchestration, agents in GraphBit operate as typed functions, while a Rust-based engine governs routing, state transitions, and tool invocation, ensuring auditability.<n>A three-tier memory architecture consisting of ephemeral scratch space, structured state, and external connectors isolates context across stages, preventing cascading context that degrades reasoning in long-running pipelines.
  arXiv  Detail & Related papers  (2026-03-08T18:32:28Z)
• Memory Matters More: Event-Centric Memory as a Logic Map for Agent Searching and Reasoning [55.251697395358285]
  Large language models (LLMs) are increasingly deployed as intelligent agents that reason, plan, and interact with their environments.<n>To effectively scale to long-horizon scenarios, a key capability for such agents is a memory mechanism that can retain, organize, and retrieve past experiences.<n>We propose CompassMem, an event-centric memory framework inspired by Event Theory.
  arXiv  Detail & Related papers  (2026-01-08T08:44:07Z)
• Debugging Tabular Log as Dynamic Graphs [24.529035679332605]
  Tabular log abstracts objects and events in the real-world system and reports their updates to reflect the change of the system.<n>This paper proposes a new framework, GraphLog Debugger, to debug tabular log based on dynamic graphs.
  arXiv  Detail & Related papers  (2025-12-28T12:23:41Z)
• GraphCogent: Mitigating LLMs' Working Memory Constraints via Multi-Agent Collaboration in Complex Graph Understanding [13.356521655409422]
  Large language models (LLMs) show promising performance on small-scale graph reasoning tasks but fail when handling real-world graphs with complex queries.<n>We propose GraphCogent, a collaborative agent framework that decomposes graph reasoning into specialized cognitive processes: sense, buffer, and execute.
  arXiv  Detail & Related papers  (2025-08-17T14:28:38Z)
• You Don't Need Pre-built Graphs for RAG: Retrieval Augmented Generation with Adaptive Reasoning Structures [16.867592142212203]
  Large language models (LLMs) often suffer from hallucination, generating factually incorrect statements when handling questions beyond their knowledge.<n>Retrieval-augmented generation (RAG) addresses this by retrieving query-relevant contexts from knowledge bases to support LLM reasoning.<n>Existing Graph-based RAG methods rely on a costly process to transform the corpus into a graph, introducing overwhelming token cost and update latency.<n>We propose LogicRAG that dynamically extracts reasoning structures at inference time to guide adaptive retrieval without any pre-built graph.
  arXiv  Detail & Related papers  (2025-08-08T08:07:40Z)
• GraphRunner: A Multi-Stage Framework for Efficient and Accurate Graph-Based Retrieval [3.792463570467098]
  GraphRunner is a novel graph-based retrieval framework that operates in three distinct stages: planning, verification, and execution.<n>It significantly reduces reasoning errors and detects hallucinations before execution.<n>Our evaluation using the GRBench dataset shows that GraphRunner consistently outperforms existing approaches.
  arXiv  Detail & Related papers  (2025-07-11T18:10:01Z)
• Divide by Question, Conquer by Agent: SPLIT-RAG with Question-Driven Graph Partitioning [62.640169289390535]
  SPLIT-RAG is a multi-agent RAG framework that addresses the limitations with question-driven semantic graph partitioning and collaborative subgraph retrieval.<n>The innovative framework first create Semantic Partitioning of Linked Information, then use the Type-Specialized knowledge base to achieve Multi-Agent RAG.<n>The attribute-aware graph segmentation manages to divide knowledge graphs into semantically coherent subgraphs, ensuring subgraphs align with different query types.<n>A hierarchical merging module resolves inconsistencies across subgraph-derived answers through logical verifications.
  arXiv  Detail & Related papers  (2025-05-20T06:44:34Z)
• Schema-Guided Scene-Graph Reasoning based on Multi-Agent Large Language Model System [5.37125692728042]
  We propose an iterative-Guided Scene-Graph reasoning framework based on multi-agent Large Language Models (LLMs)<n>Two modules collaborate iteratively, enabling sequential reasoning and adaptive attention to graph information.<n>Our framework surpasses existing LLM-based approaches and baseline single-agent, tool-based Reason-while-Retrieve strategy in numerical Q&A and planning tasks.
  arXiv  Detail & Related papers  (2025-02-05T18:50:38Z)
• GLAD: Content-aware Dynamic Graphs For Log Anomaly Detection [49.9884374409624]
  GLAD is a Graph-based Log Anomaly Detection framework designed to detect anomalies in system logs. We introduce GLAD, a Graph-based Log Anomaly Detection framework designed to detect anomalies in system logs.
  arXiv  Detail & Related papers  (2023-09-12T04:21:30Z)
• Autoregressive Search Engines: Generating Substrings as Document Identifiers [53.0729058170278]
  Autoregressive language models are emerging as the de-facto standard for generating answers. Previous work has explored ways to partition the search space into hierarchical structures. In this work we propose an alternative that doesn't force any structure in the search space: using all ngrams in a passage as its possible identifiers.
  arXiv  Detail & Related papers  (2022-04-22T10:45:01Z)

This list is automatically generated from the titles and abstracts of the papers in this site.

This site does not guarantee the quality of this site (including all information) and is not responsible for any consequences.