# What it takes to set intelligence free

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.

[07:26:09](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=26769s) good to go here. Um, all right. Welcome

[07:26:11](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=26771s) everyone. Glad to be here. I'm Fabian,

[07:26:14](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=26774s) co-founder and CTO of of Lovable. And um

[07:26:18](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=26778s) we spent the last three years or so

[07:26:20](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=26780s) building a platform to let anyone create

[07:26:22](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=26782s) software and then operate that and

[07:26:24](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=26784s) deploy that software. Um and um the the

[07:26:28](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=26788s) topic of today is what it takes to set

[07:26:32](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=26792s) intelligence free. Um really um for us

[07:26:37](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=26797s) this takes us back to when we when we

[07:26:40](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=26800s) started three years ago. And um I have

[07:26:42](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=26802s) to say I have a bit of a complicated

[07:26:45](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=26805s) relationship with with agents. Um and I

[07:26:48](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=26808s) I'll tell you why. Um we almost failed

[07:26:51](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=26811s) as a company because we thought um back

[07:26:55](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=26815s) in 2023 that hey we these agents are the

[07:26:58](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=26818s) future. So let's build for them now. Um

[07:27:00](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=26820s) I think the we kind of turned out to be

[07:27:02](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=26822s) true that they were the future but we

[07:27:04](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=26824s) were definitely wrong on the the now

[07:27:06](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=26826s) piece in in 23. So this was back in kind

[07:27:08](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=26828s) of GPT4 days. Um and um at the at that

[07:27:13](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=26833s) time the intelligence was simply not

[07:27:15](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=26835s) there to have more of these kind of

[07:27:17](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=26837s) complex agentic systems. Um but now it

[07:27:20](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=26840s) is right now uh now the intelligence is

[07:27:23](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=26843s) actually at a place where where you can

[07:27:25](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=26845s) really build out more complicated

[07:27:27](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=26847s) systems around them. Um, and so I I'll

[07:27:29](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=26849s) give you kind of a a quick um background

[07:27:32](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=26852s) story here of of our journey um in in

[07:27:36](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=26856s) working with intelligence or or these

[07:27:39](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=26859s) LMS. And so

[07:27:42](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=26862s) um back in 2023, we built the first

[07:27:45](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=26865s) version of our product. We called it GP

[07:27:46](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=26866s) Engineer back then. Um and really the UI

[07:27:50](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=26870s) was very similar to what it is today

[07:27:51](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=26871s) where you can kind of have a chat and

[07:27:53](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=26873s) this preview. Um but the AI at that

[07:27:55](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=26875s) point was quite simple. We just had a

[07:27:58](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=26878s) prompt and a response, one LM call per

[07:28:01](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=26881s) user message. Uh, very simple. It it

[07:28:03](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=26883s) worked fine. Um, but you could kind of

[07:28:05](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=26885s) build one page apps and and simpler

[07:28:08](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=26888s) applications with this. Um, and then we

[07:28:12](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=26892s) thought, okay, this intelligence is

[07:28:14](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=26894s) going to keep on evolving. So, we have

[07:28:16](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=26896s) to be ready for uh for it as it evolves.

[07:28:19](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=26899s) And so, we thought, let's go out and

[07:28:20](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=26900s) build this agentic framework. And so we

[07:28:23](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=26903s) we went and we built this very

[07:28:25](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=26905s) sophisticated there is a beautiful

[07:28:27](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=26907s) framework for for agents to work. And um

[07:28:30](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=26910s) we had kind of this one main agent that

[07:28:33](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=26913s) would talk to the user and that agent

[07:28:34](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=26914s) would spawn other agents like an

[07:28:37](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=26917s) implementation agent here in the example

[07:28:39](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=26919s) and each agent could have a specialtity.

[07:28:41](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=26921s) This agent would kind of specialize in

[07:28:43](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=26923s) the first generation of an app and then

[07:28:45](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=26925s) you would have like a front-end agent

[07:28:46](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=26926s) and a backend agent and they would all

[07:28:48](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=26928s) talk to each other, send messages back

[07:28:50](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=26930s) and forth. and we thought, "Oh, this is

[07:28:52](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=26932s) beautiful." And there was papers around

[07:28:54](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=26934s) this and how well this could work. And

[07:28:56](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=26936s) in the end, it didn't work at all. We

[07:28:58](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=26938s) just made the product worse. Um, we um

