Latest / Agentic Conversations (formally mlops.community) / The Future of AI Agents is Sandboxed

Transcript

The Future of AI Agents is Sandboxed · Agentic Conversations (formally mlops.community)

• 0:00
  I don't know if this is the right term for it.
• 0:02
  Like the Githubbification of like workflows is going to be
• 0:05
  important. It could be, it could be that
• 0:08
  that someone figures out a very generic and extensible way to
• 0:12
  have like a staging environment that like outputs work that
• 0:17
  people approve or don't. It's maybe more open-ended, but
• 0:20
  I think that's that's going to be ultimately another important
• 0:22
  piece of this puzzle. Sandboxes are very hot these
• 0:32
  days. They are the topic du jour and I
• 0:37
  would love to talk with you since you have been in the weeds
• 0:41
  of sandboxes for so long. Just breakdown.
• 0:45
  What exactly do we mean when we hear that term being thrown out
• 0:49
  in the wild? Yeah.
• 0:51
  So I, I think it can mean a few different things, but in, in the
• 0:54
  context of, of like agentic execution, typically what this
• 0:59
  means is, is you're going to give an agent its own sandbox
• 1:04
  environment where it can do what it pleases and you don't have
• 1:08
  any kind of concerns of, of security kind of
• 1:12
  vulnerabilities, right? You know, it gets to operate in
• 1:15
  its own isolated environment. You know, kind of a key to this
• 1:19
  is also setting that environment up so that the agent has any
• 1:23
  tools or any context that it needs to do its job.
• 1:27
  So I think typically, you know, when people talk about sandboxes
• 1:31
  in the ngenta context, what they're really talking about is
• 1:33
  giving the agent effectively its own computer.
• 1:37
  You know, I, I think we've seen that agents tend to perform
• 1:42
  better the more tools you give them, giving them their own
• 1:45
  computer. I mean, that's effectively like
• 1:47
  the most powerful tool there is, really.
• 1:52
  And are you giving them beefy compute as they give them?
• 1:55
  And how do you look at the different environments that you
• 2:00
  set up for them? Is it something that you want to
• 2:03
  make sure that they have tools to go and search the web or is
• 2:06
  it something a little bit more constrained?
• 2:09
  Yeah. So on the kind of beefiness of
• 2:12
  the, the environment, you know, you can create these sandboxes
• 2:16
  via API on our platform on run loop AI.
• 2:20
  You can specify the, the size you want.
• 2:22
  You can specify how much memory and how much compute and, and
• 2:25
  how much disk you want to be available.
• 2:28
  You know, depending on your workload, it might be that you
• 2:31
  want lots and lots of these things running in parallel and
• 2:34
  relatively lightweight boxes. Or if you have heavier weight
• 2:38
  tools like if you're messing with F, FM, PG or I don't know,
• 2:42
  sometimes like MPM and PMPM can be pretty beefy too.
• 2:46
  So you might you might need more compute.
• 2:48
  So it's really kind of dealer's choice there.
• 2:51
  So we have like default sandbox images that we launched that
• 2:54
  have like, you know, common tools, you know, like they have
• 2:57
  Python And like node and stuff like that pre installed.
• 3:01
  But most folks end up using one of our products called
• 3:05
  Blueprints, which lets the our users specify the precise
• 3:10
  context that they they want in the container image.
• 3:15
  So that basically a blueprint is basically a Docker file plus
• 3:18
  plus. Why is it more than a Docker
• 3:21
  file? So there, there are certain
• 3:22
  things that are hard to express in a Docker file like Docker.
• 3:25
  In Docker, it's kind of awkward to express from one Docker file,
• 3:30
  which we support. So the blueprint let's our users
• 3:34
  say, hey, here's the laundry list of stuff that I want in
• 3:37
  that container when it launches as part of the sandbox
• 3:40
  environment. Let's see interesting things
• 3:44
  that we include in the the blueprint context.
• 3:48
  We have an object object API where you can upload arbitrary
• 3:51
  objects. You can say, hey, I want that on
• 3:53
  that container image. We have an agent API where you
• 3:56
  can specify agents that you want to include in an image.
• 4:01
  We also have a notion of code mounts where you can say I'd
• 4:04
  like to include this code repository in this image.
• 4:08
  So these are all kind of part of the toolkit for configuring your
• 4:12
  sandbox. The blueprint is a way to kind
• 4:15
  of statically ahead of time build the container image with
• 4:18
  all that in there. You can also do it when you're
• 4:20
  experimenting or getting set up. You can do it dynamically when
• 4:23
  you launch the dev box. So you can dynamically put all
• 4:26
  that stuff onto your sandbox environment at launch time.
• 4:29
  So I think developers will typically start launching dead
• 4:34
  boxes and dynamically adding the stuff they need.
• 4:36
  And then when they're like, OK, I got all the right recipe
• 4:38
  together, let me put that into a blueprint.
• 4:41
  Now it's already and it just, it launches that way.
• 4:43
  It's just faster for launching like that.
• 4:47
  So many questions for you man. Like, First off, you're not
• 4:52
  specifically creating tools in these different environments,
• 4:58
  are you? It's really up to our users to
• 5:01
  to build their agents as they see fit and choose how to
• 5:05
  compose them with with tools and skills and things like that.
• 5:09
  And that's how the repo comes in to play.
• 5:11
  It's like here, throw this repo in there, then the agent can
• 5:14
  understand what's going on and it can grab the needed MCP
• 5:19
  servers and look in the different directories or
• 5:22
  whatnot. You, you certainly could do
• 5:26
  things that way. So typically the, the code mount
• 5:30
  is really quite literal. It just means tell me what
• 5:33
  GitHub repositories you want in this image and I'll put them
• 5:37
  there. And it might be a code
• 5:39
  repository that you intend to work on, like, hey, I'm going to
• 5:43
  write some code in here. Or it might be a code repository
• 5:46
  that you're using as you're suggesting as a source for like
• 5:49
  tooling and whatnot. This also kind of speaks to the
• 5:53
  agent API. Like these are very powerful and
• 5:56
  composable kind of API. There's many ways to to skin any
• 6:00
  particular cat, so to speak. So the the agent API similarly
• 6:06
  lets you specify an agent you'd like to put on the dead box.
• 6:09
  You can specify an agent that you want to be made available
• 6:13
  via MPM or you can also point to a GitHub repository or you can
• 6:18
  actually upload an object that is a a tart up version of your
• 6:22
  agent. So you have many different ways
• 6:25
  to kind of compose these things and, and ultimately it kind of
• 6:28
  becomes a dealer's choice on how you use these AP.
• 6:33
  Is do you find that folks will run various agents inside of one
• 6:39
  environment? Yeah, often, sometimes people
• 6:42
  will run one agent, they'll have a workflow like some folks use
• 6:46
  things like Temporal outside of the dead box and they will
• 6:49
  launch the dead box with whatever target context they're
• 6:52
  trying to work on. And you might use something like
• 6:55
  Temporal or any, any sort of other workflow thing.
• 6:57
  This may be part of your product layer.
• 6:59
  And then you'll reach into the the dead box environment and
• 7:02
  you'll invoke, you know, maybe a first agent.
• 7:04
  When that completes, you maybe move on to another stage of your
• 7:08
  product workflow and invoke a second agent, you know, and it
