WEBVTT

NOTE Sentence-level transcript of https://www.youtube.com/watch?v=khVX_BUnEwU

NOTE One cue per sentence. Cue ids are the line anchors on /transcripts/khVX_BUnEwU.html. A cue ends where the next begins, or 2 s after its last word.

s1
00:00:01.309 --> 00:00:03.309
[music]

s2
00:00:12.440 --> 00:00:13.640
Hi everybody.

s3
00:00:13.640 --> 00:00:14.560
Thanks for coming.

s4
00:00:14.560 --> 00:00:16.240
I'm excited to be here.

s5
00:00:16.240 --> 00:00:19.960
AI engineer warfare has been so fun meeting everybody.

s6
00:00:19.960 --> 00:00:29.680
Um, but I'm here to talk about active graph, which is my new open-source experimental approach to building agents, which looks a little bit different than maybe you've been building agents.

s7
00:00:29.680 --> 00:00:31.000
Uh, it's definitely experimental.

s8
00:00:31.000 --> 00:00:36.040
The idea is more to give you inspire you with some potentially new ideas.

s9
00:00:36.040 --> 00:00:39.200
Um, agents are awesome, but long-running agents break.

s10
00:00:39.200 --> 00:00:41.960
And if they're so awesome, why am I still building them?

s11
00:00:41.960 --> 00:00:44.320
Why they should build themselves.

s12
00:00:44.320 --> 00:00:53.160
Let's build the simplest thing that can build itself has basically been kind of my research theme for the last 3 years since I did baby AGI back in March of 2023.

s13
00:00:53.160 --> 00:00:55.600
So that's over 3 years ago.

s14
00:00:55.600 --> 00:00:57.160
If you were there at the time, it was crazy.

s15
00:00:57.160 --> 00:01:00.080
It went wild like it was covered by media.

s16
00:01:00.080 --> 00:01:01.160
People thought it was going to work.

s17
00:01:01.160 --> 00:01:02.760
It didn't work at all.

s18
00:01:02.760 --> 00:01:03.535
Um,

s19
00:01:03.535 --> 00:01:04.000
[laughter]

s20
00:01:04.000 --> 00:01:12.680
Uh, over the course of 3 years I've done nine iterations of baby AGI with less fanfare, but you know, every time just experimenting on like how do we get autonomous agents to actually work?

s21
00:01:12.680 --> 00:01:14.760
Usually with the theme of self-improvement.

s22
00:01:14.760 --> 00:01:18.440
Uh, if you go to baby AGI wiki, you can see earlier experiments.

s23
00:01:18.440 --> 00:01:23.160
Um, in the in this process I kept coming up to coming back to graphs and I've had a couple of projects.

s24
00:01:23.160 --> 00:01:25.440
Earlier I did a one called Instagraph and Mindgraph.

s25
00:01:25.440 --> 00:01:27.800
That was like pre-graph rag rag.

s26
00:01:27.800 --> 00:01:30.640
I did some code graphs, function graphs, log graphs.

s27
00:01:30.640 --> 00:01:35.600
And since then it seems like a lot of people have started using graphs to build agents.

s28
00:01:35.600 --> 00:01:46.760
Um, and so and in addition to that I've actually gotten to invest in a in a good number of, you know, agentic companies, some of which you I'm sure you'll recognize through my funds Untapped Capital and I also have an agent fund.

s29
00:01:46.760 --> 00:01:48.840
Uh, but yeah, that's that's me.

s30
00:01:48.840 --> 00:01:51.080
Yohei, VC by day, builder by night.

s31
00:01:51.080 --> 00:01:53.920
You might recognize this face more than this face.

s32
00:01:53.920 --> 00:02:00.880
Um, ActiveGraph is an event-sourced graph runtime for building auditable agents.

s33
00:02:00.880 --> 00:02:06.920
I have a paper that was my first archive paper called the log is the agent, but I'm here to explain it.

s34
00:02:06.920 --> 00:02:08.880
So today most people build agents around the LLM.

