# The Rise of the Agent Workforce: Rethinking Agent Infrastructure

Source: https://www.youtube.com/watch?v=ZZ19zhYnDKY

Machine-generated transcript; recognition errors remain. Source-recording timestamps. Boundary-crossing subtitle ends are clipped to this session.

[02:46:35](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=9995s) All right. Uh well, super excited to be

[02:46:38](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=9998s) here. My name is Ankit. I'm from Data

[02:46:40](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=10000s) Bricks. Uh I work on AI infrastructure

[02:46:42](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=10002s) there. And today I'm going to talk about

[02:46:44](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=10004s) >> [music]

[02:46:44](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=10004s) >> uh the rise of the agent workforce and

[02:46:46](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=10006s) how we're building our agent

[02:46:48](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=10008s) infrastructure to support what we think

[02:46:50](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=10010s) is the next generation of agents.

[02:46:52](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=10012s) I wanted to start by taking a step back

[02:46:54](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=10014s) and and thinking about how we help

[02:46:57](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=10017s) computers become good at other things uh

[02:47:00](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=10020s) better even than humans. And one of the

[02:47:02](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=10022s) games I grew up playing a lot was chess.

[02:47:04](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=10024s) Uh it's one of the great examples of

[02:47:06](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=10026s) something where computers became way

[02:47:07](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=10027s) better than humans a long time ago. But

[02:47:10](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=10030s) I think it's important to think about

[02:47:12](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=10032s) why that happened and how we can apply

[02:47:14](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=10034s) those lessons today. One of the biggest,

[02:47:16](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=10036s) you know, to summarize at a high level,

[02:47:18](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=10038s) a lot of work went into it. The biggest

[02:47:20](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=10040s) thing that agents were able to do, that

[02:47:22](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=10042s) computers were able to do was explore

[02:47:24](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=10044s) the space of decisions much more

[02:47:26](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=10046s) effectively than humans. For most

[02:47:29](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=10049s) complex problems, there's actually a

[02:47:30](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=10050s) bunch of different ways you can solve

[02:47:32](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=10052s) the problem. And at each turn, you can

[02:47:34](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=10054s) kind of think of three more decisions

[02:47:37](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=10057s) that you can make. And really, it's the

[02:47:38](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=10058s) exploration of that space that all of us

[02:47:40](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=10060s) are engaged in. All of us who solve hard

[02:47:42](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=10062s) problems are engaged in the search space

[02:47:44](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=10064s) for what's an amazing product, what's

[02:47:46](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=10066s) the right solution to this math problem,

[02:47:48](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=10068s) and etc., right? uh and I think we've

[02:47:50](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=10070s) seen some really exciting progress from

[02:47:53](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=10073s) the labs like Enthropic, OpenAI and

[02:47:54](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=10074s) Google on solving problems that are

[02:47:57](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=10077s) wellformed. So, you know, if you think

[02:47:59](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=10079s) about chess, it can be modeled

[02:48:00](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=10080s) effectively. You can evaluate your

[02:48:02](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=10082s) position. Uh you can actually play

[02:48:05](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=10085s) simulate it. You can try different moves

[02:48:07](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=10087s) and safely think about all the different

[02:48:09](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=10089s) alternatives. Similarly, with math

[02:48:11](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=10091s) problems, often the ones that agents are

[02:48:13](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=10093s) really good at solving, they you can

[02:48:15](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=10095s) actually verify if you got the result

[02:48:17](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=10097s) right. uh and how do we then take that

[02:48:20](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=10100s) mindset and apply it to the problems

[02:48:22](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=10102s) that we actually face day-to-day.

[02:48:25](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=10105s) I think like let's a lot everyone here

[02:48:27](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=10107s) is an engineer. So let's take it to

[02:48:29](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=10109s) engineering for a bit. Uh I think you

[02:48:31](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=10111s) know if you take it to the preai days uh

[02:48:34](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=10114s) most people think about solving a single

[02:48:37](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=10117s) problem and they're kind of

[02:48:38](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=10118s) singlethreaded on that problem for the

[02:48:39](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=10119s) time that they're writing code on it. uh

[02:48:41](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=10121s) and you know as a company if or a

[02:48:43](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=10123s) product if you wanted to solve more