• 7:12
  it's possible that you could snapshot or, or suspend and
• 7:15
  resume. So our dev boxes have useful
• 7:18
  orchestration primitives. So snapshot is, hey, we're going
• 7:21
  to take a point in time copy of this.
• 7:22
  You can fork it or you can just save it for later.
• 7:27
  Suspend resume is a feature that uses snapshot.
• 7:30
  It's it's like a nice product feature on top of it uses
• 7:33
  snapshots to suspend a dev box and then resume it.
• 7:37
  People who have like human in the loop kind of workflows often
• 7:41
  use this just because if the, if you're waiting for a person for
• 7:44
  a while, maybe you should shut down the dead box when the
• 7:48
  person comes back and make some decision, you might want to
• 7:51
  resume it. So it's again, these are kind of
• 7:55
  composable primitives and it really comes down to what the
• 7:59
  application that that ultimately our user is trying to build.
• 8:04
  And I think there's something I'm still trying to wrap my head
• 8:08
  around, which is why have a sandbox for the agent versus
• 8:16
  just like having that agent be some API that you can ping.
• 8:22
  Yeah. So, so there's, there's, there's
• 8:26
  a number of kind of questions underneath that one question.
• 8:31
  But I, I think it's a kind of in a way you're asking, Hey, why
• 8:36
  why don't I just hope host an agent execution on a normal
• 8:39
  server? And I think that that there are
• 8:42
  certainly agent patterns where you can do that.
• 8:46
  But I think the second you want the agent to have access to its
• 8:50
  underlying compute, like it wants shell access, bash access,
• 8:55
  you want it to be able to, to author code and execute code for
• 8:59
  security reasons. You really don't want that
• 9:01
  running right next to your server.
• 9:03
  You know, if you had an LLM, if you have a server running and
• 9:06
  it's hosting some number of these things, First of all, they
• 9:09
  have very unpredictable load and usage depending on because
• 9:14
  they're, they're effectively going to execute tools and do
• 9:17
  what LLMS are suggesting they do, right?
• 9:20
  So they have really unpredictable usage patterns.
• 9:23
  And if you're going to give them bash or shell access or access
• 9:26
  to to dangerous tools, if that's running next to your computer, I
• 9:31
  mean, there's nothing to stop your agent from kill lining the
• 9:33
  server it's running on or RM dash Rfing the root file system
• 9:38
  where your server is running. And that would be problematic.
• 9:41
  So, you know, that's that's really where the kind of the
• 9:45
  sandbox term really originates is you're putting it in a
• 9:48
  sandbox where it's isolated and and it's kind of blast radius of
• 9:52
  things that that it can impact is low.
• 9:56
  And I think typically speaking, like, you know, I mean, the, the
• 9:59
  LMS and the agents are, are, are usually not doing silly things
• 10:02
  are usually trying to make like forward progress, but they can
• 10:06
  make mistakes or they can also just do things like that are
• 10:09
  very resource expensive, right, that just chew up all the cores
• 10:13
  of memory on the system. So for this reason, like, you
• 10:17
  know, unless you have an agent with like a very specific and
• 10:21
  narrow use pattern, if you're looking to give it access to
• 10:23
  things like bash tools, compilers, the ability to, to
• 10:27
  execute arbitrary code, if you're looking to do those types
• 10:31
  of things with your agent, you, you probably want it in its own
• 10:34
  sandbox environment. And that's kind of like the for
• 10:39
  security and isolation rationale for doing it.
• 10:42
  I think kind of the flip side of that coin is just opening up the
• 10:44
  world of capability to your agent, right?
• 10:47
  You know, as I said earlier, I mean effectively like a computer
• 10:51
  is like the most valuable and powerful tool out there, right?
• 10:56
  Why not give that to your agent? What that lets the agent do, if
• 11:01
  you give it its own sandbox is you can really open up its its
• 11:04
  tool kit and you can let it do a lot of things that would
• 11:06
  otherwise be a little nerve racking to have running on your
• 11:11
  server, right? So you can say, hey, if you
• 11:14
  like, clone repos, download stuff from the Internet, parse
• 11:18
  files, hey, you have full access to the file system, write
• 11:21
  yourself A to do list and go work your way through the To Do
• 11:24
  List. You can write sample code or
• 11:27
  intermediate state to the local file system.
• 11:30
  So you, you know, you really do end up by giving your agent its
• 11:34
  own computer, giving it the the a lot of power and a lot of the
• 11:38
  kind of open-ended capability. So many great things there.
• 11:44
  And yes, thank you for clarifying that because it was
• 11:50
  like I had the inkling of yeah, sandboxes.
• 11:54
  Of course there's limiting the blast radios.
• 11:56
  You don't want to doing stuff in the same place that you have
• 12:01
  maybe the production environment because it can go AWOL or.
• 12:05
  Just I think it. Starts causing trouble.
• 12:07
  The the answer is really that it was like the pro and the con,
• 12:10
  and they're actually both opposite sides of the same coin.
• 12:13
  The the the con is is you're like, Oh my God, I don't want my
• 12:16
  stuff getting rooted or destroyed or like, maybe Asia is
• 12:19
  going to do something bad. But the Pro is like, hey, like
• 12:22
  this agent's cool and smart. Give it the best tools and.
• 12:26
  Yeah, we should. We should give it access.
• 12:27
  It's it ends up with the same answer.
• 12:29
  So like, I don't know pick pick your rationale, but I think you
• 12:32
  you kind of end up with the same result other way.
• 12:34
  So if I understand this correctly, then you're saying
• 12:39
  for an agent that maybe is able to look into databases.
• 12:47
  Are you copying whole databases over into these environments so
• 12:51
  that the agent can play and do what it wants?
• 12:54
  But also if you have Johnny drop tables agent, it's not going to
• 12:59
  destroy your last whatever year of data.
• 13:03
  Yeah, you certainly could. I mean, there are a few
• 13:06
  different ways you could you could do that.
• 13:09
  So kind of earlier I mentioned the object API to you on the
• 13:13
  object API, just it, I mean, it more or less is, is like a
• 13:17
  product layer in front of something like S3, right?
• 13:20
  So you certainly could take a copy of of some set of database
• 13:24
  tables, put it into the object store and build it into a
• 13:27
  blueprint or make it available when you launch the dead box.
• 13:30
  And then your agent has its own private copy.
• 13:33
  Kind of the other way you would do something like that is is you
• 13:36
  would maybe use an MCP server that had scoped credentials that
• 13:41
  said, hey, I have like read only access to to A to an external
• 13:47
  database. So that would kind of be the
• 13:48
  other way to do that sort of thing.
• 13:51
  I want to just touch on one other piece that you mentioned
• 13:56
  and it's worth highlighting, which is the agents can be
• 13:59
  resource intensive. And so when you have a sandbox,
• 14:04
  you can kind of control that and make sure that if they do go a
• 14:08
  little bit wild with the resources, it's only up to the
• 14:12
  amount that you specified beforehand.
• 14:15
  Yep, yeah, it's they're, they're in their own isolated sandbox.
• 14:18
  The most they can use is the full size of the sandbox.
• 14:21
  And we actually in our product layer will will start to alert
• 14:26
  you. We we put into the log traces
• 14:28
  when you go over, I think I don't know if it's 80 or 90% of
