The Log is the Agent - Reactive runtime for Agents
This is a very peek-into-the-future paper from Yohei Nakajima, the creator of BabyAGI, the *first* truly autonomous agent which went viral.
The title is dramatic. The idea is more interesting than the title.
At first glance, it seems to oversell the idea of the chat "logs" - all the inputs, outputs, tool calls etc that accumulate during a conversation with Agent.
Yet another graph memory paper bolted on to the LLM.
But that's not the point. What it says is that:
the activegraph is the single source of truth of everything that happened.
the harness, the imperative loop around the LLM isn't in there explicitly.
you can trace from any observation back to exactly what caused it, full details
if the conversation bumps into an error state, you can create alternative futures by branching and tweaking the prompt without replaying entire history. This isn’t natural to do now.
So what drives the agent?
Implicit reactive events.
tool call event -> append to state
output created -> update memory.
prompt updated -> fork and re-run
A declarative set of harness rules sit outside. There is no explicit orchestrator for your Agent - it is in the BIOS of activegraph. Works through implicit reactive events that follow the harness rules.
What's (or could be) cool about this?
Implicit reactive events run the system. Not an easy-to-complicate imperative harness loop. Any fix automatically triggers a deterministic cascade of correct downstream behaviors, rewriting the entire suffix of the graph purely through reactive dataflow.
Behaviors and rules are treated as data inside the log, you can append a
behavior.updatedorprompt.patchedevent mid-run.enables creating different "futures" with branching. and comparing the futures. Notice a bug? fork and run with the new prompt, reusing all the history.
all the provenance, what happened after what, is preserved. enables explicit, precise debugging.
Clearly, this creates a humungous graph. How does a human visualize it? The graph isn't a UI feature for humans to stare at; it's a data substrate for the agent.
Ask a query to the active graph: how did we arrive at fact X. and it slices through the graph to render the relevant history for you.
Because every object carries strict provenance, if a final report says, “We recommend avoiding this investment due to regulatory risk,” a UI wouldn’t show you the 700-node operational graph. It would isolate and render a single linear path showing only the nodes directly connected to that claim:
[User Goal] ➔ [Planner Behavior] ➔ [Research Question] ➔ [Document Source] ➔ [LLM Extraction] ➔ [Final Risk Claim]By filtering out the other 95% of the graph that didn’t contribute to this specific conclusion, the visualization becomes incredibly clean and auditable.
But the big graph needs compaction. Can't keep appending. If a run hits 1,000,000 events, replaying it from scratch every time would make the system crawl. This graph bloating is a key bottleneck and work in progress.
There is a GitHub implementation too. Not as popular as BabyAGI yet.
But I like the direction:
Traceability, Branching, and Memory are not three separate features here. They emerge from the same graph. Code (rules) and data (memory) live together.