[02:48:44](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=10124s) problems you brought in more people and

[02:48:46](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=10126s) the very basic version of agents just

[02:48:49](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=10129s) helps create leverage for that engineer.

[02:48:51](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=10131s) Now you can be singlethreaded on three

[02:48:53](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=10133s) things at the same time and ultimately

[02:48:55](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=10135s) that helps you explore new product

[02:48:57](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=10137s) ideas, ship faster, iterate faster and

[02:49:00](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=10140s) that's obviously very exciting. But it's

[02:49:02](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=10142s) it's not actually close to what we

[02:49:04](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=10144s) needed to do to win at chess or any of

[02:49:06](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=10146s) these other problems. What we're seeing

[02:49:08](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=10148s) at the absolute frontier are these teams

[02:49:11](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=10151s) of agents that are able to make

[02:49:12](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=10152s) significant progress by exploring the

[02:49:14](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=10154s) decision space more effectively. So how

[02:49:16](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=10156s) do we move towards that world where we

[02:49:18](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=10158s) actually have these teams of agents that

[02:49:20](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=10160s) are coherently attempting to solve

[02:49:22](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=10162s) problems? It's actually quite complex

[02:49:24](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=10164s) and we think it requires a little bit

[02:49:26](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=10166s) different type of infrastructure.

[02:49:28](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=10168s) Specifically, I think an important

[02:49:30](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=10170s) question to ask is how do we give agents

[02:49:32](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=10172s) a realistic world to explore? Because in

[02:49:36](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=10176s) other problems, we're able to help

[02:49:37](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=10177s) define that world very effectively. But

[02:49:39](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=10179s) even in software engineering, we

[02:49:41](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=10181s) actually really struggle to do that.

[02:49:43](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=10183s) Like just consider this movement towards

[02:49:45](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=10185s) software factories, right? Where you're

[02:49:47](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=10187s) away from the from the agents and you're

[02:49:49](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=10189s) actually operating a bunch of agents

[02:49:50](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=10190s) that are working on a problem. How do

[02:49:53](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=10193s) you validate that those agents are

[02:49:54](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=10194s) effective? Like before you had a branch

[02:49:58](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=10198s) uh you had main, you branched your PR

[02:50:00](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=10200s) off of that. Maybe you have an agent

[02:50:01](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=10201s) working on that PR and you have some

[02:50:04](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=10204s) reasonable assertion that this is kind

[02:50:06](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=10206s) of a sim, you know, you have some ass

[02:50:08](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=10208s) like some tests or something like that

[02:50:10](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=10210s) that help you guide your development.

[02:50:12](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=10212s) But if you're actually merging tens of

[02:50:15](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=10215s) PRs a minute or even more, right? Like

[02:50:17](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=10217s) if you play out the future of factories

[02:50:20](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=10220s) of agents building code and software,

[02:50:23](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=10223s) your PR is just out of date the moment

[02:50:24](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=10224s) you branched. The the moment you

[02:50:26](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=10226s) started, you're already out of date. So

[02:50:28](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=10228s) it demands a different mindset of

[02:50:30](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=10230s) thinking of how do we verify these

[02:50:32](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=10232s) things? You actually might want to move

[02:50:33](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=10233s) most of your verification to postmerge.

[02:50:36](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=10236s) And so that kind of brings me to this a

[02:50:38](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=10238s) little bit radical idea. I I don't think

[02:50:41](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=10241s) we should try to write hundreds or

[02:50:43](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=10243s) thousands of unit tests. Instead, I want

[02:50:45](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=10245s) to explore this idea of simulating

[02:50:48](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=10248s) reality. Can I give my agent a faithful

[02:50:51](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=10251s) reproduction of what's actually there in

[02:50:53](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=10253s) the real world in my production code in

[02:50:55](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=10255s) my production agent and let it work on

[02:50:58](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=10258s) that? And with when you can do that, you

[02:51:01](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=10261s) can actually do that at scale. If you

[02:51:03](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=10263s) find a way to simulate reality, then you

[02:51:05](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=10265s) can actually do that across lots of

[02:51:07](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=10267s) different explorations.

[02:51:09](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=10269s) At data bricks, one of the big things

[02:51:10](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=10270s) that people do on our platform is build