[07:29:02](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=26942s) we definitely failed on this one. Um,

[07:29:06](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=26946s) but luckily before we ran out of money,

[07:29:08](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=26948s) we figured out like, hey, let's go back

[07:29:10](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=26950s) to a simpler system again. So uh in late

[07:29:12](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=26952s) 24 we went back to a much simpler um

[07:29:15](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=26955s) system where it was a bit of a shame

[07:29:17](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=26957s) where we had like some some smaller LMS

[07:29:19](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=26959s) doing some knowledge retrieval and then

[07:29:22](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=26962s) really just one main LM kind of writing

[07:29:24](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=26964s) to the user and and writing the code in

[07:29:26](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=26966s) the same message. And this worked great.

[07:29:28](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=26968s) It was very responsive for for users in

[07:29:30](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=26970s) the UI and it was reliable and users

[07:29:33](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=26973s) were kind of in it and and iterating

[07:29:34](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=26974s) with uh with the model. Um, and so, um,

[07:29:39](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=26979s) let's close that down. Um, but now it's

[07:29:43](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=26983s) time again. We're back. We're so back.

[07:29:45](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=26985s) Agents this time, uh, they work. Um,

[07:29:48](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=26988s) and, uh, we're running them in

[07:29:50](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=26990s) production over a billion tokens per

[07:29:51](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=26991s) minute on on on these systems that I'm

[07:29:53](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=26993s) going to talk about. Um, but, um, first

[07:29:57](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=26997s) just looking at okay, what is actually

[07:29:59](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=26999s) loveable? So uh if you simplify the UI

[07:30:03](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=27003s) and this was same back in 2023 as it is

[07:30:06](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=27006s) today. Uh to the left we have a chat

[07:30:08](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=27008s) where humans come in and they kind of

[07:30:10](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=27010s) describe their their intent to to build

[07:30:12](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=27012s) or whatever they want to do. And to the

[07:30:14](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=27014s) right you have a preview uh which is the

[07:30:16](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=27016s) output or or the outcomes of of what

[07:30:19](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=27019s) you're building. Um and this back in 23

[07:30:23](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=27023s) you could do simpler things with right

[07:30:25](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=27025s) but now we've really seen working at

[07:30:28](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=27028s) this layer of abstraction you're able to

[07:30:30](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=27030s) build very complex things right and I

[07:30:32](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=27032s) think we've even seen uh a lot of

[07:30:34](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=27034s) tooling meant for for developers for

[07:30:37](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=27037s) example moving to this type of interface

[07:30:39](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=27039s) where you're not really looking at the

[07:30:40](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=27040s) code every day and so on and you're

[07:30:42](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=27042s) getting kind of abstracted and working

[07:30:44](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=27044s) on on be architecture uh or looking at

[07:30:47](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=27047s) some kind of output of of what you're

[07:30:49](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=27049s) doing. And um this is something that

[07:30:52](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=27052s) we've always believed in and it's been

[07:30:54](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=27054s) kind of a core thesis behind lovable

[07:30:56](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=27056s) that you won't have to care about the

[07:30:58](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=27058s) code in in the same way that you had had

[07:31:01](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=27061s) to do before. And I think today we're

[07:31:03](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=27063s) kind of in this almost a bit in between

[07:31:05](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=27065s) I think in the industry where you know

[07:31:06](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=27066s) some people might say you don't have to

[07:31:08](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=27068s) care about code at all and some people

[07:31:09](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=27069s) might have different opinions. Um um I

[07:31:13](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=27073s) of course like growing up coding and

[07:31:15](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=27075s) these things you get a bit attached u

[07:31:17](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=27077s) but in the end what matters is u is

[07:31:20](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=27080s) actually not the code um sorry if we

[07:31:23](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=27083s) remove that last part but uh what what

[07:31:25](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=27085s) matters is uh is the outcomes right um

[07:31:29](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=27089s) and so um the outcomes what is that well

[07:31:33](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=27093s) for for our users the outcomes is um uh

[07:31:36](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=27096s) creating a business and monetizing and

[07:31:39](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=27099s) creating value for for others in in in

[07:31:41](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=27101s) some type of way. And I'll kind of

[07:31:44](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=27104s) quickly go over um what we build as a

[07:31:47](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=27107s) platform to to enable this before I go

[07:31:48](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=27108s) in kind of on the uh on the technical

