try this prompt: “analyze https://t.co/ufL9Ht0POv, the blog posts, etc to understand its claims, verify them, and write a review of the project ending with a final verdict paragraph.” https://t.co/wEQAKp90g7

activegraph — A persistent world for long-running agents

Source: https://activegraph.ai/ v1.0 · open sourceMIT · Python 3.11+

A persistent world for long-running agents.

A shared graph of beliefs, tasks, evidence, decisions, and dependencies — derived from an append-only event log. Replay, fork, and diff any run.

FromYohei Nakajima, creator of BabyAGI (2023). activegraph is the architectural answer that years of agent infrastructure work kept pointing toward.

relation_behavior

The differentiated primitive. Coordination logic lives on the edge, where the meaning is — not duplicated across every node that might emit a relevant event.

runtime.fork(at_event=…)

Branches the run. The shared prefix replays from cache. Forks don’t re-pay for LLM calls already made.

//Try it through your AI assistant

Paste this into Claude, ChatGPT, or your coding agent.

ActiveGraph is designed to be learned by agents as well as humans. The docs, quickstart, trace, and fork/diff primitives give an assistant enough structure to build something real in minutes — not just agent-legible infrastructure, but infrastructure that an agent can pick up and use.

Works with any agent that can read a webpage, install a pip package, and run Python.

//Agents need more than memory

The event log is the agent. The graph is its world.

ActiveGraph

Collapses these into one substrate: anappend-only event logprojected into a live graph. The graph is the agent’s world — what exists, what depends on what, what was produced, what was approved, what changed, and why.

Latest

• 2026-05-25paper The Log is the Agent: Event-Sourced Reactive Graphs for Auditable, Forkable Agentic Systems↗
• 2026-05-25announcement activegraph 1.0 — agents that coordinate through replayable state↗

All posts →

//Where it fits

Not another agent framework. The world beneath one.

Bring your model, tools, prompts, and workflows. ActiveGraph gives them durable state.

Workflows model computation. ActiveGraph models the world that computation acts on. Memory remembers conversations. ActiveGraph holds beliefs, evidence, contradictions, decisions, and their lineage.

ActiveGraph is where agent state becomes inspectable infrastructure.

1. Models Reasoning and generation
2. Tool frameworks Calling external systems
3. Workflows Sequencing work
4. Memory Retrieval and recall
5. ActiveGraphthis layer The shared world: objects, relations, events, lineage, replay, forks, diffs

//What you can build

Primitives the loop doesn’t give you.

Replay, fork, diff, lineage, edge logic — concrete things that become possible once the event log is the substrate, not a debugging artifact.

//Research basis

The Log is the Agent.

ActiveGraph is introduced inThe Log is the Agent: Event-Sourced Reactive Graphs for Auditable, Forkable Agentic Systems. The core claim: the event log should not be a debugging artifact. It should be the substrate the agent is built from. The graph is a deterministic projection of that log — replay, fork, diff, and end-to-end lineage fall out of the architecture, not an audit layer bolted on top.

Worked example

• 01Write a behavior. Save a run. Inspect it externally.
• 02Fork the run at any historical event. Diff the result against the parent.
• 03Explain where every object in the graph came from — the event, the behavior, the evidence, the LLM call.

Reproduce withactivegraph quickstart.

//Example · BabyAGI, rewritten

BabyAGI, as an active graph.

The original BabyAGI (Nakajima, 2023) was a while-true loop with three steps: execute the current task, summarize against the objective, generate follow-ups. State lived in a global list.

This rewrite expresses the same loop as reactive behaviors over a shared graph.The loop IS event propagation. The graph IS the state.Every step is a subscription, not a function call; the trace records every mutation and is queryable after the run.

It’s a download-and-run-it-yourself example in the OSS repo — not a bundled pack. Three behaviors:initializer→executor→task_creator, wired by events.

Three behaviors. The graph queues itself; the event log is the order; an empty follow-up list terminates the loop.