s35
00:02:08.880 --> 00:02:22.880
You start with the LLM, you add a response API, you give it tools, you add memory, and then you make sure you log everything correctly, which can give you you know all the benefits that ActiveGraph will give you, but ActiveGraph asks, what if you build around the log?

s36
00:02:22.880 --> 00:02:24.360
Now what does that mean?

s37
00:02:24.360 --> 00:02:31.800
Um means not everything the agent does, but more importantly, every change to the agent, right?

s38
00:02:31.800 --> 00:02:37.160
Nobody here is using the same agent they were using a year ago, and the agent you're going to use a year from now is going to be different.

s39
00:02:37.160 --> 00:02:45.400
And a lot of people, what the agent does and how the agent changes are tracked in two different places, but I'm saying let's flatten that down into a single immutable

s40
00:02:45.400 --> 00:02:48.920
event log, and this is the ground truth of the agent.

s41
00:02:48.920 --> 00:02:50.680
And this projects a sort of graph.

s42
00:02:50.680 --> 00:02:52.240
This is the state of the agent.

s43
00:02:52.240 --> 00:03:00.680
And what I mean by that is, for example, a prompt can be edited multiple times, but you might have, you know, a master prompt that gets used when you're, you know, when you query the graph.

s44
00:03:00.680 --> 00:03:04.200
And then on top of this, you attach something that I'm calling behaviors.

s45
00:03:04.200 --> 00:03:08.840
Behaviors are reacts to graph changes.

s46
00:03:08.840 --> 00:03:17.440
And then they emit events, which then in turn updates the state of the agent, which might trigger new behaviors.

s47
00:03:17.440 --> 00:03:20.560
Um LLMs don't talk to each other in ActiveGraph.

s48
00:03:20.560 --> 00:03:24.840
They all communicate through this shared state, and that's what makes it a little bit different.

s49
00:03:24.840 --> 00:03:30.600
Behaviors can be deterministic, or they can include LLMs, which is which is how you build this agent.

s50
00:03:30.600 --> 00:03:41.120
And you get this beautiful typed event log, uh that's the source of truth about everything the agent did and everything every change that's happened, which means Oh, actually, well, shoot, I I jumped ahead.

s51
00:03:41.120 --> 00:03:45.519
So in addition to that, there's a concept called policies, which determine how the graph can be modified.

s52
00:03:45.519 --> 00:03:53.440
I'll come back to it, but for example, things like a source article that you found in research, you might be fine with adding, but if you're changing a prompt, maybe you want human in the loop.

s53
00:03:53.440 --> 00:03:57.040
Or if you're changing a fact, you might want to make sure there's no contradicting facts.

s54
00:03:57.040 --> 00:04:01.160
So there's these thing called policies and again, I'll show you some code you code examples.

s55
00:04:01.160 --> 00:04:07.080
But yeah, in the end you get this beautiful typed event log, which gives you replays.

s56
00:04:07.080 --> 00:04:10.920
It gives you rollbacks and it gives you forks.

s57
00:04:10.920 --> 00:04:15.080
And this becomes natively when you start building agents with ActiveGraph.

s58
00:04:15.080 --> 00:04:21.519
So this is the kind of LLM-centric versus log-centric way of building agents that I'm going to be talking about or showing you code for.

s59
00:04:21.519 --> 00:04:24.360
And and again, I'll specify that this is not a harness.

s60
00:04:24.360 --> 00:04:29.000
It's it's a runtime and you can actually rebuild most of the common harnesses on top of it.

s61
00:04:29.000 --> 00:04:33.793
You're just forcing every single communication to communicate through the shared state.

s62
00:04:33.793 --> 00:04:34.520
[snorts]

s63
00:04:34.520 --> 00:04:36.320
So at the highest level, right?

s64
00:04:36.320 --> 00:04:41.919
When you're building with agents, messages feels like the kind of core unit that you're seeing often, but we're going to replace that with logs.

s65
00:04:41.919 --> 00:04:44.040
Logs are going to be the core unit you're going to build around.

s66
00:04:44.040 --> 00:04:46.893
That's what you're going to be reading, that's what you're going to be looking at.