• 14:32
  memory or CPU use, but we actually drop an alert.
• 14:35
  So we're like, hey, getting hot in here.
• 14:39
  Maybe I need a bigger sandbox, or maybe you need to tone down
• 14:43
  the stuff you're trying to do. One or the other.
• 14:46
  And is this because this is really geared for production?
• 14:51
  How do you see it scaling horizontally when you want to
• 14:56
  start doing that? Is it just replicating the same
• 14:58
  sandboxes or is it getting a bigger sandbox?
• 15:03
  Yeah, typically people just stand up a large number of
• 15:06
  sandboxes, like some of our customers will stand up like
• 15:08
  6000 at once. Yeah, these are sometimes these
• 15:13
  are people who are trying to drive like RFT or like jobs like
• 15:18
  that. And I'll just stand up a whole
• 15:20
  pile of these things at once. So kind of the point is there's
• 15:25
  kind of an interesting observation here.
• 15:27
  This is, I think, another one of the reasons, you know, if you if
• 15:30
  you step back a little and you look at the success of things
• 15:32
  like Clawed Code Codex and now actually Lang chain with deep
• 15:38
  agents, they, you know, increasingly have this metaphor
• 15:41
  of a really direct computer use, right?
• 15:44
  Like when you run clawed from your terminal on your laptop,
• 15:48
  it's using your laptop as if it was its own right.
• 15:51
  Same thing with Kodak's. So you're, you're starting to
• 15:53
  see this, this pattern become popularized of like, you know,
• 15:58
  agents directly using compute. And you know, I think there's
• 16:02
  another advantage to that. We we mentioned a minute ago
• 16:05
  maybe using something like MCP to give, you know, an agent
• 16:09
  access to non local resources, right.
• 16:13
  And I think that if you look at the concept of bundling an agent
• 16:18
  with its code sandbox, you have this nice atomic unit of like,
• 16:22
  OK, here's your existing tools, here's the amount of compute
• 16:26
  and, and RAM and stuff you're allowed.
• 16:28
  You know, hey, you're in this box and I know you can use all
• 16:31
  of it, but this is like a nice atomic unit.
• 16:34
  And you can actually then assign identity to that, to that
• 16:37
  specific dead box, right? And that identity can also be
• 16:41
  part of how authentication to to MCP tools is handed out.
• 16:46
  So I think there's there's just a huge number of very practical
• 16:50
  reasons to think about deploying agents in this pattern.
• 16:53
  And the identity would be whatever Johnny drop tables
• 16:57
  agent. Yeah Johnny drop tables agent is
• 17:01
  Nana. Here's the agent ID.
• 17:02
  It's running on this sandbox. Idi provision this sandbox with
• 17:07
  this specific MCP access credential which is read only
• 17:10
  database. So Johnny Drop.
• 17:12
  Table doesn't. Johnny drop table doesn't go too
• 17:15
  crazy and drop my production database.
• 17:17
  He has been known to do that. He has been known to do that.
• 17:21
  You can't give him that access man.
• 17:23
  That's the problem. Wow.
• 17:26
  Yeah, I mean the, the, the, the, the the database nerds would say
• 17:29
  you can also, you can also create virtual databases that
• 17:32
  are clones of your production database to to solve this.
• 17:35
  So there are many layers of the stack at which people will solve
• 17:38
  all these problems. You know, and, and actually all
• 17:40
  the way back to your database question earlier, like, hey, can
• 17:44
  you provision a database onto the dead box?
• 17:46
  I had suggested people using object mounts for that.
• 17:50
  We have a bunch of customers that use Docker files for this.
• 17:53
  You know, as I mentioned earlier, we support Docker and
• 17:55
  Docker. People will take Postgres, jam
• 17:58
  it and the Docker file with some amount of storage or some subset
• 18:02
  of their production database and use Docker and Docker for that.
• 18:05
  So as it's in computer science, there's always, there's always
• 18:10
  many particular, there's always many ways to solve a problem.
• 18:12
  It's just what is the most expedient and like judicious way
• 18:16
  for you to do it now or with what you're currently trying to
• 18:19
  do? Well, it's interesting.
• 18:21
  Before we hit record, you mentioned that agents work a lot
• 18:25
  more like humans than traditional software.
• 18:29
  Yeah, I think that's, I think this is also like a thing that
• 18:33
  makes the whole give an agent a computer insight even more
• 18:37
  valuable, right? Like, I mean, think about like
• 18:41
  you've I'm sure you've worked on like a REST server or coded, you
• 18:44
  know, maybe a fast API or a next server, right?
• 18:47
  Think about normal servers, right?
• 18:49
  Like you have schema inputs, right?
• 18:51
  Like typically REST or maybe GRPC with proto schemas, right?
• 18:54
  Like you have some amount of like, hey, work comes in this
• 18:57
  door, right? But it's it's strongly typed,
• 18:59
  right? And that maps somewhere
• 19:02
  deterministically to code, right?
• 19:04
  And that code executes. And sure, some requests are more
• 19:07
  expensive than others, but by and large there is a determined
• 19:11
  deterministic set of paths through your system, right?
• 19:14
  And ultimately state gets stored probably in a database.
• 19:17
  Maybe something goes out the other door to a message queue or
• 19:20
  some other API. But you effectively have this
• 19:22
  deterministic mapping of like requests and inputs storage,
• 19:27
  maybe outbound requests, right? Now think about an lol, right?
• 19:32
  It's natural language is coming in one side.
• 19:35
  It has some tools it can invoke, but you have no idea if it's
• 19:40
  going to, you know, it's an inherently probabilistic
• 19:44
  process. And, you know, if you even look
• 19:47
  at like, you know, Claude code or, or what a lot of these, you
• 19:50
  know, agent frameworks do now they start doing things with the
• 19:53
  local file system. They're like, ah, like, yeah,
• 19:55
  it's a big task. I'm going to write myself a plan
• 19:59
  and store it on the file system. Just like, you know, a human
• 20:02
  being at their laptop, you know, at work might have a white, like
• 20:05
  a white piece of paper or a pad next to them and be like, Oh
• 20:08
  yeah, things I have to do, like check that off.
• 20:10
  So I like don't, you know, let my teammates sound right.
• 20:14
  So you start to see like agents kind of, you know, not to
• 20:17
  anthropomorphize them, but they, they have like very different
• 20:20
  working patterns. If I'm sure you have seen this
• 20:24
  using agent sewer, you'll ask it to do something and it maybe
• 20:27
  isn't 100% sure about an API or a library.
• 20:30
  And it'll be like, hey, I'm going to go over to the Internet
• 20:33
  and download this this API or download, you know, some, some
• 20:37
  read me documentation like that's how I work.
• 20:41
  Like, you know, OK, hey, I want to give a code against this
• 20:44
  thing. I'm pretty sure I know I need to
• 20:45
  use this, but like, let me go look at the documentation.
• 20:49
  So, you know, I think kind of the way that agents use compute
• 20:55
  is a lot different than a traditional server or, or even a
• 20:59
  Lambda function, which is just kind of like a point in time,
• 21:02
  one request slice of a server, right?
• 21:06
  And we, we really do believe that what we're working on here
• 21:09
  is kind of a new compute pattern.
• 21:12
  And you know, like you might, you might pause and be like,