[07:31:50](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=27110s) side of this talk. So if you if you look

[07:31:53](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=27113s) at lovable the first thing that that you

[07:31:56](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=27116s) can say about the platform is that we

[07:31:58](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=27118s) have this agent and like any other agent

[07:32:00](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=27120s) it can do quite arbitrary things and

[07:32:02](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=27122s) it's quite specialized at at building

[07:32:05](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=27125s) software uh and it has access to a

[07:32:08](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=27128s) browser so it can verify what it's

[07:32:10](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=27130s) building and um it connects to to GitHub

[07:32:13](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=27133s) and you know it writes code that and you

[07:32:15](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=27135s) can do whatever you want with that code

[07:32:17](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=27137s) so on. So that's um kind of your basic

[07:32:19](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=27139s) uh coding coding agent. Um and the the

[07:32:22](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=27142s) other pieces of the platform is this

[07:32:23](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=27143s) kind of cloud and and business piece of

[07:32:25](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=27145s) the platform. And so um the cloud part

[07:32:28](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=27148s) of the platform is is about just giving

[07:32:31](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=27151s) kind of these u hosting primitives just

[07:32:33](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=27153s) seamlessly to to this agent. And so we

[07:32:36](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=27156s) we built out databases, authentication,

[07:32:38](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=27158s) storage, all the types of backend

[07:32:40](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=27160s) compute and security scanners and like

[07:32:42](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=27162s) backups and logs for all of these

[07:32:44](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=27164s) things. And all of it can be

[07:32:45](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=27165s) introspected by by the agent. Um, and

[07:32:48](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=27168s) this just makes it seamless to to build

[07:32:50](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=27170s) things. You don't have to kind of go to

[07:32:52](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=27172s) different services to set this together.

[07:32:54](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=27174s) We just kind of provide you uh these

[07:32:55](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=27175s) primitives. Um, so that's still around

[07:32:58](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=27178s) building software and hosting this,

[07:32:59](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=27179s) right? Um, but then the last piece is

[07:33:02](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=27182s) around these business capabilities where

[07:33:05](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=27185s) again the output of what our users are

[07:33:07](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=27187s) doing on lovable, we don't see that

[07:33:08](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=27188s) output as code. the output is is a

[07:33:11](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=27191s) product or or a business. Um, and if you

[07:33:15](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=27195s) want to succeed as a business, you need

[07:33:17](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=27197s) to do more things than just write code,

[07:33:19](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=27199s) right? And so we we we help our users

[07:33:22](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=27202s) with uh receiving payments, sending

[07:33:24](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=27204s) emails, optimizing SEO, um, doing ads on

[07:33:27](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=27207s) on Google and meta um, and kind of

[07:33:29](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=27209s) analyzing what is happening with the

[07:33:31](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=27211s) product through analytics and you can

[07:33:34](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=27214s) look at kind of conversions and and

[07:33:36](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=27216s) optimize these sort of things. and the

[07:33:37](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=27217s) agent is in the loop in all of this,

[07:33:40](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=27220s) right? So, that's kind of our uh

[07:33:43](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=27223s) capability offering, you could say. Um,

[07:33:46](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=27226s) and again, the core part of this is an

[07:33:48](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=27228s) agent that all of these capabilities are

[07:33:49](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=27229s) built for. Um, and at some point in

[07:33:53](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=27233s) level history, we used to limit our

[07:33:55](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=27235s) agents to work for only 30 minutes

[07:33:57](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=27237s) because we thought they weren't reliable

[07:33:59](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=27239s) to to work for a longer amount of time.

[07:34:01](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=27241s) Um but uh now we've changed this to

[07:34:04](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=27244s) really be uh without any any sort of

[07:34:07](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=27247s) bound in terms of the length an agent

[07:34:09](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=27249s) can work. And so you can imagine agents

[07:34:11](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=27251s) working for for 10 hours plus. Um and so

[07:34:14](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=27254s) I'll I'll go into some of the things

[07:34:16](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=27256s) that we've done um in our architecture

[07:34:18](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=27258s) to to enable this. And so the first

[07:34:20](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=27260s) piece is really around the agent runtime

[07:34:23](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=27263s) itself and how how we enable that to to

[07:34:26](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=27266s) run for a longer amount of time. And the

[07:34:27](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=27267s) second piece is the computer where each

[07:34:31](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=27271s) of these agents are actually doing their

