Latent Space: The AI Engineer Podcast

Episode: [AIEWF Preview] Containing Agent Chaos — Solomon Hykes

Date: June 3, 2025
Guest: Solomon Hykes (Founder of Docker, Dagger)

Episode Overview

This episode of Latent Space dives deep with Solomon Hykes—creator of Docker and founder of Dagger—on the crucial topic of infrastructure and workflow design for AI coding agents. The discussion spotlights how the transition to AI-driven software development is straining and reshaping conventional developer environments, and how Dagger aims to provide standardization and modularity that could “contain the chaos” of running teams of coding agents. The hosts, Alessio (CTO at Dazable) and Swyx (founder of Small AI), guide a conversation exploring the state and the urgent needs of the AI engineering toolchain, especially for AI agents, and Solomon's vision for how to design reliable, composable environments that empower both human and machine developers.

Key Discussion Points & Insights

1. Dagger’s Origin and Mission

[00:20–02:37]

• Dagger is described as a workflow engine, initially post-development focused, converting ad hoc scripts and pipelines into robust modular workflows—all containerized for consistency and portability.
  • Quote:

    “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 code. And it all runs in containers.” — Solomon, [00:32]

• Dagger’s open-source community primarily attracts platform engineers, those "designing the factory" for developer enablement.
• Increasingly, developers are being "pulled into" platform engineering, especially as agents start performing and automating key parts of the development process.

2. The Rise of Coding Agents and New Challenges

[02:37–06:23]

• Agents (particularly LLM-based coding agents) are shifting the role of developers, who now must manage and enable teams of AIs, not just develop alone.
  • Quote:

    “If you're a developer, increasingly, your job is not going to be to actually develop, but to manage and enable these coding agents.” — Solomon, [04:10]

• The move from single-agent support (e.g., one agent in the IDE) to multi-agent, team-like environments creates frictions—including state management, environment isolation, and repeatability.
• Traditional developer environments are highly fragmented and not well suited for multi-agent orchestration.

3. The Missing Standard for Agent Environments

[06:23–11:23]

• The status quo: current agent environments are tightly coupled to specific tools/platforms (e.g., IDEs, proprietary agent infrastructure), suffer from limited internet access, shallow customization, and poor isolation.
• Solomon identifies the lack of a clear, open, modular standard for the agent's runtime environment as the main bottleneck.
  • Quote:

    “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. It has to be portable... observable... you need a strong multiplayer element. Agents and humans [should] both be able to interact with that environment.” — Solomon, [10:00]

• The comparison to previous platform consolidation efforts (e.g., Docker’s original vision vs. the current fragmented landscape).

4. Limitations of Today’s Container Tooling and UX

[11:23–14:02]

• Tooling such as Docker and Docker Compose remain “frozen in time” and were not designed for AI agents—there's no agent-native UX or interfaces.
  • Quote:

    “Dockerfile was something we designed as a stopgap prototype thinking, oh, we'll clean this up later in 2013... it's not agent native, it never will be.” — Solomon, [11:59]

• It's not enough to plug together old tools; a fresh iteration on developer/agent experience is needed, leveraging ubiquitous standards (container tech, Git, LLM API specs) but with new UX paradigms.

5. The “LEGO” Analogy: Modularity & Customization

[14:02–16:38]

• The right balance is needed: too much flexibility leads to complexity, too little stops adoption.
  • Quote:

    “I think of it as LEGO because... no two dev environments are the same. It's like factory design. Every great product has its own factory that's unique.” — Solomon, [14:20]

• Success looks like a uniquely versatile yet easy-to-integrate set of building blocks—referencing how hard LEGO bricks were to engineer, but how their success comes from interoperability.
• Workflow engines (like Dagger, Temporal) are well-positioned to serve as the backbone for agentic systems due to their event-driven, asynchronous nature.

6. Orchestration Convergence: CI/CD and Agents

[16:38–17:37]

• The boundaries between CI/CD, runtime workflows, and agentic systems are blurring.
  • Quote:

    “Your CI/CD will soon be nothing more than runtime infrastructure for your workflows. And all those workflows will become agentic.” — Solomon, [16:45]

• Agentic pipelines will deeply intertwine with software delivery pipelines; provenance and traceability ("can I trace how [an artifact] was created?") become pivotal as agents take on more responsibility.

7. Ephemeral Apps, Local Dev, and the Cost Challenge

[17:37–20:59]