[02:51:12](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=10272s) data pipelines. We've got tens of

[02:51:14](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=10274s) thousands of data pipelines on data

[02:51:16](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=10276s) bricks. Uh and the biggest problem that

[02:51:19](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=10279s) happens with pipelines is that they

[02:51:20](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=10280s) break. Um and in this era of agents,

[02:51:23](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=10283s) what people want is they want to fix

[02:51:25](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=10285s) those broken pipelines with agents

[02:51:28](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=10288s) because these are serious business

[02:51:29](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=10289s) problems that they that are, you know,

[02:51:31](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=10291s) uh caused by a broken pipeline. If a

[02:51:33](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=10293s) pipeline breaks, that business can't

[02:51:35](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=10295s) operate that day. Uh and so this becomes

[02:51:37](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=10297s) a major emergency.

[02:51:40](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=10300s) But like how do you actually validate

[02:51:41](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=10301s) this with an agent? Do you trust it on

[02:51:43](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=10303s) your production data pipeline? It's

[02:51:45](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=10305s) pretty risky because writes might not be

[02:51:47](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=10307s) identy

[02:51:54](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=10314s) broken. It's just partially broken. One

[02:51:56](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=10316s) of the things we started doing was

[02:51:58](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=10318s) building on top of branchable

[02:51:59](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=10319s) infrastructure. And so what we did was

[02:52:02](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=10322s) we branched the entire data platform. We

[02:52:05](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=10325s) branched the tables, the compute, the

[02:52:07](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=10327s) governance and we gave the agents a

[02:52:10](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=10330s) place where they can actually play with

[02:52:12](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=10332s) the data platform and explore different

[02:52:14](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=10334s) hypotheses. And these hypotheses can be

[02:52:16](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=10336s) ambitious like can I investigate that

[02:52:19](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=10339s) the upstream pipeline is healthy? Maybe

[02:52:21](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=10341s) I can do that by changing the pipeline

[02:52:22](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=10342s) code and running it again. In any

[02:52:24](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=10344s) reasonable data platform, you wouldn't

[02:52:27](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=10347s) do that with an upstream pipeline unless

[02:52:28](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=10348s) you had a bunch of engineers take a look

[02:52:30](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=10350s) at it and make sure it was super safe.

[02:52:32](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=10352s) with our branched data platform. You can

[02:52:34](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=10354s) actually do that now. So it can

[02:52:35](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=10355s) investigate a bunch of different things.

[02:52:37](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=10357s) So we can investigate 10 ideas in

[02:52:38](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=10358s) parallel with our agents actually get to

[02:52:41](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=10361s) a faithful conclusion about whether it

[02:52:43](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=10363s) fixed the real data pipeline and then

[02:52:46](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=10366s) make that assumption made that assertion

[02:52:48](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=10368s) back either to a main agent or to a

[02:52:50](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=10370s) human. And what we saw before was

[02:52:52](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=10372s) happening was that people would just

[02:52:53](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=10373s) like LLM would give us text back some

[02:52:55](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=10375s) human would take a look at it and be

[02:52:57](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=10377s) like okay this might be an interesting

[02:52:58](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=10378s) theory. then they would go apply that

[02:53:00](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=10380s) theory in some way. And ultimately that

[02:53:02](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=10382s) became more of this like AI assisted

[02:53:05](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=10385s) version of fixing the data pipeline. But

[02:53:07](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=10387s) really where we want to go is is is

[02:53:09](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=10389s) hands-off full auto for this kind of

[02:53:13](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=10393s) problem. And we were we were struggling

[02:53:15](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=10395s) to do it without this branchable

[02:53:16](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=10396s) infrastructure. So how do we do it? I'm

[02:53:19](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=10399s) going to talk a little bit about that in

[02:53:20](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=10400s) this talk. Uh we built this on top of

[02:53:23](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=10403s) our Postgress native agent platform

[02:53:25](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=10405s) which started with the Neon database

[02:53:27](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=10407s) which is a branchable database that

[02:53:29](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=10409s) gives us a single place that we can

[02:53:31](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=10411s) actually use for our services and for

[02:53:32](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=10412s) our agents. And then we added in a bunch

[02:53:35](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=10415s) of really core agent primitives that