[07:34:32](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=27272s) work running a dev server um and um

[07:34:36](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=27276s) actually verifying what it's doing. And

[07:34:38](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=27278s) so so the last piece then is the

[07:34:40](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=27280s) verification itself where if you want an

[07:34:42](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=27282s) agent to to work for a long amount of

[07:34:44](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=27284s) time, you need to make sure that you

[07:34:45](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=27285s) have these feedback loops in place so

[07:34:47](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=27287s) that it's not kind of going off uh in in

[07:34:49](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=27289s) in the wrong direction. Um and so if we

[07:34:53](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=27293s) start by looking at the agent runtime

[07:34:56](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=27296s) itself um you can imagine that um um you

[07:35:00](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=27300s) have um really three different sources

[07:35:02](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=27302s) that can um interact with an agent. So

[07:35:06](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=27306s) it can be yourself kind of prompting

[07:35:07](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=27307s) this or a human. It could be other

[07:35:09](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=27309s) agents and it could also be just a

[07:35:11](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=27311s) system on on a schedule waking up. And

[07:35:14](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=27314s) the way we chose to architect this is

[07:35:16](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=27316s) that for for each agent we have a

[07:35:18](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=27318s) separate inbox uh where any of these

[07:35:21](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=27321s) sources would kind of send in messages.

[07:35:23](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=27323s) And so you might have a message here

[07:35:25](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=27325s) like what's the status? Um and you can

[07:35:28](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=27328s) imagine you have this agent and this

[07:35:29](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=27329s) agent is kind of an always on agent that

[07:35:31](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=27331s) that might be working right and so um

[07:35:33](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=27333s) you can imagine it has done like three

[07:35:35](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=27335s) actions here a request a tool call and

[07:35:37](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=27337s) it got some some result and then at this

[07:35:39](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=27339s) point the agent is ready to actually

[07:35:41](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=27341s) receive uh messages. So um since anyone

[07:35:45](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=27345s) can drop a message into this inbox, the

[07:35:47](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=27347s) agent then can copy that itself into its

[07:35:50](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=27350s) own uh what we call a trajectory

[07:35:51](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=27351s) basically it's a task history. Um and

[07:35:54](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=27354s) this is the type of interaction that I

[07:35:56](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=27356s) think you're familiar with if if you're

[07:35:57](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=27357s) using agents overall. Um so that's kind

[07:36:01](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=27361s) of the the first design principle uh

[07:36:03](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=27363s) behind this agent runtime. I'll go

[07:36:05](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=27365s) through a few more here. And so um the

[07:36:09](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=27369s) the trajectory in which the the agent is

[07:36:12](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=27372s) working in which is kind of the history

[07:36:13](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=27373s) of what has happened so far um and

[07:36:16](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=27376s) really the basis for any sort of of

[07:36:18](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=27378s) memory for for for the agent right um

[07:36:21](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=27381s) and we designed this trajectory with uh

[07:36:24](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=27384s) really git as inspiration and so the

[07:36:27](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=27387s) trajectory what is it it's an append

[07:36:29](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=27389s) only log where each event uh points

[07:36:33](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=27393s) towards a parent the previous event Um

[07:36:37](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=27397s) and because of this you get um a nice um

[07:36:41](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=27401s) capability just like in git where you

[07:36:43](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=27403s) can fork things right. So you can have

[07:36:45](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=27405s) two events pointing to the same parent

[07:36:46](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=27406s) which essentially creates a fork. Um and

[07:36:49](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=27409s) because of that you can kind of spin up

[07:36:51](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=27411s) parallel agents at um um at any point of

[07:36:55](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=27415s) time in the history without having to

[07:36:57](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=27417s) duplicate all of the kind of the shared

[07:36:59](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=27419s) history. Um and um semantically it's a

[07:37:02](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=27422s) bit unclear what would happen if you

[07:37:03](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=27423s) merge this. So unlike it, we cannot

[07:37:05](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=27425s) merge agent trajectories, but we can

[07:37:07](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=27427s) kind of um spawn them out, right? And

[07:37:09](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=27429s) these agents can can talk to each other.

[07:37:12](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=27432s) Um the other thing that uh we made sure

[07:37:14](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=27434s) to design for is that this uh agent

[07:37:17](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=27437s) trajectory, it includes kind of the full

[07:37:20](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=27440s) history and everything that happens uh

