# [AIEWF Preview] Containing Agent Chaos — Solomon Hykes

Latent Space · 2025-06-03

<https://addtry.com/abc57f5d-b67e-45ab-aaf4-97e073969d89>

Solomon Hykes, creator of Docker and founder of Dagger, argues that the industry needs an open standard for AI coding agent environments to avoid repeating the fragmentation seen before Docker. Dagger, a workflow engine originally built for post-development automation (CI/CD), is now being pulled by its community into the agentic space to solve environment isolation, portability, and observability for concurrent agent teams. Hykes insists containers are the right base layer but require a new, agent-native UX—unlike legacy Dockerfile or Compose—that is decoupled from any IDE, model, or cloud provider. He critiques current vertical monoliths (e.g., proprietary IDE-hosted agent environments) and advocates for a Lego-like modular approach where the environment is the standard linchpin. Dagger integrates with existing stacks rather than replacing them, and Hykes previews fresh, unreleased content for his upcoming keynote at AI Engineer World's Fair.

## Questions this episode answers

### Why did Solomon Hykes say standardizing agent environments is his biggest idea since Docker?

Solomon Hykes believes the current fragmentation in coding agent environments mirrors the early cloud era that Docker disrupted. He argues that without a standard, portable, isolated environment for agents, developers will be locked into monolithic IDEs and cloud providers. Hykes aims to create an agent-native environment that acts as 'the linchpin that connects everything else,' enabling teams of agents to work in parallel while being fully observable and locally executable.