• 21:16
  what do you mean it's a new compute pattern?
• 21:18
  It's just like you're just using a computer, but like to think
• 21:22
  about this, right? Like you're, you're effectively
• 21:25
  saying, I have one piece of software that's going to, in an
• 21:28
  open-ended fashion, use its own computer.
• 21:31
  And and if you think about the last time we saw like maybe a
• 21:35
  new emergent type of compute pattern, I would argue it's kind
• 21:38
  of maybe the advent of Spark and like data bricks, right?
• 21:43
  Like where they're like, yeah, Spark is kind of like a bunch of
• 21:50
  servers that like work gets farmed out to, but it has this
• 21:54
  workflow and a DAG and like. So I kind of think that this
• 22:00
  might be that different and that kind of unique that this is just
• 22:04
  kind of a new compute pattern. And probably two or three years
• 22:08
  from now, it like probably the language around all the stuff
• 22:11
  we're doing and, and other people are doing will get
• 22:14
  standardized and you'll be like, Oh yeah, there's these dedicated
• 22:17
  platforms for running agents. And like, yeah, of course it
• 22:21
  should be that way. But this is, this is the arc
• 22:24
  where we're trying to walk along that to, to kind of establish
• 22:28
  this as being, you know, just that.
• 22:32
  I could not help but think about Neo in the Matrix when you said,
• 22:36
  Oh yeah, I need to know. It's like I know Kung Fu.
• 22:39
  I went out there, I downloaded what I needed and now I know
• 22:43
  Kung Fu. Maybe that's that's skills,
• 22:45
  right? That is exactly.
• 22:48
  The Kung Fu skill. The other thing that I wanted to
• 22:52
  hit on was when you have these environments happening and you
• 22:57
  have these agents kind of getting the run of it, are you
• 23:03
  observing everything that they're doing to then be able to
• 23:06
  go back and eval what they chose and how they chose it?
• 23:13
  Yeah, Yeah. So that's a really important
• 23:15
  question. So that actually touches on
• 23:17
  another an entire another part of our our kind of product suite
• 23:21
  that we haven't talked about yet.
• 23:23
  So let me give you the straightforward answer and then
• 23:25
  I'll give you the less straightforward answer.
• 23:28
  So the straightforward answer is, yeah, we have like good
• 23:30
  built in observability and debug ability as part of our platform.
• 23:33
  So you can see and audit everything that happened that
• 23:37
  that took place for the agent. And we'll collect trajectories
• 23:41
  as well if you configure a platform that way.
• 23:45
  So that is a great way for you to be like, hey, like what
• 23:47
  actually happened here? Let me debug it.
• 23:49
  But as you kind of talk about evals, I think that's another
• 23:54
  very important thing. So we have a product we call
• 23:57
  benchmarks. And what benchmarks effectively
• 24:00
  let you let you do is, is take dead boxes in a known state
• 24:06
  where you can drop your agent on to try to solve a problem.
• 24:10
  And you can tell us you you can give us scoring functions to
• 24:13
  evaluate how well your agent did.
• 24:16
  And we think this is pretty important, right?
• 24:18
  Like if you've gone through a bunch of effort to build an
• 24:21
  agent to accomplish some domain specific task, you want to
• 24:25
  constantly measure your agent's ability to perform that task,
• 24:29
  right? And, and given that this is a
• 24:32
  stochastic system, it's, it's not, it's not like a unit test
• 24:35
  or an IT case, right? It's not going to be 100%.
• 24:39
  And So what the benchmark product lets you do is create a
• 24:43
  suite of these tests, run your agent against those tests,
• 24:49
  observe the results and say like, OK, great, am I getting
• 24:52
  better or worse? Or let's say, hey, like, I guess
• 24:55
  Claude 4-5 Opus just dropped. Let's say you're like, you know,
• 24:59
  I'm going to spend the money, I'm going to use the more
• 25:01
  expensive model. Well, how much better does your
• 25:04
  agent perform with it? Well.
• 25:06
  So important. Just go right into the exact
• 25:08
  same benchmark, flip the model you're using, run through the
• 25:11
  benchmark and and measure the difference.
• 25:14
  And I think you you had called these evaluations.
• 25:18
  I think it's worth pointing out some rash.
• 25:21
  Yeah, there's a, there's a little bit of a rationale.
• 25:23
  So why we call these benchmarks, like a lot of evals are a little
• 25:27
  more tightly scoped to like measuring the quality of
• 25:30
  independent LLM requests and responses.
• 25:33
  What we're really trying to do is longitudinally measure the
• 25:37
  end to end ability of the agent to accomplish its task, maybe
• 25:41
  across hundreds of LLM calls, hundreds of tool calls, and
• 25:45
  often times to evaluate the performance of the the agent,
• 25:50
  you need to understand the context it was working in.
• 25:53
  So let's take a code base for example, right?
• 25:56
  Let's say that you have a coding agent that I don't know is
• 26:01
  updating dependencies or something like that, right?
• 26:04
  You might start off with a repository in a known state.
• 26:07
  You know, you might invoke your agent and then your scoring
• 26:11
  function would look at, you know, your dependency file after
• 26:14
  it made the changes and say, OK, like, are all the dependencies
• 26:18
  of a higher than this, this number or not?
• 26:20
  Like it should have updated all these things like I'll score
• 26:23
  that. But you could also make sure
• 26:25
  that the the repository builds right?
• 26:27
  Like it didn't hallucinate some version that didn't exist.
• 26:30
  So this is an example of where, like, take that relatively
• 26:33
  mundane or simple example I just gave you.
• 26:36
  Probably the agent's going to talk to the LMA few dozen times
• 26:41
  and make at least four or five, maybe more tool calls.
• 26:45
  And then for you to evaluate the correctness of his results, you
• 26:48
  need to look at the file system. OK.
• 26:51
  Like what is the state of my package, Jason, or my
• 26:53
  requirements lock or whatever UV lock file, right?
• 26:57
  And like, yeah, by the way, like, does this build?
• 27:00
  Because you could have made-up some new version that is like
• 27:03
  higher than the old version, but doesn't exist, right?
• 27:07
  So again, like to get back to the benchmarks.
• 27:10
  The point is, is that, you know, for people out there,
• 27:13
  practitioners out there, you're going to build an agent.
• 27:16
  You wanted to accomplish some specific goal.
• 27:18
  You need to consistently measure that you're getting better or at
• 27:22
  least not losing ground. And we think benchmarks are the
• 27:26
  right way to do that. In your initial question, you
• 27:29
  hinted at a notion of can we take a runtime environment and
• 27:33
  maybe turn it into a benchmark? We're not there yet.
• 27:36
  I think that's ultimately the coolest thing would be, you
• 27:39
  know, for for someone to have their production traffic running
• 27:43
  against a bunch of a bunch of dead boxes and for them to flag
• 27:46
  to us like, hey, like that benchmark, you know, I'm sorry,
• 27:51
  that dead box, DBX 12345, whatever, that didn't end so
• 27:56
  well. Can you like capture all the
• 27:58
  logs in the initial state and turn that into a benchmark so I
• 28:02
  can like I can go work against that again and again until I
• 28:05
  improve that particular pattern? Yeah, those failed cases are
• 28:13
  almost like the there is valuable as gold, right.