[07:37:22](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=27442s) with the agent. And so every tool call

[07:37:24](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=27444s) um a bunch of other things happening on

[07:37:26](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=27446s) the platform if a tool call like failed

[07:37:28](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=27448s) or succeeded and a bunch of and what

[07:37:30](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=27450s) we've done is make sure that we have

[07:37:32](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=27452s) this appendon log and and from that we

[07:37:35](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=27455s) can actually build a prompt that we

[07:37:36](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=27456s) would feed into into the actual LM and

[07:37:39](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=27459s) um you might ask why why why would you

[07:37:41](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=27461s) want to do this? Well um one one reason

[07:37:44](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=27464s) is that um when you build a prompt you

[07:37:46](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=27466s) if you have a long history you probably

[07:37:48](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=27468s) want to do some sort of compaction. you

[07:37:49](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=27469s) want to summarize part of that history

[07:37:52](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=27472s) um in in the earlier steps for example.

[07:37:54](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=27474s) Um but this summarization would differ

[07:37:57](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=27477s) um for example if you use different

[07:37:59](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=27479s) models with different context lens you

[07:38:00](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=27480s) would probably think differently about

[07:38:02](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=27482s) when you should summarize and not. And

[07:38:05](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=27485s) so by separating the the prompt from the

[07:38:07](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=27487s) actual task history, we're able to

[07:38:09](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=27489s) render prompts for for any type of model

[07:38:11](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=27491s) or or any type of task um that that we

[07:38:15](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=27495s) can kind of find the best and optimal

[07:38:16](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=27496s) prompt for. Um, so to show this event

[07:38:21](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=27501s) history in in progress, we have this

[07:38:23](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=27503s) debug tool here. So here it's just

[07:38:24](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=27504s) recording of me dragging this uh slider

[07:38:27](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=27507s) in our UI. And you can see on the right

[07:38:29](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=27509s) that uh um the UI is kind of updating as

[07:38:32](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=27512s) I'm as I'm dragging this along and you

[07:38:34](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=27514s) have 156 events here and one each of

[07:38:36](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=27516s) those is an event in this event history.

[07:38:39](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=27519s) Uh and you can see how how the UI can

[07:38:41](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=27521s) render kind of any point in history. And

[07:38:43](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=27523s) this is just showcasing that at any

[07:38:46](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=27526s) point in time we have full control of um

[07:38:49](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=27529s) of say the UI or or anything else

[07:38:51](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=27531s) happening on the this platform thanks to

[07:38:53](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=27533s) um this history kind of detailing

[07:38:55](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=27535s) everything that has happened.

[07:38:57](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=27537s) Um the the last piece I'll go over here

[07:39:00](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=27540s) on the on the runtime itself is that um

[07:39:03](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=27543s) the process that is running these agents

[07:39:06](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=27546s) they're separate from from the actual

[07:39:08](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=27548s) task history. And so the process is uh

[07:39:11](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=27551s) almost entirely stateless in that

[07:39:13](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=27553s) between each each call each call each

[07:39:15](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=27555s) turn um it will actually just persist

[07:39:18](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=27558s) into the task history and so you can

[07:39:20](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=27560s) have a process come and go. Um and then

[07:39:24](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=27564s) the question is why why do we care about

[07:39:25](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=27565s) this? Um well

[07:39:28](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=27568s) uh at Lovable this system um we deploy

[07:39:31](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=27571s) to it um 700 times per day. So that's

[07:39:34](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=27574s) about once every two minutes. And you

[07:39:36](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=27576s) can imagine if you have um a agent

[07:39:39](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=27579s) working for for 10 hours um you want to

[07:39:43](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=27583s) not disrupt that agent when it's

[07:39:44](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=27584s) working, right? This this agent is doing

[07:39:46](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=27586s) something for for a customer. Um but at

[07:39:48](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=27588s) the same time we want to make sure that

[07:39:49](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=27589s) this agent is running on the latest

[07:39:51](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=27591s) deploy. and it might be a new feature or

[07:39:53](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=27593s) something like that, but it might also

[07:39:55](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=27595s) be like a security vulnerability in in

[07:39:58](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=27598s) the Linux kernel and it's like, okay, we

[07:39:59](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=27599s) need to update this ASAP. Um, and and so

[07:40:02](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=27602s) to do that, thanks to this separation

[07:40:04](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=27604s) between the actual history and and the