[02:53:37](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=10417s) allow us to build sophisticated

[02:53:38](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=10418s) different types of agents. Uh and those

[02:53:40](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=10420s) are ones that are probably familiar to

[02:53:42](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=10422s) all of you. Things like memory, things

[02:53:43](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=10423s) like sandboxes, file systems, and ways

[02:53:46](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=10426s) to host those agents. And these

[02:53:48](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=10428s) low-level primitives we can build we can

[02:53:50](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=10430s) build with them. But the key is that we

[02:53:51](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=10431s) made just all of them branchable. So you

[02:53:53](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=10433s) can branch the entire reality of stuff

[02:53:56](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=10436s) that's built on this platform for us for

[02:53:57](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=10437s) ourselves. Uh so how do we actually do

[02:54:00](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=10440s) that? Well, let me walk it through like

[02:54:02](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=10442s) kind of case by case. The first thing is

[02:54:05](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=10445s) just the database, right? And you know

[02:54:06](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=10446s) we can take an example of application

[02:54:08](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=10448s) services. But here I'm going to talk

[02:54:09](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=10449s) about just even storing the conversation

[02:54:11](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=10451s) state for for an agent. When you fork or

[02:54:14](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=10454s) branch an agent, you actually might want

[02:54:16](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=10456s) to inherit the history. And you might

[02:54:18](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=10458s) even if you have a team of agents give

[02:54:20](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=10460s) access to a given member of that team to

[02:54:22](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=10462s) what the other members of the team are

[02:54:23](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=10463s) doing. Uh and we found the database to

[02:54:25](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=10465s) be a convenient abstraction for this. Uh

[02:54:28](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=10468s) the key was that hey like when a new

[02:54:30](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=10470s) reply comes in on the on the branched

[02:54:32](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=10472s) agent it shouldn't necessarily change

[02:54:34](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=10474s) anything about the other one. Uh and

[02:54:36](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=10476s) this is possible because Neon has a

[02:54:38](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=10478s) branched database. But then we actually

[02:54:40](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=10480s) found that agents need more than just

[02:54:42](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=10482s) structured databases. Of course they

[02:54:44](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=10484s) need structured databases but they also

[02:54:46](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=10486s) like to do this you know write these

[02:54:48](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=10488s) things called memories and memories are

[02:54:50](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=10490s) you know at a very high level they

[02:54:52](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=10492s) compile down to an unstructured database

[02:54:54](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=10494s) for agents. There are two ways that

[02:54:56](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=10496s) memories get generated. The first is

[02:54:58](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=10498s) just by synthesizing the context and the

[02:55:00](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=10500s) conversations that someone's already had

[02:55:02](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=10502s) with them and the second by agents

[02:55:04](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=10504s) actually explicitly saving content to an

[02:55:07](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=10507s) unstructured place. The key thing here

[02:55:10](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=10510s) is that you actually want to consolidate

[02:55:12](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=10512s) and distill that information. there's a

[02:55:13](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=10513s) ton of information coming in through

[02:55:15](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=10515s) there and if you just give that you know

[02:55:17](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=10517s) if you just let it kind of go on its own

[02:55:19](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=10519s) you have problems of staleness you have

[02:55:22](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=10522s) conflicts in the information and all of

[02:55:24](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=10524s) those can be extremely damaging to teams

[02:55:26](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=10526s) so we have this thing that basically

[02:55:28](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=10528s) dreams overnight we use offline compute

[02:55:32](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=10532s) uh and it takes the conversations a

[02:55:34](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=10534s) different agent essentially highlights

[02:55:35](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=10535s) things that are conflicts and

[02:55:38](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=10538s) consolidates the ad hoc notes that were

[02:55:40](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=10540s) written by various members of the team

[02:55:42](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=10542s) and then all members of the team can

[02:55:44](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=10544s) actually recall from that memory

[02:55:45](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=10545s) database. And you can use this in a

[02:55:47](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=10547s) bunch of different ways. We use this

[02:55:49](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=10549s) within our Slack agents, but we also use

[02:55:51](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=10551s) this when we're launching a parallel set

[02:55:53](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=10553s) of agents to investigate a deep issue,

[02:55:56](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=10556s) for example, in the data platform. Now,

