ActiveGraph

event-sourced graph runtime for long running agents

[ActiveGraph @ActiveGraphAI]

third @activegraphai paper is on arxiv!

“Replay is a Family of Assertions”
https://t.co/oEcN93csyr

first paper said replay + forking come free with event sourcing. this one checks that claim. short answer: "replay" is really four different promises, and forking an agent that already sent the email doesn't unsend it.

[Yohei @yoheinakajima]

came across new research that combines decision models like Jev with @activegraphai to build recommender systems

they turn user activity into a knowledge graph that agents use to propose candidates for the decision models to select from

ActiveGraph isn’t my most popular open source project, but I think it’s directionally the type of approach all agent builders should be exploring today

the most fun and inspiring thing about open source is collaborating w ppl you’ve never met to push tech forward :)

the paper: https://t.co/RHXLHOVjGI

[ActiveGraph @ActiveGraphAI]

fun fact: these “runs” all run through activegraph, making them replayable/inspectable

a great example of using activegraph to make research more reproducible

[Yohei @yoheinakajima]

in case you were curious if this generalizes... yes, as a packing method. not the best overall, but it finds packings other methods miss on squares and cubes. have some ideas, but not exactly sure why...

more: https://t.co/B3l7KvKs5q

[Yohei @yoheinakajima]

reintroducing untapped capital