[07:40:06](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=27606s) processes, we can actually make sure

[07:40:09](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=27609s) that we have one one agent that is

[07:40:11](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=27611s) working on one task, but we can have

[07:40:13](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=27613s) different processes taking up and

[07:40:15](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=27615s) actually doing the compute behind that

[07:40:17](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=27617s) work. Um so so this task can keep on

[07:40:20](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=27620s) working while we have um different

[07:40:22](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=27622s) deploys um working on it be it for 10

[07:40:26](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=27626s) hours or or even longer right um so

[07:40:29](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=27629s) that's the agent runtime. The second

[07:40:32](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=27632s) piece of um of this platform right is

[07:40:34](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=27634s) the is the computer. So this is where

[07:40:36](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=27636s) the work is actually happening. Um and

[07:40:39](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=27639s) we've been through a lot of iterations

[07:40:41](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=27641s) and uh a lot of vendors kind of working

[07:40:43](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=27643s) with um um providing these sandboxes for

[07:40:46](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=27646s) for the computer for for the agent to

[07:40:48](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=27648s) work in. And we've landed in in this

[07:40:50](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=27650s) system that we've worked really hard now

[07:40:52](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=27652s) to develop which is um um checkpointing

[07:40:56](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=27656s) um a computer. And so you can imagine

[07:40:59](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=27659s) you come to level you start a new

[07:41:00](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=27660s) project. Uh we have this common what we

[07:41:03](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=27663s) call a golden checkpoint which contains

[07:41:06](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=27666s) the OS and the system services. It has

[07:41:08](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=27668s) common tools installed and a dev server

[07:41:10](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=27670s) that is ready to start. And this

[07:41:12](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=27672s) checkpoint, it it includes everything on

[07:41:14](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=27674s) disk uh memory and also running

[07:41:16](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=27676s) processes. And and so when you start a

[07:41:19](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=27679s) new project, you get all of that for

[07:41:20](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=27680s) free. And uh all of that is copied over

[07:41:22](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=27682s) in about 230 milliseconds. Um and so

[07:41:26](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=27686s) once you start a project, you you might

[07:41:28](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=27688s) have some specific code and and some

[07:41:30](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=27690s) dependencies within that project. Um and

[07:41:33](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=27693s) um that is also checkpointed as you go.

[07:41:37](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=27697s) And and so each time the the agent is

[07:41:40](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=27700s) running and it finishes a turn, we will

[07:41:43](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=27703s) actually save a checkpoint o of that

[07:41:45](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=27705s) computer and and from that we're able to

[07:41:47](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=27707s) again like very quickly subsecond uh uh

[07:41:50](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=27710s) spin that computer up whenever you need

[07:41:52](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=27712s) it. That means we can save on on

[07:41:53](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=27713s) resources by kind of spinning this down.

[07:41:55](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=27715s) If you leave for say 10 minutes or or so

[07:41:58](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=27718s) and come back, we can just spin it up

[07:42:00](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=27720s) extremely quickly. So you don't even

[07:42:01](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=27721s) notice this and even uh kind of requests

[07:42:04](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=27724s) um in transit will will not even be

[07:42:07](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=27727s) dropped in in in this setup. Um the

[07:42:10](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=27730s) other thing we can do thanks to uh this

[07:42:12](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=27732s) checkpointing is that just like the

[07:42:15](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=27735s) trajectory itself uh in the agent

[07:42:17](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=27737s) runtime we can also fork um the computer

[07:42:20](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=27740s) and when we do this um we have for

[07:42:23](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=27743s) example we have um a feature in in level

[07:42:26](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=27746s) that is called draft where you kind of

[07:42:28](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=27748s) work in different environments of what

[07:42:29](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=27749s) you're doing and and to support that we

[07:42:31](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=27751s) need to fork the computer that you're

[07:42:32](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=27752s) working in. Um and um here we have um um

[07:42:38](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=27758s) kind of the example of doing two at the

[07:42:40](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=27760s) same time. And um you can imagine doing

[07:42:42](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=27762s) hundreds of these, right? Um and so um

[07:42:46](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=27766s) we've we've had to do uh some

[07:42:48](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=27768s) optimizations to make this feasible to

[07:42:50](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=27770s) to actually run. So one of these

[07:42:52](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=27772s) optimizations is copy on write on the