• 28:17
  Because if if you have an agent that is working well against
• 28:21
  your benchmarks and then you start to see, oh, it's got a
• 28:25
  little bit of a blind spot there, that's very valuable.
• 28:29
  But what you already have set up sounds like it is infinitely
• 28:33
  valuable just to understand the basics of.
• 28:39
  Is this shippable? Is this shippable?
• 28:43
  Does it do what I think it's supposed to do most of the time?
• 28:48
  Does it, you know, with some, with some percentage points of
• 28:51
  like just chaos? Does it?
• 28:53
  Does it do what I want it to do most of the time?
• 28:56
  You know, and, and you can also get into, you know, some of our
• 28:59
  customers do pretty cool things where they'll you ask questions
• 29:04
  about multiple agents before they'll have an agent run.
• 29:08
  And then they'll have an agent that runs after it that
• 29:10
  evaluates if if it did a good enough job and then kicks by the
• 29:13
  previous agent, right. Kind of the alarm as a judge
• 29:16
  type thing. So you'll have these agent that
• 29:19
  did work unit A, agent that judged work unit A and then then
• 29:23
  pass you on to agent B or kicked back to agent A.
• 29:27
  So you they're, they're, you know, once you have these
• 29:29
  frameworks in place, there are a number of cool methodologies you
• 29:32
  can start to implement to try to like increase your accuracy,
• 29:35
  right? And make sure you you you don't
• 29:38
  produce low quality results. Well, I really like the idea of
• 29:43
  looking at it as a holistic system as opposed to just did
• 29:47
  this one LM call that's one of potentially hundreds.
• 29:53
  Actually work. And if you think about things
• 29:55
  like code, right, like the, the LLM might be telling you to
• 29:58
  patch 1 file like OK, like it's very hard to judge like OK, that
• 30:05
  one file patch is immaterial in absence of all the other patches
• 30:10
  you just did right? Like that piece or that single
• 30:14
  LLM call is is not particularly useful right?
• 30:17
  Like without the tool chain, the rest of the code base and all
• 30:21
  the other patches. So I think ultimately it's just,
• 30:24
  it's, it's just measuring things at a different scale, right?
• 30:28
  Like what is? What is the longitudinal result
• 30:30
  of like my my intend execution as opposed to like finer grain?
• 30:35
  Do you remember that meme back in the day?
• 30:37
  That was the little girl looking at the camera in the Bernie
• 30:41
  houses behind her. And it said, you know, worked on
• 30:44
  my machine. It's an OPS problem now.
• 30:47
  Yeah. Yeah.
• 30:49
  It it just reminds me a little bit of of that, how you're
• 30:54
  basically helping so that that is not happening.
• 30:58
  That meme is not a reality. Yeah, yeah.
• 31:01
  And that is, that is one of the all time grades.
• 31:06
  You mentioned that you have folks that are using 6000
• 31:10
  sandboxes when they're scaling out.
• 31:14
  Are all of these agents highly isolated?
• 31:19
  Is there any type of multi tenancy that you can have?
• 31:22
  Is it like you want some kind of a shared state sometimes?
• 31:27
  How do you see the different customers working through those
• 31:31
  questions? Yeah, that's a good question.
• 31:35
  And actually an area of maybe some active development for us
• 31:40
  right now. So our our sandbox supports the
• 31:41
  notion of of opening tunnels. So when you first launch a
• 31:45
  sandbox, by default there's no network access to it.
• 31:49
  But you can say, hey, I'd like to create a tunnel.
• 31:52
  I'd like to be able to route network access to this.
• 31:54
  And and some people use this to implement like a product UX,
• 31:57
  right? Like they might have a, a front
• 31:59
  end server running pick a place right for sale, railway,
• 32:03
  whatever. And then they launch an agent
• 32:05
  and then they want to communicate with the agent.
• 32:07
  They might open a tunnel. We, we support web sockets, you
• 32:11
  know, HTTP, whatever. But what you can do if you want
• 32:15
  the agents to talk to each other as you can open the tunnels and,
• 32:18
  and they can talk to each other over the tunnels. 1 area that
• 32:22
  we're starting to look at now. The, the, the, the folks at Lang
• 32:26
  Chain and the deep age of team has been encouraging us to look
• 32:29
  into this is a notion of what it looks like for these agents to
• 32:32
  potentially have a shared file system.
• 32:35
  So if each sandbox is totally isolated, what does it look like
• 32:39
  if you mounted some sort of shared file system so they could
• 32:42
  communicate through the file system and that would be this
• 32:47
  potentially interesting. It's not, we have not, this is
• 32:52
  not something that is like imminent from a product
• 32:54
  perspective, but it's probably, they're probably a couple things
• 32:56
  that we're going to prototype soon.
• 32:58
  Or a notion of volume mounts like, OK, how do I have a notion
• 33:03
  of a part of the file system that I can save, you know,
• 33:07
  because when the dead box is gone, it's gone.
• 33:09
  But how do I have like an output directory that gets saved some
• 33:12
  place where I can, I can retrieve the agents, you know,
• 33:15
  intermediate work or it's notes or whatever later.
• 33:19
  And then, hey, well, I mean, once you have like some sort of
• 33:22
  file system abstraction that you're saving outside of the
• 33:26
  dead box, what if it was read, write shareable?
• 33:29
  So these are these are things we're toying with.
• 33:31
  We need to make sure we have the right use cases and the right
• 33:35
  technology before we actually turn it to product, though.
• 33:38
  And so right now has the philosophy been very much along
• 33:42
  the lines of cattle not pets type ideas.
• 33:46
  Cattle, not pets. Meaning like the.
• 33:52
  I don't know if you remember that like in the I heard it from
• 33:56
  DevOps folks where they would say you want to treat your
• 33:58
  Kubernetes clusters like cattle where you're OK killing them at
• 34:04
  any point in time or them dying. And as a vegetarian, I'm just
• 34:09
  going to say I do not like this. But it was what I heard.
• 34:15
  And lightning. Strikes happen.
• 34:17
  I got you. I got you.
• 34:19
  I got you. Yeah, I think.
• 34:21
  I think it's also just, it's, I think a, there's that like,
• 34:25
  which is just like, I think effectively what you're talking
• 34:27
  about is like recoverability, like if something got halfway
• 34:31
  done and I don't know, like, you know, we run on top of AWS and
• 34:35
  other cloud providers. They're good, but they're not
• 34:38
  perfect. Machines do go away, right?
• 34:41
  So that would be like a recoverability argument, like
• 34:44
  like how do I like recover if an agent went away?
• 34:47
  I think maybe the more interesting thing though, is
• 34:49
  just like what happens? Like does that allow interesting
• 34:53
  like interagent coordination opportunities?
• 34:56
  You know, you could imagine you could have a pipeline where you
• 34:58
  had agent A on on one dead box and agent B and then agency all
• 35:03
  on separate dead boxes. And you know, you start off a
• 35:06
  pipeline by asking agent A to do something and it writes
• 35:08
  something to a file system. Then you tell Agent B to read
• 35:11
  that and continue working on it. So, you know, you might, you
• 35:16
  know, and so on. It could pass the agency.
• 35:18
  So you might end up just having different like orchestration
• 35:22
  patterns that you make available too.
• 35:25
  But this is this is a little forward-looking, you know, I'll
