AI Engineer World's Fair 2025
Containing Agent Chaos
Loading slides…
Read the talk
Containing Agent Chaos
Coding agents need more than permission prompts: they need isolated development environments that humans can inspect, change, compare and merge.
From a talk by Solomon Hykes
Before you start: Familiarity with Git, containers and command-line development will help you follow the demonstration.
Coding-agent users become platform engineers
How do you make coding agents productive without spending all your time fixing their environments? Solomon Hykes approaches that question from familiar ground: he recalls standing on the same stage to open DockerCon 2015, roughly ten years earlier. Now the infrastructure problem is enabling agents to build software.
Platform engineers—the community Hykes works with at Dagger—enable other developers to build and ship productively. That requires experience, patience and a willingness to solve problems someone else would rather avoid. The opening Lorax illustration gives this often invisible work a spokesperson.
Using coding agents puts developers in a similar position: their job increasingly becomes enabling robots to ship software. Agent adoption turns environment management into part of the development workflow. Hykes is describing an emerging practice, not a world where autonomous teams already work reliably for everyone. Early adopters are assembling scripts and tools; the challenge is making that arrangement useful to everyone shipping software.
Suggest correction
This note stays in this page until you copy or download it. Nothing is submitted; reloading clears the draft.
Shared-machine chaos and all-in-one constraints
Start with an agent acting in an environment on a human’s behalf. Hykes borrows an agent-loop diagram from Anthropic and supplies his own joke: the LLM is “wrecking everything in a loop.” For a coding agent, that environment is often the developer’s computer. The human watches, approves useful actions and stops dangerous ones.
That supervision model becomes awkward when one agent becomes a team. Hykes’s hypothetical YOLO mode simply launches ten agents. They share an environment, interfere with one another’s work, and make close supervision increasingly impractical. The problem is not merely the number of approval prompts; it is that independent attempts can mutate the same working state.
The other option is a hosted package: open an issue, let the provider supply the model, tools, environment, compute and secrets, then wait for a pull request. Hykes says these offerings can work well. Their limitation appears when you need to take the keyboard, run on your own machine, choose another compute provider or switch models. The desired workflow combines background work with direct intervention and freedom to mix components.
Suggest correction
This note stays in this page until you copy or download it. Nothing is submitted; reloading clears the draft.
Four requirements for agent environments
The requirements begin with background work and rails. An agent should not need to rediscover the project’s coding style, tools, build procedure, tests or base image. Secret access also belongs in that setup: this environment may use one credential, but not another. Establishing these constraints up front avoids spending tokens repeatedly correcting decisions whose answers were already known.
When intervention becomes necessary, neither approving every action nor waiting for a pull request is sufficient. A human needs to enter the work while it is happening. Optionality matters for the same reason: models, agents and infrastructure are changing too quickly to commit every layer to one package. These needs translate into properties of the environment itself.
| Desired behavior | Environment property |
|---|---|
| Work in the background | Isolation |
| Follow established rails | Customization |
| Let a human step in | Multiplayer access |
| Mix models, agents and compute | Openness |
Multiplayer access includes checking whether an agent actually did what it claimed, not just helping it recover from an error. Openness need not exclude commercial clouds; it means retaining the ability to choose the component that fits each job, including open-source components.
Suggest correction
This note stays in this page until you copy or download it. Nothing is submitted; reloading clears the draft.
Containers as the development environment
Containers and Git already provide much of the foundation. Hykes’s criticism is that their familiar tools were designed for humans, and agent workflows do not yet fully exploit the underlying capabilities. Git worktree scripts are one sign that developers are already trying to assemble parallel environments. The opportunity is to integrate these primitives directly into how an agent works.
Dagger’s answer is Container Use: alongside computer use and browser use, an agent needs the ability to create and operate development environments in containers. Developing inside a container is different from sandboxing only the code an agent produces. The former includes the environment in which the agent edits, builds, tests and runs its work.
The recording shows an unfinished launch version, before the repository is made public. Its CLI and implementation details should be read in that historical context rather than replaced with today’s commands. The team has advised Hykes not to demonstrate it; he proceeds with an explicit warning that the software may break.
Suggest correction
This note stays in this page until you copy or download it. Nothing is submitted; reloading clears the draft.
A portable environment attached to Claude Code
The demonstration begins in an empty directory. The task is to build a homepage for Container Use using Claude Code. Container Use is not another coding agent: it supplies portable environments that an existing agent can use. Hykes describes attaching that layer to Claude, Codex, an IDE or a command-line workflow, with cloud and CI execution also possible.
He launches Claude Code through an alias that disables permission prompts, then asks for a Go web app and instructs it to run the result. Go makes the generated application easy for him to follow. A minimal implementation of that task could look like this:
go
package main
import (
"io"
"log"
"net/http"
)
func main() {
http.HandleFunc("/", func(w http.ResponseWriter, r *http.Request) {
w.Header().Set("Content-Type", "text/plain; charset=utf-8")
io.WriteString(w, "Container Use\nDevelopment environments for coding agents.\n")
})
log.Fatal(http.ListenAndServe(":8080", nil))
}
The important part of the request is not just producing a file: the agent must also provision a suitable environment and start the application.
The integration uses MCP. Vanilla Claude Code retains its usual tools and gains tools for working through Container Use; other integrations are still being developed. This distinction matters for the permission-disabling alias: adding container tools does not itself confine every action of an agent that still has host tools. Isolation of the development environment and restriction of the agent’s available tools are separate decisions.
Suggest correction
This note stays in this page until you copy or download it. Nothing is submitted; reloading clears the draft.
Ephemeral execution and shared inspection
The agent creates an environment, edits files inside it, and runs commands to build, test and start the application. Hykes describes execution as a succession of ephemeral containers, not one Docker container left running throughout development. Each action runs in a container, after which its state is snapshotted and returned.
Meanwhile, the human’s working directory remains untouched. In the demonstrated implementation, Hykes says file and container state are persisted in special Git objects alongside the repository. The state is available locally without automatically populating the checked-out workspace. This separates the agent’s ongoing work from the human’s decision to adopt it.
The cu command-line tool gives the human a way into that state:
- List the environments and find the newly created, randomly named environment.
- Open a terminal in it, using execution primitives supplied by Dagger.
- Inspect the same files and tools the agent sees, including the Go version it selected.
- Build the application independently.
The agent chooses and configures its tools in a repeatable, containerized environment. Hykes enters that environment and reports a successful build: intervention does not require reconstructing the agent’s setup on his own machine.
Suggest correction
This note stays in this page until you copy or download it. Nothing is submitted; reloading clears the draft.
Secret access and remote execution
The environment boundary also provides a place to assign credentials. Hykes describes connecting an existing password manager such as 1Password, then granting a particular environment access to a particular secret. He wants to keep his existing password manager rather than adopt a separate one from an AI provider. This integration is described but deliberately not demonstrated: the team expects that part to break.
Execution location is independent of the terminal on stage. Hykes initially says the containers run on his machine, then corrects himself: they are running on his remote server, about a mile away. That avoids conference-network problems when downloading container images. Files stream between the local workflow and remote execution, while he continues inspecting the environment from his laptop.
Suggest correction
This note stays in this page until you copy or download it. Nothing is submitted; reloading clears the draft.
Watch the history and merge a working result
Watching an environment exposes its history. Each state snapshot appears in a Git-backed log, so the human can follow progress and retrieve a result when it is useful. This supplies the missing middle ground: observe the work without approving every tool call, and intervene without waiting for a finished pull request. The first homepage becomes live, and Hykes opens it and reacts positively.
A working homepage is only the first result. Hykes calls the design boring and asks for something more striking for the AI Engineer World’s Fair audience. The deliberately vague request creates a reason to explore multiple alternatives: there is no single obvious interpretation of making a design pop.
Before launching those experiments, he stops and adopts the working baseline. His local workspace is still empty; merging the accepted environment brings the result and its history into his own workflow. From there, he can clean up the history or open a pull request. Accepting agent work is an explicit operation, separate from letting the agent work.
Suggest correction
This note stays in this page until you copy or download it. Nothing is submitted; reloading clears the draft.
Launch and discard independent experiments
With the accepted application available as a starting point, Hykes launches multiple Claude sessions asking them to improve the design. Each attempt can proceed in its own environment. The ambiguous design request becomes a set of independent experiments rather than several agents editing one shared workspace.
Failure becomes easier to handle as well. If an attempt goes wrong or produces an unwanted direction, discard its environment and restart. There is no need to clean that attempt’s changes out of the shared working directory. Hykes uses this disposability to explain why demonstrating unfinished software is still useful: recovery is part of the workflow being demonstrated.
He then introduces Goose, an open-source agent, and launches it alongside Claude. His Claude YOLO and Goose YOLO aliases disable permission safeguards; he presents environment isolation as his reason for using them. The larger demonstration is agent independence: the environment layer should support different agents working on the same development problem.
Suggest correction
This note stays in this page until you copy or download it. Nothing is submitted; reloading clears the draft.
Compare branches and reach isolated services
The watch interface is still rough: Hykes describes it as thinly wrapped Git commands, including a command that can be copied directly. Underneath, the combination is Git, Dagger and the existing agent, joined by a small amount of glue. As the agents work, snapshots accumulate and their branches diverge. Those branches can then be diffed, applied or merged using familiar version-control operations.
Running services adds another dimension to isolation. A command such as go run or npm run executes inside its environment, and Hykes describes tunneling each service to a distinct port on the local machine. That allows separate experiments to expose applications without competing for the same local port. The boundary covers files, context, configuration and execution, not just source-code branches.
The remote server is one possible execution location; Hykes also points to clusters and CI. But the final live demonstration does not reach the hoped-for comparison of running parallel services before time expires. He reports Goose running, then finds the work is not done. Environment management can make attempts independent and recoverable without resolving the ambiguity of the task: “We did not solve prompt engineering.”
Suggest correction
This note stays in this page until you copy or download it. Nothing is submitted; reloading clears the draft.
Publish the unfinished project on stage
The ending returns to DockerCon. Hykes recalls opening projects on stage ten years earlier and offers to do the same with Container Use. After reminding the audience that it is unfinished, he opens GitHub’s visibility controls and proceeds through the acknowledgments required to make dagger/container-use public. The confirmation dialog captures the release in progress.
After working through the confirmations, Hykes tentatively reports that the change is done and announces the repository. The invitation is to participate in building the environment layer: meet the team, try Container Use and contribute to the project.
Suggest correction
This note stays in this page until you copy or download it. Nothing is submitted; reloading clears the draft.
Resources
From the talk
Open-source development environments for coding agents, with MCP integration, Git-backed work and human inspection tools.
Open-source AI agent with a command-line interface and support for MCP extensions.
Further reading
February 2025 release announcement introducing direct retrieval of secrets from 1Password and HashiCorp Vault in Dagger pipelines.
Updates since the talk
Current guide to inspecting agent work, entering environments, merging history, applying changes and discarding experiments.
MCP setup instructions for Claude Code, Goose and other coding agents, including tool-access configuration.
Configure secret references from 1Password, Vault, environment variables and files for containerized development.
Full transcript
Loading transcript…