• Developers crave ephemeral, rapidly spinning-up environments, but current tooling is too heavyweight or fragmented (VMs, containers, filesystems).
• Most vendor solutions are cloud/infra-centric and overlook local developer experience—this mirrors earlier CI/CD mistakes.
  • Quote:

    “Local execution... 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... fully solving the problem.” — Solomon, [19:55]

8. Standardization, Ecosystem, and The Role of Small Teams

[20:59–22:55]

• True standardization doesn’t necessarily require dominance by the big clouds; developer experience and adoption matter more for agent environment tooling than brute scale.
  • Quote:

    “You don't really need permission as a startup. You just go ahead and do it and build momentum. You know, there's less gatekeeping, I would say.” — Solomon, [22:43]

9. Dagger’s “LEGO” Philosophy and Platform Boundaries

[22:55–25:13]

• Dagger will always be a component, not the whole platform: it seeks composability, not lock-in.
• End-to-end solutions require full stack lock-in; Dagger’s strategy is to integrate, not replace, existing infrastructure.

10. Looking Forward: Generative Infra, Agent Control, and Previewing New Work

[25:13–26:51]

• Demand is rising for “generative infrastructure”—LLMs generating and managing infra—but with it comes the risk of runaway costs and “agent chaos.”
• Solomon hints at unreleased demos and fresh concepts for his upcoming keynote, doubling down on the “contain the chaos” theme.

Notable Quotes & Moments

• [00:32] Solomon:

  "It takes all these workflows that are usually semi automated with artisanal scripts... and it turns them into robust modular workflows that you can drive with code. And it all runs in containers."

• [04:10] Solomon:

  "If you're a developer, increasingly, your job is not going to be to actually develop, but to manage and enable these coding agents."

• [10:00] Solomon:

  “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. It has to be portable... observable... you need a strong multiplayer element. Agents and humans [should] both be able to interact with that environment."

• [11:59] Solomon:

  "Dockerfile was something we designed as a stopgap prototype thinking, oh, we'll clean this up later in 2013... it's not agent native, it never will be."

• [14:20] Solomon:

  “I think of it as LEGO because... no two dev environments are the same. It's like factory design. Every great product has its own factory that's unique.”

• [16:45] Solomon:

  "Your CI/CD will soon be nothing more than runtime infrastructure for your workflows. And all those workflows will become agentic."

• [19:55] Solomon:

  “Local execution... it's a good test. Whatever solution you're imagining, does it support local execution?... If the answer is no, you're not, you're, you're solving part of the problem, but you're not fully solving the problem of standardizing dev environments for coding agents."

• [22:43] Solomon:

  "You don't really need permission as a startup. You just go ahead and do it and build momentum. You know, there's less gatekeeping, I would say."

Timestamps for Key Segments

• 00:20–02:37 — Dagger mission and core user base
• 02:37–06:23 — The shift to agent-driven workflows and evolving developer roles
• 06:23–11:23 — Problems with current agent environments and lack of standards
• 11:23–14:02 — UX debt in container tooling, need for agent-native interfaces
• 14:02–16:38 — The LEGO analogy and modularity challenges
• 16:38–17:37 — CI/CD and agent orchestration convergence
• 17:37–20:59 — Ephemeral dev environments, local vs. cloud, and developer needs
• 20:59–22:55 — Size, standardization, and the role of ecosystem/community
• 22:55–25:13 — Dagger’s place in the stack and integration philosophy
• 25:13–26:51 — Generative infrastructure and a teaser for new work coming soon

Summary

This episode is an essential listen for anyone navigating the intersection of AI agents, developer tooling, and infrastructure. Solomon Hykes provides a historical perspective on how developer environments have stagnated post-Docker, lays out a vision for how infrastructure must evolve to empower agentic workflows, and candidly assesses the state of today's tools ("frozen in time," "not agent native"). The conversation repeatedly returns to the need for a modular, open, portable “LEGO brick” standard for environments—one that will let both humans and AI agents collaborate productively, and that lowers friction for both cloud-native and local-first development. The discussion is frank, energetic, and prophetic, offering direct advice to both the AI builder community and the cloud vendors shaping the next wave of software.

For developers, platform engineers, and AI toolmakers, the core call-to-action is clear:
Rethink how you manage agent environments. Don’t accept today’s fragmentation and lock-in. Embrace open standards, prioritize local and portable execution, and help build the “LEGO” for the age of AI agents.