The loop that ships itself: How Stratus built an autonomous testing fleet

When code velocity turns verification into a bottleneck

Stratus, a cloud platform managing CAD viewers, real-time status updates, and custom workflows for mechanical, electrical, and plumbing (MEP) contractors.

As Stratus’s engineering team grew to 30 developers and leaned heavily into AI coding agents, code velocity skyrocketed. However, this hyper-productivity exposed a new bottleneck: testing capacity.

While developers were using AI to amplify their impact, testing remained tied to manual review. A lean, three-person QA team was suddenly tasked with validating an unprecedented volume of tickets across a highly dynamic UI.

Before adopting mabl in August 2024, this testing bottleneck was compounded by a brittle tech stack: self-managed virtual machines running fragile legacy scripts overnight. Switching to mabl immediately cut test execution times by 20% and eliminated tedious locator maintenance through self-healing locators. Yet, the core structural challenge remained: Stratus needed a way to author tests at the speed of AI-generated code without burning out their QA team.

Shifting test authoring ownership unlocked valuable test coverage

When Anthony Anderson joined as Director of Software Engineering, his goal was to transition from weekly releases to continuous deployment, mandate a regression test for every customer-reported bug, and expand test coverage — all without hiring additional headcount.

"We're cranking out more code than we've ever done before. So we need to be able to test more, and we can't rely on just three people to build all of those tests for us. This allows us to exponentially create more tests. We can focus in on what needs to be created… and improve our coverage overall."

– Anthony Anderson, Director of Engineering

Stratus achieved this transition by handing mabl’s testing harness to developers via mabl’s Model Context Protocol (MCP). Instead of manually recording user workflows, developers point Claude at a Jira ticket. mabl’s MCP server parses the acceptance criteria and generates an executable mabl test directly from the ticket details. Today, Stratus executes thousands of mabl MCP requests every month.

By embedding test creation inside developer workflows, test authoring became a shared engineering responsibility. The QA team shifted from manual test builders to testing architects.

Building an orchestrated, agentic pipeline with guardrails

To run this process automatically, Stratus built an orchestration pipeline using nine n8n bots powered by mabl’s MCP server.

1. Evaluation: An n8n agent inspects new Jira tickets and pull requests to determine if the change requires UI-level testing.
2. Drafting: Downstream agents construct preconditions and outline step-by-step test logic.
3. Integration: A dedicated agent initiates a mabl authoring session via the MCP server, assigns the test to the relevant suite, and links it directly to GitHub Actions.
4. Monitoring: Two supervisory agents monitor error rates and runtime performance across the workflow.

The routing is carefully confidence-gated. If the AI's assessment scores above a specific threshold, the system proceeds automatically. If it falls below that threshold, it sends a personalized notification to the appropriate QA engineer and halts. Furthermore, three explicit human checkpoints (the verdict, the preconditions, and the test steps) ensure the workflow requires human sign-off.

The agentic workflow Stratus created with mabl’s MCP uses a practical test case methodology to ensure the best quality testing starts with unit/integration tests, and then finishes with end-to-end testing. Because of this workflow, Stratus has been able to generate the right API and end-to-end tests at the right level, resulting in more effective testing and fast and efficient software delivery.

Decoupling code generation from verification

Stratus uses AI coding tools like Claude, Cursor, and Copilot across its development team. To avoid feedback loops where AI validates its own errors, Stratus keeps code generation strictly separated from test execution.

AI tools generate the application code, while mabl validates that the software meets functional requirements.

To streamline execution further, mabl maps code changes to specific application paths for Stratus. This allows the team to only run the tests affected by a pull request, rather than executing the entire suite on every commit.

"We've evolved — even in the last six months to three months, we've 10X'd. And that's thanks to our strategy, the mabl team,  and the open APIs. We've been able to leverage that to continue to take Stratus to the next level, to the stratosphere."

– Glenn Holmes, QA Engineer

Elevating the team to system coaches

At Stratus, automation elevated the team. Their QA engineers shifted from hand-crafting tests to coaching the system that creates them. Instead of building coverage from scratch, they now quickly review AI-drafted tests and step in only when human judgment is truly needed. This transformation inspired a simple playbook they now share with others: connect the hand-offs, build human gates, enable the automation, and supervise it before you trust it.