Docker's Coding Agent Sandboxes team, known as “sbx,” has pioneered a groundbreaking approach to software development by creating a virtual team of seven AI agents called the Fleet. This autonomous team tests products, triages issues, posts release notes, and even fixes bugs—all running in CI without human intervention. Built on Claude Code skills, the Fleet operates with role-based personas and judgment instead of rigid scripts. Here are ten essential insights into how this fleet of agents revolutionizes shipping speed and developer productivity.
1. What Is the Fleet?
The Fleet is a virtual team of seven distinct AI agent roles that automate critical tasks for Docker's Coding Agent Sandboxes (sbx) project. These agents run autonomously in CI, handling everything from exploratory testing to bug fixing. Each agent has a specific persona, such as build engineer or triage specialist, and accesses a secure, microVM-based sandbox environment. This setup allows agents to operate with full autonomy—managing their own Docker daemon, network, and filesystem—without affecting the host system. The Fleet ensures faster, more reliable releases by handling repetitive and complex tasks that would otherwise consume developer time.
2. Skills Over Scripts: The Core of the Fleet
Unlike traditional automation scripts that execute fixed steps, the Fleet relies on Claude Code skills—markdown files that define an agent's persona, responsibilities, and allowed tools. A skill isn't a set of instructions like “run these commands,” but a role description that says “You are the build engineer, here's what you know and how you make decisions.” This distinction is crucial because agents need judgment, not just procedures. When a test fails unexpectedly, a script stops; but a role investigates. Skills empower agents to adapt, troubleshoot, and learn from failures, making them far more robust than conventional automation.
3. Local First, CI Second: A Game-Changing Principle
The Fleet's design principle is deceptively simple: every skill runs on your machine first. Before wiring an agent into GitHub Actions, developers run it locally, watching the agent think, test, and report. For example, the /cli-tester skill was developed entirely on a developer's laptop. They observed it building binaries, exercising CLI commands, and finding issues. This local-first approach eliminates the painful commit-push-wait-read-logs cycle of CI-only agents. Iteration takes seconds instead of minutes, allowing rapid refinement. Once the skill works perfectly on the desktop, it is promoted to CI—without any changes.
4. CI as Just Another Runtime
CI is treated as a secondary runtime for the same skill developed locally. The /cli-tester that runs nightly on macOS, Linux, and Windows runners is identical to the skill invoked from a terminal. The CI workflow only sets up the environment, checks out code, and calls the skill—no separate “CI version,” no translation layer. This consistency ensures that behavior observed locally is exactly what happens in CI, reducing surprises and debugging headaches. It also means developers can trust that the agent's performance in CI reflects its true capabilities.
5. The /cli-tester: A Case Study in Autonomous Testing
The /cli-tester role exemplifies the Fleet's power. It is the exploratory tester that builds the sbx CLI, exercises all commands, and reports issues. Developed locally first, it now runs nightly across three platforms (macOS, Linux, Windows) in CI. It checks upgrade paths, network configurations, and resource leakage under sustained load. Unlike human testers who need breaks, the /cli-tester works 24/7, catching regressions before they reach users. Its autonomy frees developers from manual regression testing, allowing them to focus on feature development and complex problem-solving.
6. Seven Roles, One Team: How the Fleet Divides Work
Beyond the /cli-tester, the Fleet includes six other agent roles. Each has a unique persona: a build engineer for compilation and packaging, a release manager for changelogs and deployment, a triage specialist for Issue backlog management, a bug fixer for low-risk patches, a documentation writer for keeping docs updated, and a performance monitor for resource usage analysis. These roles collaborate autonomously: the triager identifies issues, the bug fixer implements fixes, the tester validates, and the release manager publishes updates. This division of labor mirrors a human team but operates at machine speed.
7. Secure MicroVM Isolation Ensures Safety
Each AI agent operates inside a secure, microVM-based sandbox provided by the sbx project. This isolation means agents have their own Docker daemon, network stack, and filesystem—completely separate from the developer's host. Even if an agent misbehaves or a bug triggers unintended actions, the host remains unaffected. This security layer is critical for giving agents full autonomy, as it prevents any potential damage to production environments. The microVM approach combines the speed of containers with the security of virtual machines, making it ideal for autonomous AI operations.
8. Faster Iteration Through Local Development
The Fleet dramatically accelerates shipping velocity. By developing agents locally first, developers can iterate in seconds rather than waiting for CI feedback loops. Traditional CI debugging involves committing, pushing, waiting for workflow completion, reading logs, and guessing what went wrong. With local-first skills, developers see the agent's reasoning in real-time, identify misunderstandings, tweak the skill file, and reinvoke instantly. This rapid iteration reduces the time to develop robust agents from days to hours. Once refined, the same skill runs in CI without modifications, maintaining velocity.
9. Reduced Developer Toil and Increased Productivity
The Fleet eliminates repetitive tasks that consume developer time and energy. Manual testing, triage, release note writing, and simple bug fixes are now handled autonomously. Developers no longer need to run nightly test suites or sift through Issue backlogs. Instead, they oversee the Fleet, handle complex issues that require human judgment, and focus on high-value work like architectural improvements. This shift reduces burnout and increases job satisfaction. The original team reported that the backlog no longer feels like a full-time job, thanks to the Fleet's autonomous triage and bug fixing.
10. The Future: More Scalable and Smarter Agents
The Fleet is just the beginning. As Claude Code skills evolve, Docker plans to add more agent roles, improve collaboration between agents, and integrate with external tools like GitHub issues and monitoring dashboards. The local-first, CI-second principle scales naturally—new agents are developed quickly and deployed seamlessly. The team envisions a future where autonomous AI teams handle entire release cycles, from development to deployment to monitoring. By reducing human intervention in routine tasks, Docker aims to supercharge innovation while maintaining reliability. The Fleet proves that AI agents can be trusted partners in shipping software faster.
In conclusion, Docker's Coding Agent Sandboxes team has demonstrated a revolutionary approach to software development by creating a virtual AI agent team that operates autonomously. Through local-first development, role-based skills, and secure microVM isolation, the Fleet accelerates testing, triage, and bug fixing. Developers are freed from tedious tasks and can ship updates faster and with higher confidence. As this technology matures, it promises to reshape how teams build and maintain software, making AI a core part of the development workflow.