s67
00:04:46.893 --> 00:04:46.919
[snorts]

s68
00:04:46.919 --> 00:04:50.800
These are typed logs, again, immutable, clean.

s69
00:04:50.800 --> 00:04:51.880
You can't edit the graph.

s70
00:04:51.880 --> 00:04:53.160
These are just kind of basic rules.

s71
00:04:53.160 --> 00:04:54.000
Just emit events.

s72
00:04:54.000 --> 00:04:56.919
You can have the add object, which is an event emitting.

s73
00:04:56.919 --> 00:04:58.680
But yes, you can query over the graph.

s74
00:04:58.680 --> 00:05:03.960
And again, I'm I'm flying through some of this cuz I want to get to the fun parts and all this is in the documentation.

s75
00:05:03.960 --> 00:05:05.960
Behaviors listen to graph changes and emit events.

s76
00:05:05.960 --> 00:05:11.400
So this is a behavior called a planner that triggers on a goal created, right?

s77
00:05:11.400 --> 00:05:17.919
And then it adds an object to adds two task objects and a relationship object, a research, write memo, two tasks.

s78
00:05:17.919 --> 00:05:22.560
And then actually behaviors can actually live on edges as a something called relation behavior.

s79
00:05:22.560 --> 00:05:24.400
This one has an unblock relation.

s80
00:05:24.400 --> 00:05:28.080
So basically, when the research is done, you can write the memo, right?

s81
00:05:28.080 --> 00:05:31.560
Um And behavior subscriptions can be pretty complex.

s82
00:05:31.560 --> 00:05:32.720
They can be graph queries.

s83
00:05:32.720 --> 00:05:42.720
So this one says on object created, if the if the object type is a claim, and this claim contradicts another claim, we're going to trigger the contradiction detector.

s84
00:05:42.720 --> 00:05:44.600
And these can be more complex than this.

s85
00:05:44.600 --> 00:05:53.440
It can have, you know, uh confidence percentages baked into it um and and then on top of that, there's another concept called views.

s86
00:05:53.440 --> 00:05:58.200
Uh context management can be done programmatically as basically a graph query.

s87
00:05:58.200 --> 00:06:02.720
It's a It's You basically grab a subset of the graph, which makes it available to that behavior.

s88
00:06:02.720 --> 00:06:10.520
You can still do other types of context uh context management, but I felt like this kind of graph query as context management just felt really elegant.

s89
00:06:10.520 --> 00:06:16.560
Candidly, I'm not the one writing the code, but AI seems to be pretty good at figuring out how to do it.

s90
00:06:16.720 --> 00:06:22.120
Um and you know, I earlier I talked about policies, so some graph changes require a proposed patch before approval.

s91
00:06:22.120 --> 00:06:31.680
Again, this is how you these these policies kind of give it the control on what it's allowed to change by itself, what uh what kind of changes require certain tests,

s92
00:06:31.680 --> 00:06:34.919
um and I'll give a few examples in a bit, um or if you want human in the loop, right?

s93
00:06:34.919 --> 00:06:42.640
And you have these kind of policies that that determine or define uh what the uh what these rules are.

s94
00:06:42.640 --> 00:06:51.919
And when you bring it all together, you got these kind of object schemas, tools, deterministic LLM behaviors can be assembled into a something called a pack, right?

s95
00:06:51.919 --> 00:06:53.120
With a pack policy.

s96
00:06:53.120 --> 00:06:55.960
And that's how you build Harness on top of ActoGraph.

s97
00:06:55.960 --> 00:07:03.720
These And all of this together is and I'll have a couple examples later um are are modular and they can be combined, uh but you're not just adding skills.

s98
00:07:03.720 --> 00:07:06.480
It is much more complex about actually pretty unintuitive.

s99
00:07:06.480 --> 00:07:12.919
I would never write code myself with ActoGraph, but again, AI seems really good at it.

s100
00:07:12.919 --> 00:07:15.000
Um and just on like event types are fixed.

s101
00:07:15.000 --> 00:07:17.160
You can add custom events, objects are user-defined.

