7 AI Agent Roles That Revolutionized Docker's Testing Workflow (And How You Can Use Them)

At Docker, the Coding Agent Sandboxes team (known internally as "sbx") builds a fleet of AI agents that act like a virtual team—testing, triaging, and even fixing bugs without human oversight. These agents operate inside secure microVM-based sandboxes, giving each one full autonomy over its own Docker daemon, network, and filesystem. Over the past few weeks, the team created seven distinct agent roles, each defined by a simple markdown file—a skill—that describes a persona, responsibilities, and allowed tools. Unlike traditional scripts that run predefined steps, these skills enable agents to use judgment: when a test fails unexpectedly, a script stops, but an agent investigates. This listicle unpacks each role, the core design principle of running locally first, and how you can apply similar patterns to your own workflows.

1. Exploratory Tester (/cli-tester)
2. Build Engineer
3. Release Notes Writer
4. Issue Triage Agent
5. Bug Fixer
6. Regression Tester
7. CI Monitor

1. Exploratory Tester (/cli-tester)

The Exploratory Tester (skill name: /cli-tester) is the fleet's hands-on quality assurance agent. Its job is to build the sbx CLI from source, then exercise every command – create, start, stop, remove – across macOS, Linux, and Windows. Unlike a script that checks for exit codes, this agent uses judgment: it tries edge cases, mounts workspaces, simulates upgrade paths, and reports any unexpected behavior. The skill file defines its persona as a meticulous tester who never assumes success. Because the same skill runs on a developer's laptop first (local iteration takes seconds), debugging occurs before it ever hits CI. It runs nightly across all platforms, catching resource leaks and regressions that traditional tests would miss.

2. Build Engineer

The Build Engineer agent manages the entire build pipeline for the sbx project. It knows how to compile binaries for multiple operating systems, run unit tests, and verify that artifact signatures are correct. Its skill file describes it as “the person who ensures nothing leaves the workshop broken.” It makes decisions about whether a build failure is a test flake or a real issue – if a test fails due to a timeout in a CI runner, it re-runs; if it fails consistently, it opens a detailed report. This role runs alongside the Exploratory Tester but focuses on compilation and static analysis. By local-first design, developers can invoke it on their machine to validate changes before pushing, dramatically reducing CI failures.

3. Release Notes Writer

The Release Notes Writer agent transforms raw git logs and changelogs into polished, user-friendly release notes. Its skill file gives it the persona of a technical writer who knows the product inside out. It scans commit messages, looks for changes in public APIs, and groups updates into categories like “New Features,” “Bug Fixes,” and “Known Issues.” Crucially, it doesn’t just concatenate messages – it rewords and prioritises what’s important for end-users. This agent runs automatically after every release tag, and its output is posted to the team’s documentation site. The same skill can be invoked locally by any engineer to preview release notes before finalising, ensuring consistency and saving hours of manual editing.

4. Issue Triage Agent

The Issue Triage Agent tackles the growing backlog of GitHub issues without adding overhead to the human team. Its skill defines it as a “first responder” that reads each new issue, checks for duplicates, labels it by severity and area (e.g., CLI, sandbox, networking), and asks clarifying questions when details are missing. It can even suggest possible workarounds by searching the codebase. Importantly, it knows when to escalate: if an issue mentions a crash or security concern, it adds a priority: critical label and pings the on-call engineer. The triage agent runs continuously on new issues, reducing response time from hours to minutes. Like all roles, it was first tested locally on a sample issue before deployment.

5. Bug Fixer

The Bug Fixer agent is the most autonomous role – it fixes bugs without human intervention. Its skill describes it as a careful senior engineer who never pushes code without running the full test suite. When the Issue Triage Agent or a manual reporter files a bug, the Bug Fixer agent examines the codebase, reproduces the issue in a sandbox, proposes a fix, applies it, runs tests, and opens a pull request with a description of the root cause. It handles straightforward issues like typos, misconfigurations, and minor logic errors. For complex bugs, it leaves a detailed analysis for human review. This agent runs on-demand but also cycles through unresolved low-hanging-fruit issues daily. It has already fixed several minor bugs, freeing developers to focus on feature work.

6. Regression Tester

The Regression Tester agent maintains a suite of end-to-end tests that simulate real user workflows. Its skill file gives it the persona of a “skeptical user” who tries to break the product. It works in tandem with the Exploratory Tester but focuses on long-running scenarios: stress tests with many concurrent sandboxes, networking chaos, and upgrade rollbacks. When it detects performance degradation or new failures, it logs the exact sequence of commands and flags the commit that caused the change. This role is essential for sustaining rapid releases without regressions. Because the skill is first iterated locally, engineers can simulate the full stress test on their machine in minutes, rather than waiting for a dedicated CI pipeline.

7. CI Monitor

The CI Monitor agent watches over all CI pipelines and reports on the health of the fleet itself. Its skill defines it as a “devops liaison” that understands the workflow configuration and runner status. It checks for flaky tests, stalled jobs, and infrastructure errors. When something goes wrong – say, a runner runs out of disk space – the CI Monitor agent diagnoses the issue, reruns failed jobs with fresh sandboxes, and updates the team’s internal dashboard. It also posts release summaries and weekly reliability reports to the team chat. Like every skill, it runs locally first, allowing engineers to test agent behavior in their own CI simulation before deploying changes. This ensures the fleet’s own reliability is as robust as the product it tests.

Conclusion

The Docker Coding Agent Sandboxes team proves that a fleet of AI agents can dramatically accelerate shipping without sacrificing quality. Their approach – build a skill as a persona, run it locally first, then reuse it exactly in CI – turns agent development into a rapid, iterative process. Each of the seven roles contributes a specific capability, from exploratory testing to bug fixing. By applying these same patterns, your team can automate routine tasks, reduce manual triage, and maintain a high velocity of releases. The key lesson: treat agents as team members with judgment, not as scripts. Start small with one skill, test it on your laptop, and let the fleet grow organically.