[07:42:54](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=27774s) RAM itself. And so creating one of these

[07:42:57](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=27777s) forks of a computer is uh is basically

[07:42:59](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=27779s) free in terms of of the RAM that it's

[07:43:01](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=27781s) using. But um as soon as you start

[07:43:04](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=27784s) writing um um in in a process to to RAM,

[07:43:07](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=27787s) we will kind of copy that page over and

[07:43:09](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=27789s) only then will you start having to

[07:43:11](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=27791s) allocate new memory. Um and there's

[07:43:15](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=27795s) another optimization here also which is

[07:43:17](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=27797s) that um each of these sandboxes require

[07:43:20](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=27800s) a few hundreds of megabytes of memory.

[07:43:22](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=27802s) Um but and that would take a few seconds

[07:43:25](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=27805s) to stream in if you have it in like cold

[07:43:27](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=27807s) object storage and then it has to go to

[07:43:28](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=27808s) disk and then then into memory of this

[07:43:30](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=27810s) uh um this VM. But um thanks to uh um

[07:43:36](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=27816s) being able to stream the memory, we can

[07:43:37](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=27817s) actually boot up the the machine before

[07:43:41](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=27821s) all of the memory is is actually um

[07:43:44](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=27824s) ready on it. So the the memory the OS

[07:43:47](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=27827s) uses comes first and then like some

[07:43:48](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=27828s) processes and so on will will start to

[07:43:50](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=27830s) work as soon as the memory gets there.

[07:43:52](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=27832s) And this also shaves off some some extra

[07:43:55](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=27835s) startup time. Um, and then we started

[07:43:57](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=27837s) asking ourselves, how can we make this

[07:43:58](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=27838s) even more efficient and even more faster

[07:44:00](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=27840s) for our users? And so you might be

[07:44:02](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=27842s) familiar with V. It's this great dev

[07:44:04](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=27844s) server that most of the meta frameworks

[07:44:06](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=27846s) out there in the JavaScript ecosystem is

[07:44:08](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=27848s) using. Uh, and so we we took that and we

[07:44:10](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=27850s) forked it and we rewrote it in in Rust.

[07:44:13](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=27853s) And uh, that made our code starts two

[07:44:15](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=27855s) times faster and we went from getting

[07:44:17](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=27857s) this preview from 14 seconds to to 3

[07:44:19](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=27859s) seconds. And the main um kind of thing

[07:44:21](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=27861s) that we made faster here is that vit

[07:44:23](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=27863s) uses noode.js and we're able to like

[07:44:25](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=27865s) drop that dependency off itself and just

[07:44:28](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=27868s) have this rust binary. So um that made

[07:44:30](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=27870s) the memory footprint be 6.5 times less

[07:44:34](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=27874s) uh in these machines. Um and by taking

[07:44:36](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=27876s) control of the applications that we're

[07:44:38](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=27878s) running in these computers, we're also

[07:44:39](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=27879s) able to control kind of how we write to

[07:44:42](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=27882s) memory. And so when we control how we

[07:44:44](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=27884s) write to memory, we're even more

[07:44:46](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=27886s) optimizing. If you remember back to the

[07:44:48](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=27888s) kind of the copy and write solution when

[07:44:49](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=27889s) we're drafting different um um different

[07:44:52](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=27892s) computers and so we're able to uh run

[07:44:55](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=27895s) this extremely efficiently so that we

[07:44:57](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=27897s) can run um lots and lots of agents in in

[07:44:59](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=27899s) parallel and kind of have agents explore

[07:45:02](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=27902s) different solutions to solving a bug or

[07:45:04](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=27904s) improving the performance of of your

[07:45:06](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=27906s) applications and and so on. Um and so

[07:45:10](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=27910s) this has been fun. Um uh but the last

[07:45:13](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=27913s) piece now is is about verification. And

[07:45:15](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=27915s) of course this kind of computer and this

[07:45:17](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=27917s) dev server is a big piece of being able

[07:45:19](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=27919s) to verify what an agent is doing. Um and

[07:45:23](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=27923s) if you look at verification, you can

[07:45:25](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=27925s) think of these feedback loops, right?

[07:45:27](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=27927s) That the agent needs to get information.

[07:45:29](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=27929s) It took an action. Was this a good

[07:45:30](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=27930s) action or was it a bad action? And um

[07:45:33](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=27933s) you can think of it as this inner loop

