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.
watch the AI Engineer talk — Active Graph Agent Runtime (BabyAGI 4)
From Yohei Nakajima, creator of BabyAGI (2023). activegraph is the architectural answer that years of agent infrastructure work kept pointing toward.
from activegraph import Graph, Runtime, behavior, relation_behavior
graph = Graph()
runtime = Runtime(graph, budget={"max_events": 200, "max_seconds": 60})
# Behaviors react to events and write back to the graph.
@behavior(name="planner", on=["goal.created"])
def planner(event, graph, ctx):
research = graph.add_object("task", {"title": "Research", "status": "open"})
memo = graph.add_object("task", {"title": "Draft memo", "status": "blocked"})
graph.add_relation(research.id, memo.id, "depends_on")
# Edges carry logic. This one knows how to unblock its target.
@relation_behavior(name="unblock", relation_type="depends_on", on=["task.completed"])
def unblock(relation, event, graph, ctx):
if event.payload["task_id"] == relation.source:
graph.patch_object(relation.target, {"status": "open"})
runtime.run_goal("Evaluate this idea")
runtime.print_trace()
# Fork the run at any historical event. The shared prefix
# replays from cache — no duplicate LLM calls.
fork = runtime.fork(at_event=4)
The differentiated primitive. Coordination logic lives on the edge, where the meaning is — not duplicated across every node that might emit a relevant 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
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.
Read https://docs.activegraph.ai/llms.txt
(and llms-full.txt if you need depth).
For more context, also open:
- https://github.com/yoheinakajima/activegraph-packs
- https://github.com/yoheinakajima/activegraph-lab
- https://github.com/yoheinakajima/regimes
Install the activegraph Python package.
Build and run a small experiment that shows why an
event-sourced reactive graph is useful.
Use fork/diff or replay if possible.
Explain what happened and what the trace proves.Point agents at llms.txt / llms-full.txt. Works with any agent that can read a webpage, install a pip package, and run Python.
// Agents need more than memory
Memory
Stores what an agent might want to recall.
Workflows
Define what should happen next.
Logs
Record what happened afterward.
ActiveGraph
Collapses these into one substrate: an append-only event log projected 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.
AI Engineer talk — Active Graph Agent Runtime (BabyAGI 4)↗
activegraph v1.10.0 — context-read tracing, cooperative drains↗
ActiveGraph 1.2.0 to 1.7.1: hardening the reference packs pulled the runtime forward↗
Active Graph v1.2.0: The Graph Projection Becomes Pluggable↗
ActiveGraph Packs: A Composable Assistant Substrate↗
I Built a Research Agent That Shows Its Work↗
Regimes: An Auditable, Held-Out Gated Improvement Loop Demonstrated on LongMemEval with ActiveGraph↗
// Where it fits
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.
// What you can build
Replay, fork, diff, lineage, edge logic — plus the post-v1.0 operator loop: sandboxed trials, promote gates, pluggable graph backends, and context-read traces. Concrete things that fall out once the event log is the substrate.
Every object, claim, decision, and tool result traces back to the event that created it.
Branch a run, try a change in isolation, and promote only what earns it — without destroying the parent lineage.
A depends_on, contradicts, supports, or blocks relation can carry behavior. Logic lives where the meaning is.
Swap the materialized graph store. In-memory by default; FalkorDB is the first external backend — native edges, Cypher push-down.
Run candidate packs and patches in isolated trials before they touch the shared world. Cross-pack interactions become expressible experiments.
Record which objects a behavior actually looked at. The read set is an event — replayable, exportable, fork-stable.
// Research basis
Two papers. Same substrate: the event log as source of truth, the graph as its deterministic projection — then controlled self-improvement as a first-class, replayable workflow instead of external scaffolding.
arXiv:2605.21997
The design argument: invert the usual agent framework so the append-only log is the source of truth. Replay, fork, diff, and end-to-end lineage fall out of the architecture — not an audit layer bolted on top.
arXiv:2606.10241
Controlled self-improvement as a first-class, replayable workflow instead of external scaffolding. Diagnose failing runs, route repairs, promote only through held-out gates — every step an event.
The site is its own proof. Research notes on this blog are drafted by the lab agent running on activegraph, then published through human editorial gates — each carrying an evidence-linked provenance trail.
// Ecosystem
activegraph is one repo in a small open-source constellation. The siblings are where the runtime gets exercised for real — and good additional context to hand an AI assistant.
~20 open packs, composed demo bundles, a demo server, and a React inspector. Multi-pack assistants with no central orchestrator.
Self-hosted research agent on activegraph, running in production. Crawls, proposes claims, drafts posts behind human gates.
Code for the Regimes paper: held-out-gated improvement loops as a first-class, replayable workflow on the runtime.
First external GraphStore backend — native edges and Cypher push-down, contributed outside the core maintainers.
// Learn
Interactive tutorials for activegraph — the persistent world for long-running agents. Start with the mental model, then build. Same model, tools, and prompts; durable, replayable state underneath.
Take the familiar LLM agent loop, see why it breaks, then refactor it into activegraph one substitution at a time. The core mental model, end to end.
~45 min · 11 lessons · Beginner → Intermediate
Build the research agent everyone has built — reason, search, observe — then watch it change on activegraph: full provenance, surfaced contradictions, and a forkable conclusion.
~50 min · 11 lessons · Intermediate
// Example · BabyAGI, rewritten
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.
git clone https://github.com/yoheinakajima/activegraph
cd activegraph && pip install -e .
export ANTHROPIC_API_KEY=...
python examples/babyagi.py "Plan a 3-day intro to Rust"@behavior(name="initializer", on=["goal.created"])
def initializer(event, graph, ctx):
goal = event.payload["goal"]
graph.add_object("task", {"title": f"Plan first step toward: {goal}",
"status": "pending"})
@llm_behavior(name="executor", on=["object.created"],
where={"object.type": "task"}, output_schema=TaskResult)
def executor(event, graph, ctx, llm_output: TaskResult):
task = event.payload["object"]
graph.patch_object(task["id"], {"status": "completed"})
graph.emit("task.executed", {"task_id": task["id"],
"result": llm_output.result})
@llm_behavior(name="task_creator", on=["task.executed"],
output_schema=NewTasks)
def task_creator(event, graph, ctx, llm_output: NewTasks):
for title in llm_output.tasks:
graph.add_object("task", {"title": title, "status": "pending"})Three behaviors. The graph queues itself; the event log is the order; an empty follow-up list terminates the loop.