Containing Agent Chaos — Solomon Hykes, Dagger

Key Concepts

• Coding Agents
• Platform Engineering
• Container Use
• Isolated Environments
• Background Work
• Rails (Constraints for Agents)
• Seamless Intervention
• Optionality (Choice of Models, Compute, Infrastructure)
• Git Integration
• Ephemeral Containers

Main Topics and Key Points

The Challenge of Coding Agents

• The speaker starts by reflecting on their DockerCon 2015 presentation and introduces the topic of chaos emerging from using coding agents.
• Platform engineers face the challenge of enabling developers to ship software productively.
• Using coding agents shifts the platform engineer's role to enabling robots to ship software, which can be a tough job.
• The speaker jokes about the lack of gratitude from developers, highlighting the often-unseen work of platform engineers.

Current Approaches and Their Limitations

• YOLO Mode: Running multiple agents simultaneously without proper management, leading to conflicts and inefficiencies. Agents step on each other's toes due to shared environments.
• All-in-One Solutions: Providing a complete, managed environment for agents, which can be limiting in terms of customization and choice of tools. Users may want to intervene directly or use their preferred models and infrastructure.
• The speaker argues that both approaches have limitations and seeks a better solution.

Desired Properties of an Ideal Environment

The speaker outlines four key requirements for an ideal environment for coding agents:

1. Background Work: Agents should be able to operate autonomously without constant supervision.
2. Rails: The environment should provide constraints and guidelines for the agent, including project context, coding style, tool usage, build processes, base images, and secret access. This reduces wasted tokens on corrections.
3. Seamless Intervention: A middle ground is needed between constant monitoring and waiting for pull requests, allowing for efficient and direct intervention when necessary.
4. Optionality: Users should have the freedom to choose their preferred models, compute resources, and infrastructure, avoiding vendor lock-in.

Container Use: A Solution

• The speaker proposes "container use" as a solution, leveraging containers to create isolated and customizable environments for coding agents.
• This is different from sandboxing, which focuses on securely executing the output of the agent. Container use involves the agent developing entirely within containers.
• Containers provide isolation, customization, multiplayer capabilities (allowing intervention), and openness (choice of components).
• The speaker emphasizes that existing container technology is underutilized and can be fully leveraged by intelligent models.

Demo of Container Use with Dagger

• The speaker attempts a live demo of an unfinished, open-source project called "container use," integrated with Dagger.
• The demo involves using cloud code to create a simple homepage for the container use project.
• Cloud code is configured to use containers via MCP (Management Control Plane), creating a sandbox environment for editing and running code.
• Ephemeral containers are used for each action, with the state of files and containers persisted in git objects alongside the repository.
• The speaker uses a command-line tool ("cu") to list environments and open a terminal within the agent's environment, allowing inspection of files and tools.
• Secrets can be plugged in from password managers like 1Password.
• The environment is running on a home server, demonstrating the ability to run it on various infrastructure.
• The speaker demonstrates merging the environment and then asking multiple agents (Claude Yolo and Goose Yolo) to improve the design.
• The demo highlights the ability to discard environments if the results are unsatisfactory.
• The speaker mentions a "watch" command that shows the history of state snapshots as git branches, allowing for diffing, applying, and merging changes.
• The demo aims to show that when an agent runs a service (e.g., go run), it does so in its containerized environment, which is seamlessly tunneled to the user's machine.

Open Sourcing the Project

• The speaker announces the open-sourcing of the "container use" project on GitHub: github.com/dagger/container-use.

Important Examples and Real-World Applications

• Cloud Code Integration: Demonstrates how existing tools like Cloud Code can be integrated with container use to provide a sandboxed development environment.
• Parallel Experiments: The speaker attempts to run multiple agents in parallel to improve the design of the homepage, showcasing the potential for parallel experimentation.
• Secret Management: The ability to plug in secrets from existing password managers like 1Password is mentioned as a key feature.
• CI/CD Integration: The speaker mentions that the environment can be run from CI, highlighting its potential for integration with continuous integration and continuous delivery pipelines.

Step-by-Step Processes

• Creating a Containerized Environment:
  1. Configure a coding agent (e.g., Cloud Code) to use containers via an integration like MCP.
  2. The agent creates an isolated environment within a container.
  3. The agent edits files and runs commands within the container.
  4. Ephemeral containers are used for each action.
  5. The state of files and containers is persisted in git objects.
• Intervening in the Agent's Environment:
  1. Use a command-line tool (e.g., "cu") to list available environments.
  2. Open a terminal within the agent's environment to inspect files and tools.
  3. Make changes or debug the agent's actions.
• Merging and Applying Changes:
  1. Review the history of state snapshots as git branches.
  2. Diff the branches to see the changes made by the agent.
  3. Merge the desired changes into the main branch.

Key Arguments and Perspectives

• Limitations of Current Approaches: The speaker argues that existing approaches to using coding agents (YOLO mode and all-in-one solutions) have significant limitations.
• Importance of Isolation and Customization: The speaker emphasizes the need for isolated and customizable environments for coding agents.
• Leveraging Existing Technology: The speaker believes that existing container technology is underutilized and can be fully leveraged by intelligent models.
• Openness and Choice: The speaker advocates for openness and choice in terms of models, compute resources, and infrastructure.

Notable Quotes

• "It's an LLM that's wrecking everything in a loop on behalf of a human." (Definition of an agent)
• "I don't want to use a separate password manager from an AI company... I just want to use my password manager." (Emphasis on using existing tools and avoiding vendor lock-in)

Technical Terms and Concepts

• Coding Agents: AI-powered tools that can automate coding tasks.
• Platform Engineering: The practice of building and maintaining the infrastructure and tools that enable developers to ship software productively.
• Container Use: The concept of using containers to create isolated and customizable environments for coding agents.
• Ephemeral Containers: Short-lived containers that are created and destroyed for each action.
• MCP (Management Control Plane): An interface for managing and controlling containers.
• Git Work Trees: A Git feature that allows multiple working directories to be attached to a single repository.

Logical Connections

• The speaker starts by identifying the challenges of using coding agents.
• They then critique existing approaches and propose a set of desired properties for an ideal environment.
• "Container use" is presented as a solution that addresses these properties.
• The demo illustrates how container use can be implemented with Dagger and integrated with existing tools.
• The open-sourcing of the project encourages community participation and further development.

Data, Research Findings, or Statistics

• No specific data, research findings, or statistics are mentioned in the transcript.

Synthesis/Conclusion

The presentation argues that current approaches to using coding agents are limited and proposes "container use" as a more flexible and powerful solution. By leveraging containers to create isolated and customizable environments, developers can empower agents to work autonomously while retaining the ability to intervene and choose their preferred tools and infrastructure. The open-sourcing of the "container use" project aims to foster community collaboration and drive further innovation in this area.