s102
00:07:17.160 --> 00:07:22.440
I only added that cuz someone asked me that question when I was showing them these slides, but think that makes sense.

s103
00:07:22.440 --> 00:07:25.280
So, the old way, you got the while not done if loop.

s104
00:07:25.280 --> 00:07:30.919
The new way, or at least my new way, uh you have a whole bunch of behaviors that don't talk to each other, that just monitor the state.

s105
00:07:30.919 --> 00:07:40.040
So, it's it's it's inspired by uh blackboard architecture from the '70s or '80s or more recently Kafka, whole bunch of micro workers communicating through a shared state.

s106
00:07:40.040 --> 00:07:46.720
One of the challenges, at least back when uh blackboard was was that it was really unintuitive to write, and the workers were very slim and deterministic.

s107
00:07:46.720 --> 00:07:53.040
But now, AI writes the code, and the workers can be very powerful because they have reasoning capability.

s108
00:07:53.040 --> 00:07:55.400
This is a React agent on Auto graph.

s109
00:07:55.400 --> 00:07:58.680
React agent was one of the earlier agent kind of architectures.

s110
00:07:58.680 --> 00:08:04.240
As you can see, it's it look it actually works the same way, but on goal created, you add a thought.

s111
00:08:04.240 --> 00:08:06.320
On thought created, you trigger the reason function.

s112
00:08:06.320 --> 00:08:09.560
So again, this is just to show that you can build any harness on top of Auto graph.

s113
00:08:09.560 --> 00:08:13.875
It does look different um because they're not communicating with each other.

s114
00:08:13.875 --> 00:08:13.960
[snorts]

s115
00:08:13.960 --> 00:08:18.240
And so, to see if how well this can work, I've been running a lot of experiments.

s116
00:08:18.240 --> 00:08:21.040
Um the first one I did was can I use the log itself as memory?

s117
00:08:21.040 --> 00:08:22.560
So this is not pure vector rag.

s118
00:08:22.560 --> 00:08:31.560
It's actually leveraging the structured log, so it knows which which message was before what, plus uh vec uh plus embedding the actual messages within the log.

s119
00:08:31.560 --> 00:08:33.640
Uh I did this on long mem eval.

s120
00:08:33.640 --> 00:08:35.280
I embedded the query.

s121
00:08:35.280 --> 00:08:47.200
There was no semantic uh ingestion, no fact extraction, no entity extraction, but I just embedded the query, looked for relevant messages, grabbed a couple messages before and after, made sure it fit into the context,

s122
00:08:47.200 --> 00:08:51.000
and it actually did pretty well on long mem eval, right?

s123
00:08:51.000 --> 00:08:55.640
Like a lot of the data in your memory is actually overlaps with the memory uh the data in your log.

s124
00:08:55.640 --> 00:08:59.680
Actually having them the same actually kind of makes sense and makes sure they don't separate.

s125
00:08:59.680 --> 00:09:03.920
Um I did try another couple other experiments on adding kind of semantic ingestion to improve the score.

s126
00:09:03.920 --> 00:09:10.360
Was able to do it, but candidly, um I could put more effort into try to increase that, but I jumped onto the next experiment.

s127
00:09:10.360 --> 00:09:16.680
Actually, but in that process, one of the biggest fun surprises was, I don't know if you've run long mem eval, but you have to like 500 questions.

s128
00:09:16.680 --> 00:09:20.360
And then one of the runs, uh my API key ran out like 350.

s129
00:09:20.360 --> 00:09:21.440
I was like, "Oh Okay."

s130
00:09:21.440 --> 00:09:24.760
So I updated the API key, said, "Okay, let's let's rerun it again."

s131
00:09:24.760 --> 00:09:30.480
And it just like rolled back one and was like, "All right, we'll just start from, you know, question number 353."

s132
00:09:30.480 --> 00:09:37.360
And I don't know if you have, but like I've built a lot of agents that like where the API key did broke or something, and I had to rerun the long agent from the beginning.

s133
00:09:37.360 --> 00:09:43.440
and that just has not been my experience since building with ActiveGraph, uh which was a very fun surprise.

