[AIEWF Preview] Containing Agent Chaos — Solomon Hykes
Summary
Solomon Hykes’s core bet is that coding agents need a portable environment layer, drawing on the role Docker played amid fragmentation in the early cloud wave. Developers are moving from one IDE assistant to teams of parallel agents, effectively becoming platform engineers responsible for enabling AI workers. The environment is “not the most powerful piece,” but it is the “linchpin that connects everything else.”
Dagger is being pulled from post-development CI/CD into the coding loop by its own community. Its container-based workflow engine already makes builds and tests isolated, modular and portable between local machines and CI. Hykes now sees those same properties as essential for preventing multiple agents from corrupting one another’s work.
The agent environment should be isolated, portable, observable, multiplayer, and independent of any model, cloud, or IDE. Humans need to inspect an agent’s reasoning, tools, and environment state, then “get the keyboard for a second” to verify its claim that work is finished. Hykes sees the market moving instead toward proprietary, vertically integrated monoliths that repeat the fragmentation preceding Docker.
Existing Docker tooling cannot simply be taped onto agent workflows. Dockerfile began as a 2013 “stopgap prototype,” while Compose was stitched in and then effectively frozen by adoption; neither is agent-native. Hykes argues that a new UX can still build on established primitives: containers, Git, the OpenAI API spec and MCP.
CI/CD and agent runtimes are likely to converge around event-driven workflows and traceable artifacts. Hykes expects “workflows running LLMs, LLMs running workflows, all the way down,” with CI increasingly serving as events, job dispatch and compute. The differentiator for coding agents is provenance: teams must know whether a binary is reproducible or came from “a model that went rogue.”
Local execution is Hykes’s litmus test for whether an agent platform can become ubiquitous. Cloud vendors naturally optimize hosted VMs, traces and model access for their own infrastructure, but developers do not want local use treated as an afterthought. A hosted-only product might be “a great commercial solution” that makes money, he says, but it will not standardize agent development.
Dagger’s strategy is to remain a modular component rather than own authentication, UI, storage and networking end to end. It can turn an existing CI system into “basically dumb runner infrastructure” without replacing it, trading platform completeness for broad integration. Hykes says this market rewards developer experience and ecosystem more than scale, leaving startups room to win without permission from a major cloud.
Deep dive
1. Coding agents are turning developers into platform engineers
Hykes introduces six-year-old Dagger as an open-source workflow engine that replaces “artisanal scripts” for builds, tests and delivery pipelines with modular code running in containers. Its historical users are platform engineers—the people designing and operating the software factory—who often suffer a “cobbler has no shoes” problem, assembling their own tools from Bash and YAML.
Dagger began primarily after code was saved, improving the path through build, test and production. Its community then started inserting LLMs into workflows and running agents inside CI, pulling the company upstream into development itself.
Hykes’s transition point: one agent in an IDE becomes a team of coding agents, and the developer’s job shifts from producing every change to enabling others to work productively. Those “others, of course, are AIs,” and each needs a clean environment rather than several workers colliding inside one mutable laptop workspace.
2. The environment is the independent layer agent stacks are missing
Containers remain Hykes’s base unit for isolated execution, but the full environment must support agents working in parallel without interference, move across models, clouds and IDEs, and expose everything from model activity to tool calls and resulting state.
The human must also share that environment. When an agent says, “I did it,” the operator should be able to inspect the result and say, “Give me the keyboard for a second,” rather than trust an opaque background run.
The host’s practical pushback is sharp: today an IDE agent can be forced through
Docker Compose exec, yet its changes may not propagate back into Dockerfile or Compose, and the interface consumes cycles without preserving the work. Hykes agrees this is a design failure, not evidence against containers: “You can’t just tape existing tools as is on new workflows and hope it’ll be perfect.”His historical concession matters: “We busted our ass on Docker,” but Dockerfile was a 2013 stopgap, Compose was stitched onto the system, and adoption made both interfaces difficult to change. A fresh agent-native UX can nevertheless reuse containers, Git, the OpenAI API spec and MCP rather than reinventing every primitive.
3. LEGO is the model for programmable agent infrastructure
Hykes compares environments and workflows to factories: “No one goes and buys a factory at the factory store.” Every product needs a distinct factory, so tooling that is too customizable wastes users’ time, while tooling that simplifies too aggressively cannot fit their stack.
LEGO is his benchmark because one carefully engineered component supports a much larger compositional system. Adopting another standard is expensive—“one more of everything to worry about”—so the pieces must repay that cost through saved effort or money.
This modularity also blurs traditional categories. Temporal-style application runtimes and CI/CD systems both involve asynchronous events, dispatch and compute; Hykes expects coding agents to bring them together as “workflows running LLMs, LLMs running workflows, all the way down.”
Coding creates a special provenance problem even without real-time voice or video: artifacts must be repeatable and traceable. Teams need to determine whether a binary followed a reproducible process or was “created by an agent—a model that went rogue.”
4. Hosted-first infrastructure faces the local-execution test
Vibe-coded and even single-use apps intensify demands for rapid setup, teardown, fine-grained isolation and low cost. Users take shortcuts because current tools cannot subdivide environments “that small or that cheaply” or start them quickly without substantial duct tape.
Containers alone are insufficient: parallel agents also need isolated files, leading teams to combine container execution with Git worktrees. Hykes sees vendors assembling these pieces, but warns that hosted AI companies naturally frame environments as another fleet of fast, cheap VMs on their own infrastructure.
His litmus test is simple: “Does it support local execution? Will developers be able to run it locally and enjoy it?” CI/CD’s weak local story—and projects struggling to emulate GitHub Actions locally—shows how hard compatibility becomes when local execution is an afterthought.
Hykes’s commercial-versus-standard distinction is categorical: a hosted-only environment can be “a great commercial solution” and “make lots of money,” but it cannot become ubiquitous enough to standardize development for coding agents.
5. Dagger is betting that interface quality can beat platform scale
Asked what would make a major cloud or lab adopt Dagger amid competing efforts such as Dev Containers, Hykes declines to predict consolidation: “Everyone should just give it their best shot and design the best possible solution.”
Unlike foundation models, where scale narrows the plausible winners, agent environments are primarily a developer-experience and interface-design contest. Small teams retain leverage, though community and ecosystem remain decisive; in this layer, a startup “doesn’t really need permission” and can build momentum directly.
Dagger deliberately will not become an end-to-end platform with proprietary authentication, UI, storage and networking. It adapts to existing stacks, including legacy CI, which can be simplified into “basically dumb runner infrastructure” while remaining in place.
The host frames a possible next step as “generative infrastructure,” with LLMs generating their own infrastructure, and says giving an agent an AWS account to “go nuts” is tricky. Hykes cautions that this is “prone to a lot of spend.” Separately, he puts the odds at “a 50% chance” that his coming keynote would contain brand-new work beyond the workshop, if it was ready in time.