Copilot Agent tools and MCP support

Agentic AI workflows are transforming how developers interact with code, and context is key — the more accurate and timely the context, the better the agent can understand, debug, and enhance the code. High-quality context is especially crucial for complex tasks that require not just static code structure, but also runtime behavior and intent.

Every unit test run, for example, contains a wealth of valuable information: runtime values, code execution paths, coverage data, runtime dependencies, and more. If we can efficiently supply this context to an AI agent, its ability to create, fix, and maintain code dramatically improves. This is exactly what Wallaby’s new AI tools and MCP server are designed to do.

We’re excited to announce support for Copilot Agent, Cursor, Windsurf, Cline, RooCode, and many other AI agents, enabling them to access Wallaby’s rich, detailed runtime insights on demand.

The Old Way

Until now, AI agents have had to work with fairly limited context. They could read generic CLI output from a test runner, or pull from basic IDE problem lists and test result panels. While helpful for simple scenarios, this surface-level context didn’t offer deep insights into code behavior, execution, or structure.

Without a deeper understanding of runtime values, precise code coverage, or code runtime relationships, agents often struggled with more complex tasks, like debugging tricky tests or generating nuanced, high-quality test cases.

The New Way

With Wallaby’s MCP server and AI tools, the game changes. Now, agents can go far beyond surface-level outputs and tap into an incredibly detailed, live model of your codebase and test execution environment. They can access:

• Any runtime value — no code modification needed
• Execution paths for individual tests, files, or the whole project
• Branch-level code coverage — for specific tests, lines, or files
• Code dependency graphs
• Test snapshot updates and more

Think of it like solving a problem: the more observations and details we have, the better we can understand the situation and find a solution. In the same way, the more information the agent has about your code’s behavior, the better it can analyze and tackle complex tasks.

Get Started

Wallaby extension v1.0.437 or later is required for this feature.

Wallaby provides two ways to integrate this deep context:

• AI tools inside VS Code: If you’re using Wallaby with VS Code Copilot Agent, you get access to these AI tools out of the box — no MCP server needed.
• MCP Server: If you’re using other editors or AI agents like Cursor, Windsurf, Cline, or RooCode, you can run the MCP server separately to allow your agent to connect and retrieve Wallaby’s context. You can also run the MCP server with Copilot Agent if you prefer to.

You can easily manage settings with the Wallaby: Open MCP Settings command from VS Code.

Want to dive deeper into what’s possible? Check out the documentation.

What You Can Ask Your Agent To Do

Here are just a few example prompts and queries of how you can use Wallaby’s context to supercharge your agent’s capabilities:

Fix Failing Tests

• Fix all failing tests, check runtime values first to see what is wrong
• Fix test under cursor, check coverage before and after the fix
• Fix tests covering foo.ts or bar function, update snapshots if needed

Create New Tests

• Add tests for uncovered lines of the file, verify added test coverage and overall coverage after
• Find tests for function under cursor using Wallaby coverage tools, suggest new tests for uncovered lines

Analyze, Plan, and Learn the Codebase

• Analyze coverage of test under cursor
• What tests are affected by my current code changes?
• Debug failing test using runtime values
• List functions of source.ts covered by both "test 1" and "test 2"
• Identify potential areas for code optimization based on test coverage data

These prompts can be combined to create more advanced workflows. For example:

• Add this new feature to the project, but add tests first and ensure all tests pass and verify coverage is at least 80% afterwards.

The possibilities are endless — but a quick tip: break complex tasks into smaller, manageable steps. Smaller, focused tasks are much easier for agents to execute well. For example, fixing one test at a time is typically more reliable than trying to fix a dozen at once.

You can also guide your agent to use Wallaby’s tools in specific, preferred ways by customizing their rule configurations:

• Copilot custom instructions
• Cursor rules
• Windsurf rules
• Cline rules

By fine-tuning your agent’s interaction with Wallaby’s tools, you can create powerful, flexible workflows tailored exactly to your needs.

Conclusion

Wallaby’s MCP support and AI tools open a whole new dimension for developer productivity. Where agents previously had to rely mostly on static code analysis, Wallaby now unlocks access to rich, real-time runtime data, execution paths, code relationships, and dynamic insights from your test runs — enabling a level of assistance and understanding that simply wasn’t possible before.

Whether you’re debugging failing tests, adding new ones, or exploring a massive codebase with tests, Wallaby + your favorite AI agent can now work together more intelligently, accurately, and efficiently than ever.

We invite you to explore Wallaby AI tools and MCP server, and share your feedback with us. Your input is invaluable as we continue to refine and enhance Wallaby to meet your evolving needs.