• 35:29
  be sure, I'll be sure to give you give you an e-mail update.
• 35:33
  Yeah, an update when we when we start to formalize some of these
• 35:36
  things. Well, it also feels very much
• 35:40
  like the idea of giving the agents memory in a way, and how
• 35:45
  you can let these ideas, whatever it is that they're
• 35:48
  working on or whatever they've learned, how can that persist
• 35:52
  throughout after the sandbox isn't around anymore?
• 35:57
  Yeah, yeah, I think precisely. And what if the you know, can
• 36:02
  you let agents self author skills or tools for themselves
• 36:05
  and save those? I think starts to pass it to the
• 36:08
  next one. Yeah, yeah, yeah.
• 36:11
  I think that's where this starts to become like, quite
• 36:13
  interesting. Well, there is another thing
• 36:16
  that I wanted to get into around like frameworks versus harness
• 36:20
  and I thought you had some great points on that.
• 36:24
  Can you break down like how you look at these two things?
• 36:29
  I think, you know, kind of the observation, I, I think it's
• 36:32
  Harrison Chase from Lang chain is, is been kind of pushing this
• 36:35
  like distinction of framework versus harness.
• 36:39
  And I actually think it's a pretty important one.
• 36:41
  I agree with him on this one. And I think that we're about to
• 36:45
  see a lot of people take advantage of these harnesses, so
• 36:48
  to speak. They just make it much easier
• 36:51
  for them to take like a really capable agent like Claude code
• 36:54
  or a deep agent and then build on top of it with their own kind
• 36:58
  of customizations. I think the harness approach
• 37:01
  just it's, it's more batteries included.
• 37:03
  It just makes it easier to, to accomplish a, a goal, you know,
• 37:06
  still power users will build, I'm sure from the ground up
• 37:10
  their own stuff, you know, like startups that are exclusively
• 37:14
  tackling one specific thing. But for people out there who are
• 37:17
  looking to build like simple workflows or just automate
• 37:20
  simple things, I think this will be very powerful.
• 37:24
  And I'm not sure if I fully understood what harness is
• 37:28
  exactly. When you're using something like
• 37:31
  the Cloud Agent SDK or Lang Chang Deep Agent, you're kind of
• 37:36
  assuming that what is already there is already good at
• 37:40
  managing context, doing things like planning and doing things
• 37:43
  like tool calls. And maybe you provide additional
• 37:47
  tools, but you're maybe not really writing the code for to
• 37:52
  implement tool calling or you're not really writing the code to
• 37:55
  manage context. Like I'm sure if you use Cloud
• 37:59
  code, you see where it compacts its conversation and stuff like
• 38:01
  that, right? Like doing that really well is
• 38:04
  hard. I'm sure you know, startups out
• 38:07
  there that are purely agentic startups are going to have their
• 38:10
  own stuff top to bottom because they're a specialist and what it
• 38:13
  is they do. The people out there are looking
• 38:16
  to build an agent that takes 2 PDFs and turns them into one
• 38:20
  database entry. They might be able to build on
• 38:24
  top of this and be like, great, I have this PDF reader skill.
• 38:27
  I have this like, here's my schema export to database skill.
• 38:32
  And like, I'll just give you these inputs.
• 38:34
  You know, how to call tools and skills.
• 38:37
  You know, if they're using Claude Agent SDK, I'll just
• 38:40
  build on top of you. And you're a very capable kind
• 38:43
  of harness for managing contacts, invoking tools, making
• 38:49
  a plan and sticking to it and updating the plan.
• 38:53
  And I think it's, it's really, I think the distinction is more
• 38:55
  about how many batteries are included and how much does the
• 38:58
  thing just do for you out-of-the-box without you
• 39:00
  needing to do that much. I hadn't even thought about how
• 39:06
  with Lane Graf it was very that determinism, you're always
• 39:12
  playing with a determinism versus non determinism model or
• 39:18
  way that you want to build your agent.
• 39:20
  And with Lane Graf, you could get very detailed on, I want you
• 39:26
  to do this and then I want you to do that.
• 39:28
  And then if you need to, you have a loop and you you keep
• 39:31
  doing that. And then once you get this
• 39:33
  information, you go and do that, right.
• 39:36
  But Harness throws all of that out the window, if I'm
• 39:41
  understanding it correctly. And it's saying it comes with
• 39:45
  the ability to know what it needs to do next.
• 39:48
  Good enough? Yeah, I think if you look at how
• 39:52
  like like the the Claude Agent SDK implements skills, you can
• 39:57
  kind of you can do it as natural language in a skills MD file.
• 40:02
  You can like kind of specify like do A then do B then do C
• 40:05
  and then the harness is good enough at ingesting that and
• 40:09
  doing it. I think for deep agents, let me
• 40:13
  I believe it's called a feature. So their notion of a skill I
• 40:17
  think is called a feature, but. It's a similar concept.
• 40:21
  So you're, instead of you coding that you're saying here are kind
• 40:28
  of workflow primitives or like sequences of steps I want you to
• 40:32
  take. I'm going to put them in feature
• 40:34
  files or skill files. And then you're dependent on the
• 40:37
  harness to be like adapted if following those, you know,
• 40:41
  again, for I think for easier use cases, you're taking
• 40:44
  advantage of the fact that the that these agent harnesses are
• 40:47
  just getting smarter and smarter and hopefully you have to do a
• 40:50
  little less to get an equivalent result.
• 40:52
  I think that's that's kind of the maybe the a better
• 40:55
  crystallization of what it was I was trying to say.
• 40:58
  Yeah. I think directionally this is
• 41:01
  going to keep happening too. Like I think it's going to get
• 41:05
  easier. These underlying cores are just
• 41:08
  going to get more and more powerful to the point where, you
• 41:10
  know, the same with Kodak's as well, you know, not to leave
• 41:13
  them out of the conversation, but you know, they, they have
• 41:17
  the advantage of huge use. They can tune models
• 41:21
  specifically for their own agents.
• 41:24
  You know, they can invent their own kind of protocols and, and
• 41:27
  conventions for things like skills and MCP.
• 41:32
  And I think maybe at least for people doing relatively simple
• 41:36
  agents, I think it's going to be much easier to just use these
• 41:39
  harnesses. Does make a lot more sense
• 41:42
  because I remember seeing a lot of friends graphs in in lane
• 41:50
  graph that had a lot of different nodes and a lot of
• 41:53
  different steps and there was a lot of logic behind you do this
• 41:58
  and then you do that. And then if if you have this or
• 42:00
  if you have that, like think about it or here's some.
• 42:04
  It was almost like a glorified workflow.
• 42:07
  And I do know that the workflows in a way are still quite
• 42:11
  valuable. And I was just talking to a lot
• 42:14
  of folks when I was in Amsterdam last week about how they'll
• 42:17
  bundle up a workflow. If they see that these three
• 42:21
  tools are generally called together, then they'll just
• 42:26
  bundle that up into a workflow, You know, because it's not like
• 42:31
  we want to have any question about if you're calling this
• 42:37
  tool and then this tool, you don't call that tool because
• 42:41
  it's just like, no, these are the three tools.
• 42:43
  They're always called together. And we're trying to abstract up
• 42:47
  one level on the tool calling. And it, it feels like this idea
• 42:56
  of harness is very much that. Like when we had Sid on here