[02:55:58](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=10558s) how does branching come into this? Well,

[02:56:01](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=10561s) some of the agents like in many of the

[02:56:02](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=10562s) use cases, they propose memories and

[02:56:05](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=10565s) it's not clear whether those memories

[02:56:06](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=10566s) generalize to the actual broader set of

[02:56:09](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=10569s) agents or if that's a specific thing for

[02:56:11](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=10571s) just that agent. And so with the

[02:56:13](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=10573s) branchable database for memory which is

[02:56:15](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=10575s) built on top of this neon database, we

[02:56:17](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=10577s) can actually just propose that memory

[02:56:18](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=10578s) somewhere in there and that branch can

[02:56:21](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=10581s) continue to iterate and at some point we

[02:56:23](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=10583s) can find a way to merge it back in if

[02:56:24](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=10584s) it's necessary. uh we found this to be a

[02:56:27](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=10587s) flex an important layer of flexibility

[02:56:29](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=10589s) because without the ability to

[02:56:31](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=10591s) completely branch the memory we found it

[02:56:33](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=10593s) was very hard to maintain the memory for

[02:56:35](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=10595s) a team of agents especially as we

[02:56:38](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=10598s) increase parallelism you can actually

[02:56:39](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=10599s) experience like significantly reduced

[02:56:41](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=10601s) quality if all the agents are pursuing

[02:56:43](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=10603s) different goals uh I I I like to think a

[02:56:46](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=10606s) little bit of it as as like kind of

[02:56:48](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=10608s) similar to dynamic programming right if

[02:56:49](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=10609s) you've explored a branch of exploration

[02:56:51](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=10611s) and then you have a different agent that

[02:56:53](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=10613s) happens upon that same pathway It's very

[02:56:56](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=10616s) damaging to like always revisit that but

[02:56:58](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=10618s) sometimes you want to and so the ability

[02:57:00](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=10620s) to propose a memory is extremely

[02:57:02](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=10622s) important to us.

[02:57:04](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=10624s) How is all of this kind of branchable

[02:57:06](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=10626s) database possible? Well, the way that

[02:57:08](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=10628s) Neon does is it is it separates compute

[02:57:10](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=10630s) from storage. Compute uh for Postgress

[02:57:13](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=10633s) is running in some separate place and

[02:57:15](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=10635s) then we actually have the shared history

[02:57:17](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=10637s) and the storage in a different layer and

[02:57:19](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=10639s) what that lets us do is copy on write

[02:57:21](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=10641s) for branching. So when we have a

[02:57:23](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=10643s) branched version of the database, you

[02:57:25](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=10645s) can actually have A's uh you know

[02:57:26](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=10646s) compute A's rights separated from

[02:57:28](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=10648s) compute B and that's the kind of the

[02:57:30](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=10650s) core layer of infrastructure that allows

[02:57:32](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=10652s) us to build these applications on top of

[02:57:34](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=10654s) that database.

[02:57:37](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=10657s) But then we found you know obviously

[02:57:38](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=10658s) agents are far more than storage and and

[02:57:41](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=10661s) branching storage wasn't enough.

[02:57:43](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=10663s) We also found that as they were running

[02:57:45](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=10665s) in sandboxes, agents like to take notes

[02:57:47](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=10667s) on stuff and write down scripts and use

[02:57:50](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=10670s) those to actually iterate on various

[02:57:52](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=10672s) kinds of problems. It it it's one of the

[02:57:54](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=10674s) most exciting things about agents that

[02:57:56](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=10676s) I've found that they are able to

[02:57:58](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=10678s) generalize this capability that's needed

[02:58:00](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=10680s) maybe for testing code and and things

[02:58:02](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=10682s) like that and solve other more broader

[02:58:04](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=10684s) general problems using that same con

[02:58:06](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=10686s) construct.

[02:58:08](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=10688s) But then when you branch it, you

[02:58:10](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=10690s) actually need to give the future agent a

[02:58:12](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=10692s) similar context. If you we found that

[02:58:13](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=10693s) when we started the branched agents

[02:58:15](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=10695s) without the same files that that agent

[02:58:17](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=10697s) had to begin with it just wasn't as

[02:58:19](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=10699s) effective. So when you're investigating

[02:58:21](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=10701s) an outage for example with an agent you

