Yohei Nakajima Unveils ActiveGraph Agent Runtime

Yohei Nakajima, known for his work on BabyAGI and his role as a VC at Untapped Capital, introduced his new open-source project, ActiveGraph, at the AI Engineer World's Fair. ActiveGraph is described as an experimental, event-sourced graph runtime designed to facilitate the creation of auditable AI agents. Nakajima highlighted a fundamental shift in agent development, moving from a model centered around the Large Language Model (LLM) to one that prioritizes the event log as the core component.

The Log as the Ground Truth

Nakajima's core thesis for ActiveGraph is to build agents around the log, not just the LLM. He explained that while traditional agent development typically starts with an LLM and adds tools, memory, and logging, ActiveGraph flips this by treating the immutable event log as the agent's ground truth. This log captures not only what the agent does but also every change made to it, providing a comprehensive and auditable history.

The system's architecture involves behaviors that react to changes in the graph, emitting events that in turn update the agent's state. These behaviors can be deterministic or incorporate LLMs. A key advantage, according to Nakajima, is that all LLMs within the system communicate through this shared state, creating a more unified and traceable operation.

Enabling Auditable Agents with Graphs

ActiveGraph introduces concepts like 'behaviors' and 'policies'. Behaviors are designed to react to graph changes, triggering actions or emitting new events. Policies, on the other hand, govern how the graph can be modified, allowing for controls such as requiring human review for critical changes like prompt edits or fact updates. This ensures a level of oversight and safety in agent operations.

The result of this approach is a typed, immutable event log that inherently provides capabilities for replays, rollbacks, and forks. Nakajima noted that this contrasts with the traditional LLM-centric approach where agents often need to be restarted from scratch if an error occurs, like an API key expiring. With ActiveGraph, the agent can simply resume from its last known state.

Experiments and Future Potential

Nakajima shared insights from several experiments conducted using ActiveGraph. One key finding was the effectiveness of using the structured log itself as memory, which, when combined with embeddings, performed well on the LongMemEval benchmark. He also demonstrated how various agent architectures, like the ReAct agent, can be built on top of ActiveGraph, showcasing its flexibility as a runtime.

The project also includes 'ActiveGraph packs,' which bundle object types, relationship types, behaviors, tools, prompts, and policies into modular units that can be combined to construct complex agents. Nakajima is exploring self-improvement loops, where agents can analyze their failures, propose modifications, and iterate towards better performance. He also highlighted the potential for AI to assist in architecting these agents, noting that AI seems adept at figuring out the intricate coding required.

Nakajima concluded by inviting the community to try ActiveGraph, emphasizing its potential for building more robust, auditable, and self-improving AI agents by fundamentally rethinking how their state and evolution are managed.