• 43:00
  from Claude Code, he mentioned one of the biggest things that
• 43:06
  folks were building agents these days are grappling with is how
• 43:09
  much harness is too much harness.
• 43:12
  I think that's one of the things that Cloud Code really excels
• 43:14
  out as well too, is tool use. It's a little bit of a tangent,
• 43:17
  but yeah, it's very, it's very judicious about when and how it
• 43:21
  uses tools. Speaking of the tools and the
• 43:27
  agents being able to execute tools, going back to that
• 43:32
  conversation with Sid, he mentioned that a lot of their
• 43:38
  big improvements and performance gains that they saw with Claude
• 43:42
  code was when they were deleting stuff from what Claude code had
• 43:48
  to do. And so instead of saying like it
• 43:51
  needs to use this bash tool, it would just say like, here's how
• 43:57
  bash works. You go and figure out and create
• 44:01
  your own bash command, you know, and things like that, which ties
• 44:07
  into the environment. And it also ties into another
• 44:12
  thing that I've heard is very difficult with agents, which is
• 44:17
  the verification or the making sure that if you wrote something
• 44:24
  as you mentioned earlier, does it actually does it build?
• 44:29
  Can you compile it and will it run afterwards?
• 44:32
  Or is this just some random thing that looks better?
• 44:36
  But doesn't work. Yeah, yeah, I think the the bash
• 44:42
  point you made is kind of goes back to the give give agents
• 44:45
  their own computers point bash. Like if I don't know if you've
• 44:50
  ever had a friend who is like one of one of my Co workers is
• 44:53
  just like unreal with bash. He'll chain like 30 commands
• 44:56
  together. I mean, I'm, I'm a capable bash
• 44:58
  user, but like he's next level. But you know, something like
• 45:04
  bash, you can do almost anything.
• 45:06
  There's like, I mean, we're talking about 50 years of like
• 45:10
  Unix tooling that has gone into this kind of overlooked program,
• 45:15
  which is bash between like awk and said and RIP crap and get
• 45:19
  crap and like JQ and like pipes like you can do almost anything.
• 45:26
  So to some extent this kind of goes back to the like give an
• 45:30
  agent a computer like what you were just kind of observing was
• 45:33
  like, hey, like, you know how Bash works.
• 45:35
  You know, the common tools in Bash, like use them.
• 45:39
  I don't know how often you use any of these kind of CLI tools
• 45:43
  for coding, but you'll often see like if you ever like move files
• 45:47
  or do stuff like that, you'll see, you know, in a larger code
• 45:50
  base, you'll see that they're like, Oh my God, there's too
• 45:52
  many references to the file you just moved for me to hand edit.
• 45:56
  I'm going to write up my own bash script and they'll do is
• 45:59
  they'll do like get grab pipe X args pipe said to like replace
• 46:05
  imports or like, you know, and you're like kudos, like no one
• 46:11
  had to write a tool for that. Like you, you're you are able to
• 46:14
  use like a composable accessible tool that is your own computer
• 46:18
  in a in a way that is like empowering to to you as an
• 46:22
  agent. So I I think that is like that
• 46:25
  is pretty cool argument for for less is more and having like,
• 46:30
  you know, more powerful basic tooling components being a real
• 46:34
  lift. What else is on your mind these
• 46:38
  days? When Enterprise is really going
• 46:43
  to get going a little bit more with agents, I think it's quite
• 46:46
  interesting. I think that everyone has used
• 46:49
  by hand, you know, some form of coding agent or, you know, if
• 46:55
  you're a curious, you've authored an agent and seen how
• 46:58
  powerful they are. But I think it'd be very
• 47:02
  interesting to see when enterprise kind of starts to
• 47:04
  catch up and you start to see more like actual agents live in
• 47:08
  production for, for enterprises. I think that's going to be an
• 47:12
  important part of just the broader industry life cycle,
• 47:15
  right? Like, you know, enterprise
• 47:17
  adoption, I, I think it's important.
• 47:20
  Is there are there some things that you feel like are big
• 47:25
  blockers to that right now? Yeah.
• 47:29
  I mean, yeah, so, OK, good leading question.
• 47:32
  So well, I'll finish my other two curiosities, which I think
• 47:35
  are related to what you just asked.
• 47:37
  I think I'll also be curious to see the future of of MCP and of
• 47:41
  of things like skills. I think these are all important
• 47:46
  components. I would say to your question
• 47:49
  like what are the blockers? I would say until recently with
• 47:52
  some of these harnesses, it was, it was, it was hard to build
• 47:56
  agents. It wasn't impossible.
• 47:58
  But like I, I, I do think that like the batteries included
• 48:02
  aspects of these kind of harnesses like Clot agent SDK
• 48:05
  and Lang chain deep agents and Codex SDK are going to kind of
• 48:08
  democratize it or make it easier for people to build agents so
• 48:11
  successfully. So I think that was one piece.
• 48:15
  I think people are still in their head deciding on it.
• 48:19
  But I think, you know, having a very simple isolated sandbox on
• 48:23
  time environment like what we're building, I think that's an
• 48:27
  important piece of the puzzle. Like companies like mine, there
• 48:30
  are other people trying to do this stuff there.
• 48:32
  There are a lot of cool companies innovating in the
• 48:33
  space, but kind of the existence of a very easy deployment fabric
• 48:38
  that's secure for deploying and observing and auditing agents I
• 48:41
  think is important. I think another thing that like
• 48:46
  MTP and to a lesser extent skills kind of addresses how do
• 48:49
  you actually get contacts into those agents.
• 48:53
  I think there are a lot of people working on making the off
• 48:55
  story around MTPA little more graceful.
• 48:57
  I think that's going to be an important piece of the puzzle.
• 49:02
  You know, basically giving short lived read only credentials
• 49:05
  access to to these agents to operate in an enterprise
• 49:08
  environment is going to be important.
• 49:10
  And well, I have one more that I'll add.
• 49:13
  I think one of the reasons that agents have been so successful,
• 49:18
  there are many reasons, but why they've been so successful in
• 49:20
  coding so far has been the pre existence of a workflow that
• 49:26
  lends itself to agents being involved.
• 49:28
  And what I really mean is things like get in poll requests, you
• 49:36
  know, you and I are engineers. Let's say we were working on
• 49:39
  something together and you're like, hey, John, can you add
• 49:42
  something built in to get? Is this effectively like, you
• 49:48
  know, immutable audit log of every change that's taken place
• 49:52
  in the repository? And not only does it have this
• 49:55
  audit log, right, it has this wonderful feature of just a
• 49:59
  convention by when I want to make a change, I'm going to send
• 50:01
  you a review and you're going to look at it and say that's good
• 50:04
  or bad or John, that's junk. Change this.
• 50:07
  And then once you've approved it, you're not both of our names
• 50:10
  are on it and it gets added. And there aren't that many other
• 50:14
  systems with those proper properties, right?
• 50:16
  Like like lawyers, I guess you have red lines in like Microsoft
• 50:21
  Word or something like that, but you don't have like a proposed
• 50:25
  review like journal approach, right?
• 50:29
  Like for, for most other, most other that I'm aware of
• 50:34
  professional workflows. And I think that that's actually
• 50:37
  like, that'll be like, let's just say MCP and all the all