[02:58:23](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=10703s) might have notes and plans and a future

[02:58:26](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=10706s) branch of that agent might update those

[02:58:27](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=10707s) notes. It might find new things but we

[02:58:30](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=10710s) don't want that to go back because we're

[02:58:32](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=10712s) actually exploring 10 different pathways

[02:58:34](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=10714s) at the same time. Uh so building a

[02:58:36](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=10716s) branchable file system was extremely

[02:58:37](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=10717s) important and allowed us to build what

[02:58:39](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=10719s) we call a branchable sandbox because

[02:58:42](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=10722s) then what we can do is we can launch

[02:58:44](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=10724s) that sandbox compute and and that's a

[02:58:46](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=10726s) hard problem in and of itself. It's not

[02:58:47](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=10727s) one we're going to talk about today but

[02:58:50](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=10730s) that compute can be attached to storage

[02:58:52](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=10732s) and critically the agents actually

[02:58:54](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=10734s) really aggressively leverage files very

[02:58:57](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=10737s) often. Uh and so it can be very painful

[02:58:59](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=10739s) to make all your storage fully remote.

[02:59:01](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=10741s) Uh and so the really core piece of what

[02:59:03](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=10743s) we've been building here is a syncing

[02:59:05](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=10745s) process between what we call a local

[02:59:07](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=10747s) cache and the remote cache. Uh and then

[02:59:10](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=10750s) what that allows us to do is as we're

[02:59:12](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=10752s) able to make progress on that when we

[02:59:14](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=10754s) want to branch we can actually branch a

[02:59:16](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=10756s) second sandbox use that similar file

[02:59:19](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=10759s) system and it reduces our latency for

[02:59:21](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=10761s) for branching while also keeping

[02:59:23](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=10763s) performance of the regular agent

[02:59:25](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=10765s) reasonable.

[02:59:27](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=10767s) So what this allows us to do at a high

[02:59:29](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=10769s) level is branch the entire working

[02:59:31](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=10771s) state.

[02:59:33](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=10773s) And this gives us the platform layer to

[02:59:35](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=10775s) actually go do that. Now this isn't

[02:59:38](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=10778s) obviously sufficient. You're going to

[02:59:39](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=10779s) want to branch even more. If you're

[02:59:41](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=10781s) building on top of software, you want to

[02:59:42](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=10782s) find a way to branch that too. And so

[02:59:44](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=10784s) this is along the lines of how we're

[02:59:46](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=10786s) thinking, right? Like we the data

[02:59:47](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=10787s) platform was built on top of some of

[02:59:49](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=10789s) these things, but there's a lot more

[02:59:50](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=10790s) that we've been able to branch there as

[02:59:52](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=10792s) well. Uh but we're really excited about

[02:59:54](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=10794s) this layer for just even building

[02:59:56](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=10796s) agents. And just to like kind of

[02:59:58](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=10798s) separate a little bit even from software

[03:00:00](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=10800s) development like another thing a lot of

[03:00:02](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=10802s) us are spending a lot of time thinking

[03:00:04](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=10804s) about is security.

[03:00:06](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=10806s) Uh, I mean just taking a step back, I

[03:00:09](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=10809s) think this is probably the single most

[03:00:11](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=10811s) important thing for any product that

[03:00:12](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=10812s) anyone sells at this point because trust

[03:00:15](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=10815s) is kind of the most important thing that

[03:00:16](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=10816s) we're selling when we work with other

[03:00:18](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=10818s) people. And uh, with agents being the

[03:00:21](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=10821s) ones who generate the vulnerabilities,

[03:00:24](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=10824s) uh, it's kind of impossible to find a

[03:00:27](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=10827s) different solution than having agents be

[03:00:28](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=10828s) the ones who are monitoring for those

[03:00:30](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=10830s) exact vulnerabilities in your code. So

[03:00:33](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=10833s) you should be thinking about how you can

[03:00:34](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=10834s) build an agent factory that's detecting

[03:00:36](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=10836s) security issues in your codebase. Um and

[03:00:39](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=10839s) so this is something we spending a lot

[03:00:40](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=10840s) of time out spending a lot of time on.

[03:00:43](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=10843s) So typically what happens in a security

