How Docker's Virtual Agent Fleet Accelerates Development and Testing

Introduction

At Docker, the Coding Agent Sandboxes (colloquially known as "sbx") team has pioneered a novel approach to software quality and velocity. They built a secure, microVM-based isolation layer that enables AI coding agents—such as Claude Code, Gemini, Codex, Docker Agent, and Kiro—to operate autonomously without compromising the host system. Each agent enjoys full control within its sandbox, including its own Docker daemon, network stack, and filesystem. Recently, the team extended this concept into a fully autonomous virtual team: a fleet of seven AI agent roles that handle testing, issue triage, release note generation, and even bug fixes—all running in CI without human intervention. This article explores how the Fleet works and the principles behind its success.

The Fleet: A Virtual Team of AI Agents

The Fleet is not a set of static scripts but a collection of agent personas defined using Claude Code skills. These skills are markdown files that describe a role: what the agent knows, how it makes decisions, and which tools it can use. Unlike traditional automation scripts that execute predefined steps, a skill gives the agent judgment and context. For example, a script encountering an unexpected test failure would stop; a skilled agent investigates the root cause. This distinction is critical for handling real-world complexity.

Key Agent Roles

• CLI Tester: Builds binaries, exercises command-line interfaces across platforms, and reports issues found during exploratory testing.
• Build Engineer: Manages build pipelines, monitors for regressions, and ensures consistent artifact quality.
• Bug Hunter: Triages incoming issues, reproduces problems, and sometimes prepares fixes.
• Release Note Writer: Automatically drafts changelogs and release summaries from commit history and test results.
• Integration Tester: Runs end-to-end tests across multiple OS environments (macOS, Linux, Windows) and upgrade paths.
• Performance Analyst: Conducts load testing to catch resource leaks and performance degradations.
• CI Coordinator: Orchestrates the other agents, manages workflows, and collects results.

These roles work together autonomously, each contributing to the team's daily operations.

Local-First Development Philosophy

A core design principle of the Fleet is "local first, CI second." Every skill is developed and iterated on the developer's local machine before being deployed to continuous integration. This approach eliminates the painful cycle of commit-push-wait-read-logs that plagues CI-only agent development. Instead, developers invoke the skill from their terminal, watch the agent think in real time, and tweak the skill file until behavior is correct—all within seconds.

Iteration Speed Matters

To illustrate: when creating the /cli-tester skill, the team didn't start by writing a GitHub workflow. They ran it locally, observed how it built binaries, issued CLI commands, and discovered issues. Only after local validation did they wire it into a nightly workflow. The same skill file that runs on a developer's laptop runs unchanged in CI. The workflow merely sets up the environment and calls the skill. No separate CI version, no translation layer—one skill, two runtimes.

This local-first strategy dramatically shortens feedback loops. A mistake that might take 10 minutes to debug in CI can be resolved in 30 seconds locally. It also gives developers intimate insight into agent reasoning, helping them craft better role descriptions.

Skills: More Than Scripts

The concept of a "skill" is central to the Fleet. A skill file is a structured prompt that defines a persona. It includes the agent's expertise, values, communication style, and permissible actions. For instance, the Build Engineer skill might specify knowledge of the project's build system, preferred logging practices, and a rule to never modify source code without explicit permission. These skills are version-controlled, tested, and shared across the team.

Because skills are just markdown files, they are easy to write, review, and update. They also encourage a culture of agent-based automation where anyone on the team can propose a new role or refine an existing one. The skill-based approach also supports composability: a meta-skill can orchestrate multiple agents, akin to a team lead assigning tasks.

From Laptop to CI: Seamless Deployment

The Fleet runs in CI on every push to main and on a nightly schedule across three operating systems. The CI coordinator agent reads the skill definitions, delegates tasks to appropriate agents, and collects results. If an agent finds a bug, it can file an issue. If a test fails, the agent will retry with additional diagnostics before escalating. The entire pipeline is transparent: logs are archived, and a summary is posted to a dedicated Slack channel.

One notable implementation detail: the Fleet uses Docker's own sbx tool to sandbox each agent, ensuring that agent actions are isolated even from each other. This prevents any single agent from corrupting the environment and allows parallel execution when safe.

Real-World Impact and Benefits

Since deploying the Fleet, the team reports a noticeable acceleration in release cycles. What previously required hours of manual testing and triage now happens overnight autonomously. The agent roles also catch edge cases that traditional scripts might miss—for example, a subtle network timeout that only manifests when a sandbox is under load.

Equally important, the Fleet frees human developers from repetitive tasks. Instead of spending mornings triaging a backlog of issues, engineers can review the Fleet's daily report and focus on high-priority work. The release note writer ensures that every shipping cycle has clear, consistent documentation without last-minute scrambling.

Future Directions

The team plans to expand the Fleet with more specialized roles: a documentation writer that updates guides based on API changes, a security auditor that scans sandbox configurations for vulnerabilities, and a user simulation agent that tests workflows as a real developer would. They also aim to make skill development even simpler, possibly through a visual editor or agent discovery mechanism.

Conclusion

Docker's Coding Agent Sandboxes team demonstrates that a fleet of AI agents can be more than a novelty—it can be a practical, high-impact tool for software teams. By focusing on local-first iteration, skill-based role definitions, and seamless CI integration, they have built an autonomous virtual team that ships faster and more reliably. The approach is adaptable and could serve as a blueprint for other organizations looking to harness the power of AI agents for testing, deployment, and maintenance.