s134
00:09:43.480 --> 00:09:45.760
Uh I built a couple reference agents, uh right?

s135
00:09:45.760 --> 00:09:47.880
Like now I have this runtime, let's see what I can build.

s136
00:09:47.880 --> 00:09:55.040
I asked Replit to build a coding agent on top of ActiveGraph and and as a result it came with, you know, a event log graph.

s137
00:09:55.040 --> 00:09:58.080
And again, I'll say this, you can do this with, you know, things like LangSmith.

s138
00:09:58.080 --> 00:09:59.760
Thing is, I don't know I didn't have to think about it.

s139
00:09:59.760 --> 00:10:05.400
I just had to ask my coding agent to use ActiveGraph and this event log and graph came natively.

s140
00:10:05.400 --> 00:10:07.480
Same thing with research agent.

s141
00:10:07.480 --> 00:10:18.360
I just had just build a deep research agent on ActiveGraph and it came with this beautiful, you know, had a event event log and a graph of like where the evidence came from, what contradict to each other.

s142
00:10:18.360 --> 00:10:20.240
And again, I didn't have to think about it.

s143
00:10:20.240 --> 00:10:26.187
I just asked my agent to build a research agent on top of ActiveGraph and this is what it ended up looking like.

s144
00:10:26.187 --> 00:10:26.200
[snorts]

s145
00:10:26.200 --> 00:10:30.240
Um and then I realized, okay, how do we get this closer to like an open claw or Hermes?

s146
00:10:30.240 --> 00:10:40.240
So I I played around, I have this thing called uh ActiveGraph packs, which is a core pack, a tool pack, a secret pack, a memory pack, an identity pack, a communication

s147
00:10:40.240 --> 00:10:41.200
pack, a chat pack.

s148
00:10:41.200 --> 00:10:45.680
So now you kind of get the idea of how I'm trying to build agents on top of ActiveGraph.

s149
00:10:45.680 --> 00:10:49.000
And each of these packs have object types and behaviors.

s150
00:10:49.000 --> 00:10:55.280
Again, feel probably feels very different from the way you're building agents, but I I I feel like it's actually pretty elegant.

s151
00:10:55.280 --> 00:10:59.240
You can just take a memory pack and replace it with another another memory pack, right?

s152
00:10:59.240 --> 00:11:05.920
Um uh uh and and it's not like skills, but like the objects and the rules and all of them are uh bundled as a pack.

s153
00:11:05.920 --> 00:11:10.640
And you and you attach these packs together to create your agent.

s154
00:11:10.839 --> 00:11:15.920
Um and then I jumped into the the what I really wanted to do was start playing with self-improvement loops.

s155
00:11:15.920 --> 00:11:17.480
Um I did a project called Regimes.

s156
00:11:17.480 --> 00:11:20.240
I did uh uh that was in paper number two.

s157
00:11:20.240 --> 00:11:23.960
Um This one you was a really controlled self-modification.

s158
00:11:23.960 --> 00:11:33.440
Uh Claude Code called it Regime de Scene, but basically we classified the type of failure and then based on the failure it classified it was a it was allowed to edit a specific part of the agent.

s159
00:11:33.440 --> 00:11:35.400
Again, I did this on long mem eval.

s160
00:11:35.400 --> 00:11:48.040
The loop was I think doing about 20 questions, looking at the answering questions, seeing where it failed, trying to self-modify, trying that on 50 different questions, see if the accuracy actually went up, and only if it went up, it would accept it.

s161
00:11:48.040 --> 00:11:54.640
So, that was kind of the proposal patch that started happening, where it would do after it proposed change to itself, right?

s162
00:11:54.640 --> 00:12:05.080
This is essentially the agent forking itself, proposing a change, doing a static gate check, a sandbox gate check, and then making sure it actually impacted the result, and only then accepted a change.

s163
00:12:05.080 --> 00:12:10.480
And for these loops, it would loop like eight or 13 times, but only accept four or five of those patches.