[07:45:35](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=27935s) and this outer loop. So this inner loop

[07:45:36](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=27936s) is um during the turn of the agent. And

[07:45:38](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=27938s) you have kind of obvious things such as

[07:45:40](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=27940s) like the um is the build working? Do we

[07:45:42](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=27942s) have lint errors or type errors in the

[07:45:44](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=27944s) code that we're running? And then you

[07:45:46](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=27946s) can check for runtime errors in in the

[07:45:48](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=27948s) preview that you're running. You can

[07:45:49](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=27949s) also have within this computer a

[07:45:51](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=27951s) headless browser where the agent can go

[07:45:53](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=27953s) in and kind of explore um the the web

[07:45:56](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=27956s) app it's it's building or whatever it's

[07:45:58](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=27958s) building, right? Um and and a bunch of

[07:46:00](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=27960s) other things that we're using to help

[07:46:02](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=27962s) verify within the turn of an agent. But

[07:46:04](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=27964s) then you also have this outer loop which

[07:46:06](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=27966s) is kind of between each turn and the

[07:46:08](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=27968s) turn you can think of like when the

[07:46:10](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=27970s) agent is yielding to you as a user. Um

[07:46:12](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=27972s) and um between each turn you might get

[07:46:15](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=27975s) some info on on the product itself uh

[07:46:17](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=27977s) from from production from your users,

[07:46:19](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=27979s) right? And so you can look at how your

[07:46:21](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=27981s) visitors are behavior are behaving. Um

[07:46:24](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=27984s) what users are are telling you online.

[07:46:26](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=27986s) Uh you can do automatic AB tests and

[07:46:28](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=27988s) actually see change some copy and see is

[07:46:31](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=27991s) this improving conversion and so on. And

[07:46:33](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=27993s) then you can also take these business

[07:46:34](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=27994s) metrics and and remember this goes back

[07:46:36](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=27996s) to kind of the capabilities I showed

[07:46:37](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=27997s) you. By having control over these

[07:46:39](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=27999s) things, we can make sure that we can

[07:46:41](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=28001s) optimize how the agent is is getting

[07:46:43](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=28003s) this out of feedback loop. So, we can

[07:46:45](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=28005s) make sure that if you're running

[07:46:46](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=28006s) payments, we can actually track those

[07:46:49](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=28009s) transactions and conversions and make

[07:46:51](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=28011s) sure that um the agent can actually help

[07:46:53](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=28013s) you optimize uh not only the the code,

[07:46:56](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=28016s) right, but the the business strategy um

[07:46:59](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=28019s) around around your product. Um and so

[07:47:03](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=28023s) those are really the the three things

[07:47:05](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=28025s) that that we've been working for. And uh

[07:47:08](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=28028s) we'll continue to kind of build out um

[07:47:11](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=28031s) these uh these capabilities and this

[07:47:14](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=28034s) architecture around really orchestrating

[07:47:17](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=28037s) these LMS into into agents. And so um

[07:47:20](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=28040s) this agentic system that we're building,

[07:47:21](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=28041s) it's running billions of tokens per

[07:47:23](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=28043s) minute. Um and um these computers,

[07:47:26](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=28046s) right, we can spawn up with each agent

[07:47:28](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=28048s) and we can have multiple agents use one

[07:47:30](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=28050s) computer. And now we're kind of back to

[07:47:32](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=28052s) this uh quite beautiful setup where we

[07:47:34](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=28054s) have agents talking to agents and

[07:47:36](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=28056s) they're orchestrating and and this time

[07:47:38](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=28058s) it's it's actually working and it's

[07:47:41](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=28061s) working at scale thanks to some of these

[07:47:43](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=28063s) optimizations. Um and so if you're

[07:47:45](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=28065s) curious to try this out, you can head

[07:47:47](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=28067s) to.dev and you'll you'll see our our

[07:47:49](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=28069s) preview spinning up and and so on, but

[07:47:51](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=28071s) you'll get a very simple and um a nice

[07:47:54](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=28074s) interface and you won't have to care

[07:47:55](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=28075s) about all of this stuff. Thank you so

[07:47:57](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=28077s) much. It's been pleasure. Um, and uh,

[07:48:00](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=28080s) yeah, hope you hope you learned

[07:48:01](https://www.youtube.com/watch?v=ZZ19zhYnDKY&t=28081s) something. Thanks so much. [applause]