[03:00:44](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=10844s) incident? Well, let's say you suspect

[03:00:47](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=10847s) something. An agent might be always

[03:00:48](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=10848s) looking for it. Why why is there this

[03:00:50](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=10850s) like network traffic that's erressing

[03:00:52](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=10852s) all of a sudden from my control plane?

[03:00:54](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=10854s) Well, I can assemble an incident

[03:00:56](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=10856s) timeline and that's obviously the first

[03:00:57](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=10857s) step in an investigation. But anyone

[03:00:59](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=10859s) who's been a part of a serious security

[03:01:01](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=10861s) investig investigation knows that time

[03:01:03](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=10863s) is of the essence. It's a perfect

[03:01:05](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=10865s) problem for parallelism. And that's

[03:01:06](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=10866s) exactly what you do when a security

[03:01:08](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=10868s) incident happens. You bring everyone

[03:01:09](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=10869s) online so you can explore 10, 15, 20

[03:01:12](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=10872s) different theories at once because an

[03:01:14](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=10874s) hour earlier that you can you can detect

[03:01:16](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=10876s) the real issue is an hour that you're

[03:01:18](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=10878s) actually more safe. So okay, what if we

[03:01:22](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=10882s) did that with a branchable agent? Let's

[03:01:24](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=10884s) say there's two paths to investigate. Uh

[03:01:27](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=10887s) so you know the agents assembled the

[03:01:28](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=10888s) incident timeline and now you can ask

[03:01:31](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=10891s) two questions. Hey did a recent

[03:01:32](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=10892s) deployment in introduce some kind of new

[03:01:34](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=10894s) integration like maybe I can go look at

[03:01:36](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=10896s) the code or I can explore a totally

[03:01:39](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=10899s) different theory. Is a compromised

[03:01:40](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=10900s) identity accessing this data and the

[03:01:43](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=10903s) core thing that we are able to do here

[03:01:44](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=10904s) is we branch that whole original agent

[03:01:46](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=10906s) that was starting the investigation

[03:01:50](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=10910s) and then the new one is able to work in

[03:01:51](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=10911s) a completely isolated copy of the world.

[03:01:54](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=10914s) And in some cases when we're able to, we

[03:01:56](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=10916s) can even branch the actual service that

[03:01:57](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=10917s) we're investigating. Uh, and so when you

[03:02:00](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=10920s) have this isolated copy of conversation,

[03:02:02](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=10922s) memory, and storage, you can fully

[03:02:04](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=10924s) explore that security risk and and let

[03:02:06](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=10926s) the agent loop on its own. And that's

[03:02:08](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=10928s) kind of the key thing here. The way that

[03:02:10](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=10930s) these agents are good is that they're

[03:02:12](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=10932s) able to loop, verify, try new theories.

[03:02:15](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=10935s) I think Andre Karpathy said it really

[03:02:17](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=10937s) well. They're far more tenacious than

[03:02:20](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=10940s) any human probably in the history of

[03:02:23](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=10943s) software. And so they're able to just

[03:02:25](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=10945s) but like we keep getting in the way by

[03:02:27](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=10947s) inserting ourselves as an approval

[03:02:29](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=10949s) layer. Uh and so this is a solution that

[03:02:31](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=10951s) we think helps with that. Just like take

[03:02:33](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=10953s) away the consequences of making a

[03:02:35](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=10955s) mistake a little bit. Branch the entire

[03:02:37](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=10957s) state so that you're not actually you

[03:02:40](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=10960s) know worrying about that same risk. And

[03:02:43](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=10963s) then you we you we've been able to find

[03:02:45](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=10965s) this to actually uh come to a reasonable

[03:02:47](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=10967s) conclusion as well. So what does this

[03:02:50](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=10970s) all add up to for us? We think that your

[03:02:53](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=10973s) infrastructure needs to be branchable

[03:02:55](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=10975s) and that's what we're building with Neon

[03:02:57](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=10977s) with data bricks. Uh and we're super

[03:02:59](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=10979s) excited about that branchable future

[03:03:01](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=10981s) because we think that teams are going to

[03:03:02](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=10982s) be the next generation of agents both

[03:03:05](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=10985s) for software and the way that we

[03:03:07](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=10987s) actually build products. Thank you.