• 50:41
  stuff is magically solved. And you know, companies like
• 50:44
  mine and and others like it trying to build this sort of
• 50:46
  fabric are perfect and deployed everywhere.
• 50:49
  And these harnesses are so great.
• 50:50
  You can just drop a bunch of skills and a few MCP tools in
• 50:54
  and everything just works. I think that still of the piece
• 50:56
  I just described to you is, is going to be an important
• 51:00
  workflow component that I think is still kind of missing.
• 51:02
  Like what is the pull request of like an insurance claim auditor?
• 51:07
  Yeah, or a marketing. App or any any other industry
• 51:11
  really right like and I think that it's really a a notion of
• 51:15
  like staging, reviewing, accepting work and committing it
• 51:18
  and having the ability. Maybe it's unclean or harder in
• 51:22
  those other kind of spaces to revert right like you do it get
• 51:25
  reverts like pretty straightforward, right.
• 51:29
  Maybe it's a little harder to reverse a a table update in work
• 51:33
  day or Salesforce or something like that.
• 51:36
  But I think that that like, I think that's like there's just
• 51:40
  something I'm noodling. I was not, I don't, I don't
• 51:41
  really feel it as run the problem, but I view it as like a
• 51:44
  broader industry problem of like, what is the GitHub of like
• 51:49
  all these other systems that agents need to interface with?
• 51:52
  Because the, you know, the GitHub thing makes it quite
• 51:55
  natural for you to have like a, a, you know, an agent that
• 51:58
  you're like, I go like do a pull request to update these
• 52:01
  dependencies or something like that.
• 52:02
  And then you review it and you're like, yeah, it passed the
• 52:04
  eye. It passed the eye.
• 52:07
  It looks sane to me. I approve.
• 52:09
  Done. And if something's wrong, we can
• 52:11
  refer. But also it has that ability of
• 52:16
  does it run or does it not? Yeah, the CI step is important
• 52:20
  too. Yeah.
• 52:22
  And like kind of it's kind of a funny thing where you're just
• 52:25
  sitting in this like rather highly evolved tooling ecosystem
• 52:30
  you kind of take for granted and you just don't, you know, it's
• 52:34
  not top of mind that like other industries don't necessarily
• 52:37
  have this or maybe I'm wrong. Maybe some of these other
• 52:39
  industries do have these things and I I don't know, but I think
• 52:43
  this is. Ubiquitous.
• 52:45
  Yeah. Definitely not as common.
• 52:47
  It's yeah. I don't think there's a GitHub
• 52:48
  for lawyers. No.
• 52:52
  And I wonder too if that is one of the reasons that the training
• 53:01
  has been so valuable on all of this data.
• 53:04
  Like I I'm not sure the insurance and outs on how they
• 53:08
  trained the models specifically like these, you know the cloud
• 53:13
  model, but did they train it on the actual issues and the PRS as
• 53:20
  much as they trained it on the code?
• 53:22
  Yeah, yeah. Well, you, you, you now have.
• 53:25
  So you're you're you're surfacing an important
• 53:29
  observation, which is that like your pull request log includes
• 53:33
  the motivation, the rationale, as well as what them, like
• 53:37
  presumably ultimately a human did to solve that problem.
• 53:41
  So I think that's very powerful. I think there are other aspects
• 53:44
  of code that just landed to it being one of the first things
• 53:47
  for AI to be great at. You know, it's a it's a more
• 53:51
  concise, it's not an open-ended language like human language,
• 53:54
  right. Like you, there's only, you
• 53:55
  know, there's strict syntax, there's a strict set of
• 53:58
  keywords, but maybe you know, as importantly, you have like
• 54:02
  deterministic verification functions that you don't have
• 54:06
  for natural language, right? Like I, I can say, you know,
• 54:12
  Claude or deep agent or whatever, Kodak's write me hello
• 54:15
  world and it can deterministically verify that it
• 54:19
  correctly did that job. It can compile.
• 54:22
  That's one deterministic tool. It's able to run, you know, it
• 54:25
  can also run things like linters and formatters, but then
• 54:28
  ultimately it can also just run the code and be like, did it say
• 54:30
  hello world? You know, like think now about a
• 54:34
  lawyer, like a lawyer proposing some sort of legal doc has no
• 54:39
  tool that says like, yo compile that.
• 54:41
  Like did it say John's deserves to do whatever?
• 54:44
  I'm writing the note like there's there's no deterministic
• 54:48
  verification functions. And what those deterministic
• 54:50
  verification functions that AI do is, is self play.
• 54:55
  They can go try things and they can discover things that don't
• 54:59
  work and then they can ultimately discover things that
• 55:01
  do work. This can go back into their pre
• 55:03
  train. They learn.
• 55:06
  It's almost like kind of like the alpha go thing, right?
• 55:08
  Like the alpha go thing, like the OGAI moment from Google
• 55:12
  where they just basically let the AI self play against itself.
• 55:16
  And it just had to observe the rules of alpha go and there was
• 55:19
  a deterministic scoring function of who won.
• 55:23
  And they just let it run and run and run and run and it learned
• 55:26
  novel things. I guess there are many aspects,
• 55:29
  but I think that the deterministic scoring function
• 55:31
  is a big one. The the the strict syntax, the
• 55:35
  availability. Fast feedback, you understand,
• 55:38
  Like when you're talking about this lawyer use case, you
• 55:42
  probably don't get as fast of a feedback loop, especially if you
• 55:46
  now have to let it go through court that's going to take
• 55:50
  months or. Well, and think about it too,
• 55:53
  right? You make a program like some
• 55:55
  trivial programming error, like a lender or a builder is going
• 55:59
  to tell you what line it was on. Like there's no like, there's no
• 56:04
  like make for like law. And even if there was, and it
• 56:10
  was correct in California, it'd be wrong in some other state.
• 56:13
  Yeah, how would that even look? That is.
• 56:16
  So. True.
• 56:17
  And that's not just for law, but as you were mentioning before,
• 56:20
  insurance, any of these areas that we play in that isn't so
• 56:25
  clear like does this compile or not?
• 56:29
  So I think that the next area is where where you'll start to see
• 56:32
  like rapid growth will be things where you have some sort of a
• 56:35
  verification function. It might not be as clean and as
• 56:39
  perfect and complete. It's like the tooling we have
• 56:41
  and and software engineering. And I do think that I don't know
• 56:47
  if this is the right term for it, but like the GitHub of
• 56:50
  vacation of like workflows is going to be important.
• 56:53
  It could be, it could be that that someone figures out a very
• 56:57
  generic and extensible way to have like a staging environment
• 57:01
  that like outputs work that people approve or don't.
• 57:05
  That's maybe more open-ended. But I think that's that's going
• 57:08
  to be ultimately another important piece of this puzzle.
• 57:12
  That is so cool to think about the Githubba fication of other
• 57:18
  areas of work and how valuable that will be for the future
• 57:23
  agents of the world. I think, I think it's important,
• 57:27
  I think it's missing it's like agent have these inputs produce
• 57:31
  that output, human being acts reviewed it, it was pushed into
• 57:35
  Salesforce or work day or whatever system.
• 57:39
  Or rejected and told to go back to the drawing board and fix.
• 57:43
  These points and then turned into a benchmark.
• 57:47
  See, you get it exactly.