[2:47](https://addtry.com/abc57f5d-b67e-45ab-aaf4-97e073969d89?t=167000)

### What is Dagger and how is it being applied to AI coding agents?

Dagger is an open source workflow engine for automating software delivery, originally focused on CI/CD. According to Hykes, its community of platform engineers started pulling it into AI agent applications because it provides clean, container-based environments for running agent loops. For coding agents, Dagger offers perfectly isolated and portable environments that decouple the agent's workspace from any specific IDE or cloud, enabling parallel agent work and custom tool integration.

[3:12](https://addtry.com/abc57f5d-b67e-45ab-aaf4-97e073969d89?t=192000)

### What design principles does Solomon Hykes think are crucial for coding agent environments?

Hykes outlines that agent environments must ensure strong isolation so multiple agents can run in parallel without conflict, be portable across different models and cloud providers, provide full observability of agent actions, and allow both humans and agents to interact. He emphasizes that local execution capability is a vital test of a solution's ubiquity, and the design should follow a Lego-like balance between simplicity and modularity.

[9:16](https://addtry.com/abc57f5d-b67e-45ab-aaf4-97e073969d89?t=556000)

### How does Dagger’s modular approach differ from end-to-end platforms for coding agents?

Hykes contrasts Dagger with end-to-end platforms by explaining Dagger is not a full stack but a modular engine that integrates with users' existing infrastructure for authentication, storage, and CI. It acts as a component that improves the overall system without forcing replacement. This Lego-like approach allows platform teams to compose customized agent workflows while avoiding vendor lock-in and maintaining local execution support.

[24:01](https://addtry.com/abc57f5d-b67e-45ab-aaf4-97e073969d89?t=1441000)

## Key moments

- **[0:00] Intro**
  - [0:33] Dagger is an open-source workflow engine that turns semi-automated scripts into modular container-based workflows, says Solomon Hykes.
  - [1:01] Dagger's core community is platform engineers who design the factory to enable developers, Solomon Hykes notes.
- **[2:37] Agent Environments**
  - [3:12] Solomon Hykes recounts how Dagger, originally not an AI company, was pulled into the AI space by platform engineers experimenting with LLMs in CI/CD workflows.
  - [5:14] Solomon Hykes says Dagger brings CICD technology to coding agents to provide isolated, reusable, portable environments that prevent cloud and model lock-in.
- **[6:24] Design Constraints**
  - [7:19] Solomon Hykes asserts containers are the base layer for agent environments and tooling must be redesigned for agent-native UX, not just taped onto old tools.
  - [8:31] Solomon Hykes: 'For dev environments, it really hasn't moved that much... most people don't develop in a container still... that's just a failure of tooling.'
  - [10:55] Solomon Hykes predicts the industry needs a standard on the agent environment, not the entire stack, to avoid fragmentation and monolithic platforms.
- **[11:24] Agent-Native UX**
  - [12:43] Solomon Hykes: 'Dockerfile was a stopgap prototype... it's not agent native. It never will be.'
- **[14:02] Workflow Parallels**
  - [14:21] Solomon Hykes uses Lego as the model for modular systems: 'Lego is genius... That's what everyone in this space should be trying to do.'
  - [16:24] Solomon Hykes predicts CI/CD and agentic systems will converge, with CI becoming runtime infrastructure for agent-driven coding workflows.
- **[17:37] Local Execution**
  - [20:12] Solomon Hykes: 'CICD has no good local story... local execution is a good test. Whatever solution you're imagining, does it support local execution?'
- **[21:00] Adoption**
  - [21:09] Q: What does it take for a big cloud or lab to adopt Dagger? A: Solomon Hykes says scale doesn't help as much in dev experience, giving startups leverage.
- **[22:55] Modular Design**
  - [24:21] Solomon Hykes explains Dagger is a modular component that integrates with existing stacks, not an end-to-end platform, avoiding forced auth or UI changes.
- **[25:11] Closing**
  - [26:06] Solomon Hykes hints his upcoming keynote may feature brand new original content beyond the workshop, with a 50% chance if ready in time.

## Speakers

- **Alessio** (host)
- **Wix** (host)
- **Solomon Hykes** (guest)

## Topics

Agent Platforms

## Mentioned

AWS (company), Bolt (company), Microsoft (company), OpenAI (company), Dagger (product), Docker (product), Git (product), GitHub Actions (product), Gitpod (product), Kubernetes (product), MCP (product), Temporal (product)

## Transcript

### Intro

**Alessio** [0:04]
Hey everyone, welcome to a Latent Space Lightning Pod. This is Alessio, partner and CTO at Decibel, and I'm joined by my co-host, Wix, founder of Small AI.

**Wix** [0:11]
Hello, hello, and today I'm so happy to have Solomon Hykes join us. Uh, Solomon, you're most famously the creator of Docker.

**Solomon Hykes** [0:19]
Hi, thanks for having me.

**Wix** [0:20]
You started Dagger six years ago, and, uh, I think originally it was pitched as some sort of infrastructure provisioning thing. I, I'm sorry, I'm pro- I'm probably totally mangling this in front of you. How do you introduce Dagger today?

**Solomon Hykes** [0:33]
So Dagger is, um... I think six y- yeah, six years I guess sounds right, yeah. Um, it's a, it's a workflow engine. It's a, it's an automation tool for software teams that wanna deliver software faster and more efficiently.

And it takes all these workflows that are usually semi-automated with artisanal scripts, you know, your builds, your tests, your kind of end-to-end pipelines, and it turns them into robust modular workflows that you can drive with codes, and it all runs in containers.

So it's highly portable, highly isolated. Uh, you can run them locally or in CI, which saves a lot of time. And we're an open source platform. Uh, we've got a very active and engaged open source community, mostly made of platform engineers.

You know, those systems engineers that actually design the factory and run it and enable the developers on a team to be more productive. So that's our core community.

**Wix** [1:27]
Yeah. In some ways-

**Solomon Hykes** [1:29]
And just-

**Wix** [1:29]
Uh, yeah, sorry, go ahead.

**Alessio** [1:29]
I was gonna say, just to make that clear, these are both pre-development, so spinning up an environment for people, and then also between you're done writing the code and getting it ready for production. Are those basically, like, the two entry points?

**Solomon Hykes** [1:42]
It's-- We started mostly post-development. So anything that happens after you've saved and you're ready to see what happens next, you know, build tests, y- you wanna take that live. So there's that delivery loop, right? We've been focusing on making that delivery loop more efficient because it's, it's really terrible in most places.

And, and it just, there's a lot of inefficiencies that could be cleaned up. In a lot of ways it's, it's a cobbler's witho- you know, the cobbler has no shoes situation. Like, those platform engineers, they spend all their energy and their significant experience helping developers get the best possible tooling and the best possible experience.

But they themselves, for their own tooling, it's, it's sort of like, "Okay, we gotta cobble this together with bash scripts and YAML." So we've been focusing on that post-development. Although recently we're getting pulled into the dev loop, in part because of this crazy change that's sweeping the whole market, right, with agents.

### Agent Environments

**Wix** [2:37]
Yeah. So I, I think let's k- kind of run right into that. Obviously, there's a lot more of context on Dagger and Docker that you've done prior, but we, uh, you know, we are an AI podcast, so, like, why not?

Let's just, let's just go right into it. A few months ago, you messaged me and you were like, "I think this is the biggest thing I've-- biggest idea I've had since Docker itself." And I was like, "What?" Like Docker is very big.

What is your context going into the AI builders? In some ways, I alway- I've always said basically, like, to us dev tools people, it is just more of the same. Everything that you wanted, you j- you just need 100X more.

So how, how do you, how do you, how did you approach this?

**Solomon Hykes** [3:12]
Yeah. We, we, we didn't think of ourselves as an AI company. We got pulled into it by our community, our users. Because although Dagger is primarily used to build CICD pipelines, uh, historically, we've never thought of ourselves as a CICD company.

We like to build platforms from first principles, and then we encourage our community to go and apply it. So what we have is an engine for automating workflows and making them reliable, portable, and giving them very, um, very clean environments to run in.

And the environment is key. And of course, we use containers because that's what we know, and the container tech still today is underutilized, misunderstood. It, it, it can do so much more. So the, our community pulls us into this AI space because of agents, because, uh, these platform engineers start messing with agent loops.

They wanna insert LLMs into their workflows, and now it's becoming more popular to, to run agents in the context of your CI to automate more parts of your delivery. And then they started showing us that everybody wants to use these coding agents now.

You know, so if you're a developer, increasingly, your job is not gonna be to actually develop, but to manage and enable these coding agents. And we're at the very beginning of this. You got this one agent in your IDE helping you, but now you want more than one, right?

You want a team of agents sort of doing the work for you, and that, that transition from team of one to a team of multiple coders, uh, that's basically what our community deal- community deals with, these platform engineers.

So what we're witnessing is developers becoming platform engineers. They're-- They have to learn how to enable others to be productive. These others, of course, are AIs. Uh, and to do that, they have to give them environments to work in.

And you can see the problem when you see someone live streaming their, their vibe coding, right? Everyone's vibe coding. But you can kind of make one set of changes at a time. You're kind of-- Everyone's sort of messing with this dev environment that, uh, that really isn't cleanly isolated.

So what we're doing is we're taking this technology that we invented for CICD and bringing it into the coding agent's environment and giving your agent basically a, a perfectly isolated, reusable, and portable environment so that you're not completely locked into this one app connected to this one model running on this one cloud infra provider, right?

You want the environment where the agent does its work to be decoupled, to be its own thing that you can manage and look at, and then move to another platform if you want, right? That's sort of what happened with Docker in the previous wave when everyone was adopting cloud technology, right?

Everyone was building these big platforms, uh, and they had everything But they were highly fragmented. They tried to kind of cobble everything together like a monolith. So you didn't have this portable environment that you could carry around with you.

You were trapped in one big platform. And the same thing's happening now. So we wanna use our experience from the past to enable this new generation of developers to really unlock the potential of these coding agents. That's, that's, that's what I'm excited about.

**Wix** [6:24]
Yeah. I think, like, the scope of what people do for coding agents today is maybe kind of like single VM, let's call it.

### Design Constraints

**Solomon Hykes** [6:33]
Mm-hmm.

**Wix** [6:34]
Especially the, the coding agents from the big labs, they don't even have internet access. They have, like, pre-installed libraries and, like, it's very, very limited. And it could be so much better if there were standards for it. I think obviously the standard needs to be open source.

Um, and but then, like, there, there's a question of, like, the design constraints that you are coding for.

**Solomon Hykes** [6:52]
Yeah.

**Wix** [6:52]
I think that, uh... So for example, Gitpod is another, uh, demo and person I've-- part market participant I've seen, where they're like, "Yeah," like, "we, we really need to isolate, like, this kind of like almost like a mini VPC."

Like, you need the, you need the networking sorted out and, and you need, uh, storage, everything, right? Like, just, uh, the, all the fundamental units of compute. So like, I, I guess like what is the container here? Like, what, what is that concept here-

**Solomon Hykes** [7:18]
Well-

**Wix** [7:18]
... the unit of isolation?

**Solomon Hykes** [7:19]
It's still actual containers-

**Wix** [7:20]
Yeah

**Solomon Hykes** [7:20]
... as the base layer. That's the, that's my, the first insight here. Like the, you don't have to reinvent the core technology. It already exists, but you gotta rethink the tooling because the tooling as it stands, I mean, honestly, it's, it's a little frustrating for me because we, we busted our ass on Docker and we built this whole ecosystem, and we invented the Dockerfile and Docker Compose and the format and the CLI and then, you know, we, we kind of messed up on the follow-through and, and at some point Docker basically stopped innovating and I left and, and the ecosystem continued around containers, but it didn't actually pick up where we left off.

Everything towards applying container tech to development kind of stopped and, you know, there's still a lot of interesting experiments, but it's, it never had the unity of purpose that this initial movement had and so you have fragmentation, right?

No standard really emerged beyond Dockerfile, Docker Compose and that's it. All the effort went into infrastructure, you know, Kubernetes, scalable storage, scalable networking. You know, that kept moving real-- a lot and if you go to KubeCon or any of those events, like you see all the infra people applying containers to solving that problem.

But for development, for dev environments, it really hasn't moved that much. Use containers would be the, my first, uh, recommendation. But then, yeah, I just, I just think you gotta l- you know, design a solution from first principles.

It's just a difficult design problem and I'm very excited because there's an opportunity to go through this design process again from first principles. So yeah, maybe, I mean, I'm aware of Gitpod of course. Uh, you know, there's dev containers as a standard in IDEs and there's a million other products out there, but none of them have convinced the majority of humans to develop in them with their tool.

It's very fragmented. In fact, most people don't develop in a container still, right? They just develop on their laptop. That's just a failure of tooling.

**Wix** [9:14]
But-

**Solomon Hykes** [9:14]
So yeah, I think it's, it's anyone's game-

**Wix** [9:16]
Yeah

**Solomon Hykes** [9:16]
... how to apply the, the container, container technology to the perfect developer experience. But the, the criteria are it has to be well isolated. Like you should be able to have a bunch of agents working in parallel and they don't mess each other's work up.

Uh, it has to be portable. It should not be locked to a, a model or a cloud provider. It should also not be locked to an IDE. Like that's crazy if you think a whole team is gonna standardize on the same IDE forever, you're deluded.

Um, it should be fully observable. You should be able to see everything that happens in that environment end to end. Everything from what the model's doing and thinking and saying all the way to what are the tools actually running and what, what's the state of the environment.

You should be able to see everything in one place. Uh, and you need a strong multiplayer element. You need agents and humans to both be able to interact with that environment so that you can say, you can tell an agent, "Do this," and when the agent says, "I did it," you know, you can go and verify, "Okay, did you do it?

Give me the keyboard for a second," you know? You need all those things. Um, and I, I... Right now I'm not seeing us heading in that direction. I'm seeing us heading in the direction of highly integrated, very vertical end-to-end monoliths, you know.

And I don't wanna name names, but it's just, it's a, it's definitely a market trend. Like if you, if you're selling an IDE right now and people are asking for more customization for the coding agent's environment, you're gonna add some proprietary way to customize the environment.

You're gonna add your own observability solution and when people ask for a way to have the agent work in the background, you're gonna add your own hosting solution to run the agent in the background. That's, that's a monolith.

That's what fragmentation looks like and that's exactly what, what we were up against in, in the early days of cloud that led to the creation of, of Docker, right? So we're gonna need some sort of a standard, not on everything, just on the environment, right?

Just that little piece that connects all the other pieces. It's not the most powerful piece, but it's sort of, it's the linchpin that connects everything else, you know? The environment in which the agent does work. That should be independent.

**Wix** [11:24]
What do you think are like the biggest limitation today? So I, I use Docker to develop and I- ... I force, I force the coding agent in the IDE to run commands in the Docker environment. I would say if I had to give feedback on it is like one, the agent cannot make changes while inside the container and propagate them back to like the Dockerfile and Docker Compose.

### Agent-Native UX

**Wix** [11:43]
So it kind of like spends all the cycles and then all the work is kind of lost and there's no like AI native interface. I'm basically just doing Docker Compose exec and running the command in the container instead of like having a more native way to do it.

How do you think about that changing with like the new Dagger approach?

**Solomon Hykes** [12:00]
I mean, yeah, I, I... You just gotta rethink. There's just a design process. You gotta... I mean, Dockerfile was something we designed as a stopgap prototype ... thinking, "Oh, we'll clean this up later," uh, in, in 2013. You know, it's been more than 10 years.

Compose was a, a clone of a clone that we acquired into the team and, like stitched on top. And then as soon as we launched it, you have to understand there was so much excitement and demand, people didn't want it to move.

You know, you would build platforms on top, and then you'd be like, "Don't change the syntax." And so that stuff has been frozen in time. And I commend Docker for maintaining it and keeping it alive and just, like doing the hard work of maintaining it.

But it's not, it's not agent native. It never will be. So there's, like, there's, you just gotta go through a good engineering and design process of understanding how people, how people develop with agents and understand what's the best UX that they need, and try to design that on top of technology and components that is, that are as standard as possible.

Y- you know, you don't wanna reinvent the wheel where it's not necessary. But we've got a bunch of standards to work with. We've got the container tech. I mean, it's there, it's universal. We've got Git. We've got the, the LLM, you know, the OpenAI, um, API spec, right?

And, and its derivatives. And now we've got MCP. So that's pretty good. That's a pretty good set of standards. We can work with that. But yeah, it's gotta be a new UX, in my opinion. And, and I mean, n- not to plug Dagger, but obviously Dagger is our vehicle for going through this design process.

So, you know, if you wanna see my particular opinions on how things should be designed and how you want to balance, for example, simplicity versus modularity, then, you know, in my case, look at Dagger. But-

**Wix** [13:53]
Yeah

**Solomon Hykes** [13:53]
... um, but yeah.

**Wix** [13:55]
Yeah, I was-

**Solomon Hykes** [13:55]
It's normal that, it's normal that you can't just tape existing tools as is on, on new workflows and hope it to be, hope it'll be perfect. That's, that's totally normal.

### Workflow Parallels

**Wix** [14:02]
Uh, something I, I bring up in my work history a lot, and I, I think you know, is also worked in workflow orchestration in Temporal.

**Solomon Hykes** [14:08]
Yeah.

**Wix** [14:09]
And, like this migration of, like, let's say like a custom language, like a Docker file or like a AWS step function type thing into like a more programming language like a TypeScript or Go, that, that is the exact same journey I took.

**Solomon Hykes** [14:21]
Yeah, I mean, it's, it's, it's really, it's really hard to find the right balance. I think of it as Lego because it's a hard problem to solve these workflows and these environments because no two workflows are the same.

No two dev environments are the same. It's like factory design. Every great product has its own factory that's unique. No one goes and buys a factory at the factory store. You design it, and you build it alongside your products, and that's what these things are.

It's like a factory. Um, and it's really hard to provide tooling for that space because if you make it too complicated and too customizable for no reason, then you're wasting people's time. It's just, "I buy this. I'm just gonna do everything myself from scratch."

But if you try to streamline and simplify too much, then you're restricting choice, and then it becomes useless. You know? Like, "Well, this doesn't fit in my factory 'cause my factory uses this system, and I can't reconfigure it."

So it's a really hard area of design in engineering. And I mean, to, to me, the GOAT in this space is Lego , you know, the actual Lego. And I mean, it's, it's used as an analogy so much that it loses its meaning.

But if you really think about what Lego really is, it's really hard to... It was, in reality, very difficult to design and engineer the Lego brick because it had to be just right, and it's designed as one component, but it, it's, um, it's designed with, like a much larger system in mind, right?

So there's sort of this two layers of design. That's what's so hard, and that's why Lego is genius and has stood the test of time. That's what everyone in this space should be trying to do, build like a better Lego system that is worth adopting.

You know, you're, it's expensive to adopt a new standard in your stack. Like it's e- one more, one more of everything to worry about, right? So it's gotta justify the cost by actually saving, you know, it's gotta save you something, effort, money, whatever.

Uh, that's what Lego does. When I play, I like to play with Lego 'cause, you know, I can assemble things quickly, et cetera. So yeah, that's, that's the challenge. In the case of Temporal, I mean, I think these, these systems are very well positioned also for running agentic systems, right?

'Cause it's, an agent always has some sort of loop that's triggered by events. It's asynchronous. Gotta run that somewhere.

**Wix** [16:38]
Yeah, I would say Temporal's focused more sort of runtime applications, and then other systems are more focused on CICD. And honestly, you could use one for the other, but-

**Solomon Hykes** [16:46]
Yeah, but they're, that's the, they're converging because, like, your ICD will soon be nothing more than-

**Wix** [16:52]
Part of the execution

**Solomon Hykes** [16:52]
... runtime infrastructure for your workflows, and all those workflows will become agentic, right? It's gonna be either workflows running LLMs, LLMs running workflows, all the way down. And CI is just, it's also events, a job dispatcher, and compute.

So I think these things will converge with coding agents being the domain of application where everything meets, right? Because it, when you're running a coding agent, you're running an agent, so it's a runtime problem, but it's a very specific area of application.

And like, it's not real time. You don't have to worry about voice and video and things like that. You, you, you worry a lot about artifacts that are being produced and are they repeatable? Can I trace how they were created?

Is this binary created by an agent that, a model that went rogue? You know, things like that.

### Local Execution

**Wix** [17:37]
I think one element that I see a lot for these kinds of, like we, we've, you know, we've, we've talked to Bolt and like there, there's all this, uh, universe of, let's call it ephemeral apps that people are making or vibe coded apps-

**Solomon Hykes** [17:50]
Right

**Wix** [17:50]
... single use apps even. Just because it's so easy to create an app now that you're like, "I j- I just, it doesn't matter." So the speed and the setup and the tear down is pretty significant, and then, uh, obviously like the resource usage and cost.

These are all things that I, I'm hearing the founders in these companies all trying to solve for and all finding the current set of tools lacking. Because we just don't have the u- the... We cannot subdivide things that, that small or that cheaply.

We, we can't start things up that fast. And but, like, the, the users always want this. That's why they're sh- They... That's why they're doing the shortcuts. That's why they're not using containers, 'cause they're like, "I, I don't know how to do this in containers."

**Solomon Hykes** [18:29]
Yeah, and y- there's a lot of duct tape. I mean, if you wanna use containers yourself, you gotta duct tape a bunch of tools together. And it's not just containers, it's also, like, a, the file system isolation. You know, everyone's playing with these, with, with Git worktrees to try and get multiple instances of the agent working in parallel.

That's the same problem, right? It's, it's not just containers. It's, it's, it's something container-based. Container, containers for isolated execution and worktrees for isolated files, and it all kind of... You gotta connect it together somehow. I think, I do think what I'm seeing, I'm seeing a lot of vendors, of course, think about that and, and try to find the right solution for their customers.

I think one mistake everyone's making, again, I'm making a historical parallel with the rise of PaaS. Like, everyone had this very-

**Wix** [19:15]
Only you can do this.

**Solomon Hykes** [19:16]
Hopefully I'm not the only one left, but but I think it's becoming, it's gonna be very apparent very quickly that th- when someone who sells, uh, a commercial cloud product, a cloud-centric product in the AI space, uh, like, the, it's host- And, like, they're hosting your stuff, right?

You log in and they, they have your data, they have your traces, they run the model or they proxy to model, whatever. Everything, solution they come up with will be very infras- infra-centric, right? They're gonna think of another hosted feature, another hosted service.

So when they think environments, they think, "How can I run these VMs on my infrastructure as fast and cheaply as possible? You know, the, my scale is gonna be X. I have this many customers. The pricing is X."

And that's excellent, but developers also wanna run stuff them- themselves locally, and they don't really want that to be an afterthought. Um, but it's, it... Right now it is an afterthought, and it's the same mistake CICD vendors made.

Like, CICD has no good local story. There is some open source project that tries to simulate, say, GitHub Actions locally, and it's like, it, it must be a nightmare to, to maintain this project because compatibility is just so hard.

But, like, my point is just r- local execution, it's not everything, but it's a good test. Whatever solution you're imagining, does it support local execution? Will developers be able to run it locally and enjoy it? If the answer is no, you're not...

Y- you're, you're solving part of the problem, but you're not fully solving the problem of standardizing dev environments for coding agents. It's not, not gonna, um, stand the test of time because it w- it cannot be ubiquitous. It'll be a great commercial solution.

You'll make lots of money f- with it, but it's not gonna be ubiquitous.

**Wix** [21:00]
So I'm gonna ask, like, a really hard, uh, question maybe, but what does it take for one of the big clouds or big labs to adopt Dagger?

### Adoption

**Solomon Hykes** [21:09]
Yeah.

**Wix** [21:09]
So for example, for example, right? Like, I, I've had this exact same call, same problems with the Microsoft team, and they're pushing dev container.

**Solomon Hykes** [21:16]
Oh, yeah.

**Wix** [21:16]
And obviously dev container is not enough, but whatever. They, you know, they wanna build around it. They wanna extend it. And I'm like, "Okay, but, like, everyone's working on their thing. Like, when do we get some consolidation in this space?"

**Solomon Hykes** [21:26]
Yeah. Well, who knows? I mean, honestly, everyone should just give it their best shot and design the best possible solution-

**Wix** [21:33]
May the best one win.

**Solomon Hykes** [21:35]
Yeah. Honestly, I think with open source to some degree... Well, it depends on the d- the, the area, the domain. But I think for this problem, scale doesn't really help as much. Like, if you're, if you're going for, like, foundational models to take the extreme example, sure, let the best design win, but also I know who's g- I know who one of...

You know, I know the 10 names of who's... You know what I'm saying? Like, who's gonna win, it's gonna be one of those 10. Uh, like, startups don't really stand a chance. This is very different because it's not about scale.

It's about developer experience, and it's about designing, uh, the interfaces in a way that actually help people be more productive. So there's a lot of leverage for small teams to just design the best possible solution, and then you have to convince others to adopt it and build on it.

So community and ecosystem are extremely important. If you're large like Microsoft, you have an advantage on that obviously. There's a Microsoft ecosystem. It's massive. But you still need to have a solution, right? So, like, we're talking to Microsoft.

We're talking to a whole bunch of people. But there's a lot of, in this particular problem that we're targeting, you know, standardizing the dev environments for agents, you don't really need permission as a startup. You just go ahead and do it and build momentum, you know?

There's, there's less gatekeeping, I would say.

### Modular Design

**Wix** [22:55]
Yeah. Awesome. I think, like, the other thing that does come to mind sometimes is that there are different layers in infrastructure. Um, I think you're, you're very focused on, I don't know how to call it, like, virtual hardware.

Is that, is that, like, a term that resonates?

**Solomon Hykes** [23:08]
Like virtualization?

**Wix** [23:11]
No. Like, the... When I look at, let's say, what I can do with Dagger-

**Solomon Hykes** [23:16]
Mm-hmm

**Wix** [23:17]
... it doesn't, for example, have auth or billing.

**Solomon Hykes** [23:19]
Right.

**Wix** [23:20]
The, the higher level, still infrastructure-

**Solomon Hykes** [23:22]
Yeah, yeah, yeah

**Wix** [23:23]
... but there are, like, recombinations of things that are more sort of business-facing than, than just, like, the, the hard metal-

**Solomon Hykes** [23:31]
Yeah

**Wix** [23:31]
... facing. Um-

**Solomon Hykes** [23:33]
Yeah, it's, it's... So we're-- I think that's what you're describing as a consequence of the Lego-

**Wix** [23:38]
Yes

**Solomon Hykes** [23:38]
... approach. Like, the, um, we're focusing on the platform problem. You know, how do you create, uh, a modular system that can run anywhere, you can connect to anything, and allows you to compose the ideal environment, the ideal workflow, and it could be ubiquitous because it can be integrated into pretty much any existing system.

In order to do that, you can't go ahead and design a complete end-to-end solution, right? It's, that's the price to pay. So Dagger will always be a component of a bigger platform. It will never be the complete end-to-end platform because in order to do that, you have to force your customer to ...

adopt your authentication and your UI and your storage and your networking, et cetera, et cetera. And we do, we're doing the opposite. We're telling these platform teams, "Hey, we're not, we're, we will adapt to the, to the stack that you have."

And so for example, even, I, I, I started, we started this conversation with CICD because that's our traditional use case. Dagger makes your CICD better, but it does not actually replace your legacy CI platform. It runs on top of it, and it, it, it allows you to simplify it and turn it into, like, basically dumb runner infrastructure, but it's still important infrastructure.

So we don't come in and seek to replace what you have. We try to integrate with it and make the overall system better. And so as a result, it's just a different shape of a product, right? And we definitely don't solve auth.

You know, you gotta, you gotta s- you gotta rely on others-

**Wix** [25:10]
Pick your battles to help solve auth.

### Closing

**Solomon Hykes** [25:11]
Yeah.

**Wix** [25:11]
But whatever you do, we'll integrate with it. Yeah. Yeah, yeah. Um, cool. Uh, I think that, that that's plenty for an, an intro to, like, where Dagger's at and, you know, the, the pull that you guys are seeing.

I'm looking forward to your talk, to be honest. Like, I think, I don't think-

**Solomon Hykes** [25:24]
Thank you

**Wix** [25:24]
... I haven't seen, like, a good, like, Solomon Hykes, like, AI talk. And so-

**Solomon Hykes** [25:28]
Well, I don't know anyone has.

**Wix** [25:30]
Yeah, so like-

**Solomon Hykes** [25:30]
Hopefully they'll see one next week.

**Wix** [25:32]
Yeah, I, I know, I know. You know, let's, let's, uh, uh, you know, feel free to lean on me to prep and all that, but-

**Solomon Hykes** [25:37]
Thank you

**Wix** [25:37]
... I'm, uh, excited. And I, I think, like, when I saw the workshop submission come in, you guys had a really good, like, let's, let's build a code, code a, a code agent and, like, here's all the different things.

That really tied it together for me. Um, that was like, okay, this is where, what Dagger-

**Solomon Hykes** [25:50]
Yeah

**Wix** [25:50]
... where Dagger is going. This is how, like... Like, ul- ultimately, like, I need the LLMs to start generating their own infrastructure, right? Like, generative infrastructure almost. I feel like that's, like, prone to a lot of spend.

**Solomon Hykes** [26:05]
Yeah.

**Wix** [26:06]
But it's gonna happen.

**Solomon Hykes** [26:06]
Well, yeah, controlling the environment is, is a good, like, okay, how much control, how much freedom really do I wanna give this agent, you know?

**Wix** [26:13]
I mean-

**Solomon Hykes** [26:14]
Yeah

**Wix** [26:14]
... we're, we're well past the, the stage where, like, these things are just running wild on the internet, so why not? But, like, you know, to give them my AWS account and just go nuts, like-

**Solomon Hykes** [26:21]
Yeah

**Wix** [26:22]
... that's, that's tricky.

**Solomon Hykes** [26:23]
But, you know, just so you know, de- depending on how things go, you know, there's, like, a 50% chance that, um, uh, it, for, for my keynote there will be some, like, f- brand new, or original stuff to sh- to show and talk about that is not yet, uh, out.

Like, and on top of what we're showing in the workshop and everything. So it depends if it's ready in time, but we may have, like, even more, even more fresh stuff to talk about.

**Wix** [26:52]
All right. Well, uh, we'll, we'll let you get back to it. Thanks so much for your time.

**Solomon Hykes** [26:57]
Thank you. Yeah, thanks, guys. I'll see you next week.

---

This library is powered by PodHood (https://podhood.com), the podcast website platform.