s164
00:12:10.480 --> 00:12:17.080
And it actually did have, you know, modest, but like statistically significant improvement on long mem eval scores.

s165
00:12:17.080 --> 00:12:21.560
Uh and and not only did it know what worked, but it also knew what didn't work.

s166
00:12:21.560 --> 00:12:26.200
Um at this point I was like, "Okay, can I can I get active graph to just research active graph for me?"

s167
00:12:26.200 --> 00:12:30.440
So, I built lab uh active graph lab, which is reading all the blog posts.

s168
00:12:30.440 --> 00:12:37.160
So, everything I've shared has a blog, a GitHub repo, and this lab is reading all of that to come up with new ideas, asking me if it can run it.

s169
00:12:37.160 --> 00:12:41.600
And if I say yes, it'll run the experiment, um and then it'll write a blog post about it.

s170
00:12:41.600 --> 00:12:46.040
It actually did find an error in its own code, asked me if it could it could if it could fix it.

s171
00:12:46.040 --> 00:12:48.920
It wrote the PR, and then I just merged it.

s172
00:12:48.920 --> 00:12:51.000
Um so, it's it's early, but it's starting to work.

s173
00:12:51.000 --> 00:12:52.960
It's the lab is self-improving.

s174
00:12:52.960 --> 00:13:00.640
Um it also figured out that um it looked at active graph packs, and was able to just install a pack into itself, and then wrote a blog post saying packs are modular between repos.

s175
00:13:00.640 --> 00:13:01.280
I was like, "I didn't know that.

s176
00:13:01.280 --> 00:13:02.400
That's great."

s177
00:13:02.400 --> 00:13:07.600
Um and then I got distracted when I saw this Pokémon trading card name competition on Kaggle.

s178
00:13:07.600 --> 00:13:09.600
As you can see, I'm all over the place.

s179
00:13:09.600 --> 00:13:17.000
Um but uh you have to submit this deck in a deterministic agent, not with that with an LLM, and they compete in this Elo-style competition.

s180
00:13:17.000 --> 00:13:21.520
So, my decks are, you know, every hour they're battling a new competitor, and their score goes up or down.

s181
00:13:21.520 --> 00:13:27.800
Um and I felt like this was a pretty good uh test for seeing if active graph could help me increase my score.

s182
00:13:27.800 --> 00:13:35.360
And I used no cloud code and replit and we did about 80 different passes to like try different thing and and increase our score.

s183
00:13:35.360 --> 00:13:40.240
Yeah, it might not make sense if you don't play Pokémon, but these things like let's try adding a couple energy cards.

s184
00:13:40.240 --> 00:13:42.320
Seems like a very casual ask.

s185
00:13:42.320 --> 00:13:46.960
Um and my agent, probably because I think because I'm using Actigraph, would say, "Okay, sounds great.

s186
00:13:46.960 --> 00:13:57.040
Well, let's run 200 simulated games against three reference agents and then if the win rate increases by x% and there's a, you know, whatever Wilson score above 90 something, then we'll accept that as a change."

s187
00:13:57.040 --> 00:14:04.080
And I basically did this like 80 times and each time they came with this like beautiful report of like why it worked, what it did, and what the verdict was.

s188
00:14:04.080 --> 00:14:10.080
So, out of those 80 passes, it probably accepted about 20 to 30 and the score did slowly improve.

s189
00:14:10.080 --> 00:14:20.640
I'm still at like 27%, so I don't know if I can get higher than that, but um what was most interesting is how much how well the agent understood experiments we've tried before that didn't work.

s190
00:14:20.640 --> 00:14:22.520
And that was a very different experience for me.

s191
00:14:22.520 --> 00:14:27.520
Cuz I've done a lot of YOLO agents where you just like keep trying things and then it works, you're like, "Yeah."

s192
00:14:27.520 --> 00:14:30.320
But then I don't know the stuff that we tried that didn't work.

s193
00:14:30.320 --> 00:14:41.160
But now when I'm building with Actigraph, it tracks all the things that didn't work because it's forced because I have this policy that says, "Here are the Here Here's what we have to do before we accept a change."