new website (https://t.co/fxjwox6kdQ) and... music video 🙃🎙️🕺

[Yohei @yoheinakajima]

the design of https://t.co/sgYkt6hrEE grew out of a summer project, https://t.co/eUIDYZ37O5 (which i still need to write about), and runs on @activegraphai

the pattern across all three projects is that it treats the journey as the primary substrate, and the destination as a projection of it

[Yohei @yoheinakajima]

found a new @activegraphai citing in a new paper on graph engineering for llm agents ☺️

https://t.co/OAXQUKfnzq

"Graph Engineering in the Era of LLM Agents: From Individual Intelligence to System Intelligence"

[Granite @Granite0x]

🚨 STOP RE-RUNNING YOUR WHOLE AGENT TO TEST ONE CHANGE.

someone just open-sourced the fix. free

activegraph. 547 stars. one install.

install it - and your agent gets:

- fork a finished run at any step
- the shared part replays from cache - zero new model calls
- strict replay re-fires every step and fails on the first divergence
- an append-only log: what changed, when, and why
- policies hold an action until a human approves it

setup, 30 seconds:

pip install activegraph
activegraph quickstart

runs on recorded examples. no keys, no config, same output every time

save it before your next long run dies with no log to replay ↓

[Yohei @yoheinakajima]

[new @activegraphai blog post] How Synthetic Players used ActiveGraph to verify 4,919 runs without new model calls

https://t.co/9mbTvOD48N

For the increasing number of agentic academic papers, reproducibility, etc become valuable in strengthening your argument

This blog post walks through how we used ActiveGraph for this.

[Viksit Gaur @viksit]

there is a missing link between how humans and agents collaborate today. the atomic unit of focus is a "task". but there's no way to merge tasks together in a way that gives context over the entire "workstream".

@yoheinakajima's @ActiveGraphAI has the right model of an append only event log, but theres need for a different way to do projections.

ive been thinking about how to take an event stream and "fold" it into something that enables better human-agent collaboration.

[Corey J. Gallon @CoreyGallon]

Nine iterations of BabyAGI in three years, and yet the bit that @yoheinakajima kept coming back to was graphs. @aiDotEngineer published where that landed, "Active Graph Agent Runtime (BabyAGI 4)", on YouTube. The legend Yohei is Managing Partner at Untapped Capital.

The talk is a working argument for building an agent around an immutable event log instead of around the LLM, with code, reference agents, and experiment results behind it.

- The log is the agent. One immutable typed event log holds what the agent did and every change to the agent itself, and it projects the graph that is the agent's state.
- Behaviors replace the control loop. They react to graph changes and emit events. LLMs never talk to each other, only to shared state, so replay, rollback, and forking come natively.
- Policies decide what can change. Adding a research source is cheap. Editing a prompt can require a human. A new fact can require that nothing contradicts it.
- Views are context management as a graph query, Handing a behavior the subset of the graph it should see.
- Packs, not skills. Memory, identity, tools, secrets, chat: each bundles object types and behaviors, so you can swap one memory pack for another.
- A runtime, not a harness. He rebuilds ReAct on top of it. On goal created, add a thought. On thought created, run reason.
- The log doubles as memory. On LongMemEval, no fact or entity extraction, just embed the query and pull the messages around the hits. When his API key ran out at question 350, the run picked up at 353 instead of starting over.
- Self-modification with gates. Regimes classifies the failure, lets the agent edit only the matching part of itself, then requires a static check, a sandbox check, and a measured rerun before a patch is accepted. Loops of 8 to 13 accepted 4 or 5, with modest but statistically significant gains.
- It remembers what failed. Around 80 tuning passes on a deterministic Pokemon trading card agent for a Kaggle competition, 20 to 30 accepted, and everything that didn't work stayed on the record.
- Old architecture, new workers. Blackboard and Kafka have decades of writing behind them while LLM agents have three years, which is his hypothesis for why coding agents write this style well.

I'm working through the published talks from AI Engineer World's Fair sharing summaries and takeaways. Follow for more!

[Yohei @yoheinakajima]

my current @activegraphai inspired approach to a modular repo-centric agent operating system https://t.co/dRba7xv6ZE

[Shoopy @0xShoopy]

Yohei Nakajima, the creator of BabyAGI, just showed why he stopped building agents around the LLM.

His AIE talk on ActiveGraph, in 5 timestamps:

1:55 – build around the log, not the model
3:24 – behaviors and policies gate what the agent can change
8:12 – his api key died at question 350, the run resumed itself at 353
11:11 – a loop that forks the agent and keeps a patch only if accuracy rises
15:49 – why long-running agents need an experiential world model

The frame: make an immutable event log the agent, and replays, rollbacks and forks come for free.

Different way to think about agents. 17 min well spent.

[Ian @IanIsSoAwesome]

having an event stream like activegraph is the base of how we move to next level and that will probably be composition, which can let you achieve better results with smaller models.

- get the core event stream
- wrap things in a nice monad
- now you compose the models:
> main runner's stream
> add on a validator agent that checks specific user interaction and changes/obfuscates data
> parallelized tasks that run multiple agents at same time
> classifiers, mappers, tinkerers, translators

and some can be SOTA models, some can be super fast models, some can be local mini models.

and this way you can build highly complex and observable pipelines, "swarms" or "brains" for whatever you need. much more solid, reproducible and observable than your generic imperative orchestration.

[Piyush Katariya @ppkatariya]

Implemented Yohei Nakajima's paper on "ActiveGraph : Event-Sourced Reactive Graphs for Auditable, Forkable Agentic Systems"

Repo : https://t.co/aenMbUaDET

[Don Park @donpark]

I've long felt AI harnesses were trapped by our obsession with code so @yoheinakajima's ActiveGraph video hit me hard. Reminded me of time I obsessing over Linda space & case-based reasoning. Watch the video. It's very different.
https://t.co/iCSCifWdQp

[Yohei @yoheinakajima]

🆕 ActiveGraph: The Log is the Agent

my talk from AI Engineer is live!!! 😆
https://t.co/WP7INaH1kC

it's about @activegraphai, an event-sourced graph runtime for building durable long-running agents:

- what it is
- code examples
- experiments
- benefits & surprises

please check it out, share with your friends who like to tinker at the frontier, and let me know if you have any Qs!

[Yohei @yoheinakajima]

your hippocampus fast-captures events (logs) that are computed on to hold a current state, and through selective replays, pulls some of this slowly into the cortex (model), which then feeds new priors back into the computations

[Yohei @yoheinakajima]

continued working on @activegraphai reference packs last weekend, resulted in needing to harden the runtime:

it already could...

- keep a complete history of everything an agent did
- replay that history
- fork into alternate timelines to try different ideas

it can now...

- realize it's missing a capability
- write new code to add that capability
- test it in an isolated copy of itself
- ask a human to approve it
- safely adopt it
- continue running with the new capability

https://t.co/lKyeqizeTq

[Solomon Neas @solomonneas]

the other week i read active graph papers from @yoheinakajima and got inspired.

enough to rewire brigade, graphtrail, and miseledger around one habit: state is a projection of a log.

then i got a chance to read this yesterday and the same receipts turned out to be mineable. brigade now finds command sequences operators keep repeating, proposes runbooks from them, and pins each step's binary by sha256.

the whole loop: https://t.co/rfy23j3zCR

[Solomon Neas @solomonneas]

here it is: https://t.co/rfy23j3zCR

ended up as the three that close a loop: graphtrail diffs the code graph, the diff rides into brigade's run receipts, exports to miseledger as content-addressed evidence, and comes back as context for the next run.

one wrinkle: a single event log wasn't enough for the promotion ratchet, it needed the decision receipts as their own transition log.