What if saying ‘Claude, build me a new cloud platform; make no mistakes’ actually worked???
Starting today, agents can build, debug, and test large-scale systems with Antithesis—from initial code to fully validated releases. That includes using time travel to solve any bug that you’ve found.
Whenever you find a bug in Antithesis, our deterministic environment gives you a perfect, bit-for-bit repro of the exact scenario that happened. What’s more, our environment gives you a time machine, called the Multiverse Debugger, that lets you rewind to any moment in the history of that bug, down to the nanosecond. Once you’re there, you can “branch time” by opening a fully deterministic terminal and running any commands you want: get a dump of your system, query its state, extract files, or try something different from the original history to see what happens instead. You can do things like find out exactly when something went wrong, test hypotheses about what might be causing a bug without having to find it again, or just extract that one key piece of information you didn’t know you needed to log.
Human users of Antithesis have had manual access to this feature for a while, and it’s one of our most beloved capabilities. Today, we’re making it available for easy use by your agents. This gives you agent-written software you can ship with confidence, tested against the conditions it will face in the real world.
Run it, don’t just read it #
Like you, we’re drowning in code review. Agents can author code faster than we can check it. Having another agent review the diff helps, but we also need evidence that the system behaves correctly when actually run.
A great example is a bug we found in etcd. The project already has a sophisticated test suite, including a checker that looks for linearizability violations. If a write completes and you then ask for the latest value, you shouldn’t get an older value back. Unfortunately, there was a bug that made it do exactly that. This bug had already caused production outages, but nobody knew what caused it.
The bug required a sneaky set of circumstances to manifest: a well-timed while the leader was stuck; then two other nodes electing a new leader and continuing to accept writes, then the old leader resuming and still thinking it was in charge. But the thing is, when you run real systems at scale, this sort of thing happens all the time. Yet it’s devilishly hard for humans or agents to notice this kind of bug when it’s authored, or in code review. Antithesis reliably catches them (it caught this one), but what then?
Running the tests in Antithesis exposes the sequence of events that trigger this bug, and deterministic replay lets us go back and investigate. But until today that investigation needed a person to operate the debugger and pass information back to the agent. With this release, the agent can do that itself: return to the failing execution, inspect what happened, and work on a fix. It can then run the changed code in Antithesis to check whether the fix holds up.
Here’s an example of Claude doing just that with a bug we found in HashiCorp’s Raft implementation:
(This replay is rebuilt from the original screen recording.) And here’s an animated explanation of exactly how Claude is using time travel to hunt the issue:
We want that work to happen before a PR lands in someone’s review queue. The agent should have already investigated failures and tested its fixes, with the results there for the reviewer to inspect. That’s a much better use of a human’s time than reviewing code that isn’t ready for production.
Ultimately, we believe that this will enable us to close the loop and have agents ship reliable, serious software systems in high-stakes situations, at unimaginable speeds, but that’s a topic for our next announcement.
Try it yourself #
To get started today, install (or update) our agent skills and point your agent at a failing property in your Antithesis tests. (If you’re not using Antithesis yet and want to learn more, get in touch!) The antithesis-debug skill covers how to use the Multiverse Debugger, while our other skills cover the rest of the loop.
You can also manually use the Multiverse Debugger: either through the Snouty CLI’s snouty runs exec command or by calling the /command API endpoint with any HTTP client. However you call it, the Multiverse Debugging API accepts the Bash command or script you want to run, the moment you want to debug from (for example, the moment that an assertion failed), and the ID of an in-progress run. It returns the output of your command, run in a new branch of the multiverse—so you can run destructive commands, like restarting a node or editing a file on disk, without losing your ability to reproduce the original bug.
Now that multiverse debugging is programmable, you and your agents can easily chain it with other Antithesis features to build workflows. For example, you can use snouty runs search in the CLI or the Event set API to find property violations, then jump straight into debugging them during a run.
This is only one step in a bigger loop: you and your agents can run scripts to get diagnostic outputs from your test runs, use that output to investigate the failure and fix it, then launch a new test run to validate it worked.
If you’re on Release 64, you can try agentic debugging today. If you or your agents use it to find a tricky bug, we’d love to hear about it.