s194
00:14:41.160 --> 00:14:50.000
Um So, some of the pleasant surprises, most of which I mentioned, but AI does seem better at architecting these NL and base agents.

s195
00:14:50.000 --> 00:14:55.920
It's just my personal experience and you know, some some people you'll have to try it yourself to see.

s196
00:14:55.920 --> 00:15:00.360
But if you think about it, LLM based agents are like 3 years old.

s197
00:15:00.360 --> 00:15:09.160
But if you look at, again, Kafka, blackboard, this like micro worker communicating through a shared state, there's decades of conversations about how to make that work better.

s198
00:15:09.160 --> 00:15:11.960
And my hypothesis is that that's in the training data.

s199
00:15:11.960 --> 00:15:16.360
And there's just much less training data around how to build LLM based agents.

s200
00:15:16.360 --> 00:15:19.640
Um debugging shifted from session logs to Actigraph DB.

s201
00:15:19.640 --> 00:15:30.640
Again, I didn't know it would, but when I, you know, when my coding agent was debugging, it just started querying the DB instead of the session logs because it's everything is already logged very cleanly and typed and it knows exactly how it's logged.

s202
00:15:30.640 --> 00:15:33.000
Pox can be loaded easily from other repos was a surprise.

s203
00:15:33.000 --> 00:15:36.280
I thought I had to do extra work to make that happen, but just worked.

s204
00:15:36.280 --> 00:15:42.640
Um no more starting long runs over from the beginning and I know what didn't work, which are some of the things I shared.

s205
00:15:42.760 --> 00:15:47.080
Um here's where I might lose some serious researchers, at least in the language I use.

s206
00:15:47.080 --> 00:15:49.240
I don't actually know how to train models or anything.

s207
00:15:49.240 --> 00:15:50.200
So I'll caveat that.

s208
00:15:50.200 --> 00:16:00.800
But I'm building this, I'm starting to really think that long-running agents need not just a world world model and like a predictive world model, but what I might call an experiential world model.

s209
00:16:00.800 --> 00:16:01.080
Right?

s210
00:16:01.080 --> 00:16:04.680
The predictive world model feels more like the priors, right?

s211
00:16:04.680 --> 00:16:11.600
And then if you think about the hippocampus, actually it also does work like an like a immutable state uh event log that projects a state.

s212
00:16:11.600 --> 00:16:17.240
And then it feeds some of that state back into your priors through a replays, dreaming, and sleep.

s213
00:16:17.240 --> 00:16:24.280
And so, you know, I feel like some some discussions kind of suggests that as models get better, like the harness disappears.

s214
00:16:24.280 --> 00:16:25.440
But I'm starting to think that's not true.

s215
00:16:25.440 --> 00:16:31.760
I think we need both um is is kind of the new hypothesis that's growing as I as I've been playing with active graph.

s216
00:16:31.760 --> 00:16:36.280
And if you think about like you or me, like you or me, like we're not our reasoning capability, right?

s217
00:16:36.280 --> 00:16:43.520
We are we're closer to our our our beliefs, our knowledge, and behaviors that are derived from our actual life experience.

s218
00:16:43.520 --> 00:16:48.920
And if that's the case, and we're going to you know, build agents inspired by ourselves, then then maybe our agent should be treated that way, too.

s219
00:16:48.920 --> 00:16:54.520
Maybe that identity of the agent is is derived from its own log.

s220
00:16:54.920 --> 00:16:57.200
Um I'd love for you to try it.

s221
00:16:57.200 --> 00:17:07.120
You can just go and just say look up active graph and build me something I would like to your favorite agent who knows you better than I do, uh and have it explain if it's uh if it was helpful or not.

s222
00:17:07.120 --> 00:17:11.760
Um Let me know if you try it.

s223
00:17:11.760 --> 00:17:12.640
Or hate it.

s224
00:17:12.640 --> 00:17:15.280
Or building something relevant.

s225
00:17:15.280 --> 00:17:17.760
Thanks for listening.

s226
00:17:31.942 --> 00:17:33.942
[music]