The problem
This project started with a problem familiar to platform teams, maintainers, and engineers responding to production failures:
The result is autonomous-debugger, a multi-primitive recipe that treats debugging as an evidence-producing workflow rather than a chat answer.
The separation that matters
There are two agents in this story. I used an AI coding agent to develop the recipe. But that development agent was not allowed to become the debugger. At runtime, the recipe itself receives only REPO_URL. GPT-5.6 Sol through a configurable model API becomes its reasoning layer, and Solari becomes its hands and its audit trail.
A genuinely blind test
A separate fault-injection workspace took the production p-map package, verified its baseline, and introduced four plausible regressions in four neutral-looking commits. It exposed the result through a private Git endpoint. The debugger got the clone URL - nothing else, and the endpoint is intentionally absent from every publishable artifact.
Its first sandbox reproduced 25 failures. The failures cut across ordering, skip handling, validation, concurrency, and backpressure, which is exactly what made this more realistic than handing a model a tidy bug description.
The uncomfortable green build
The first complete run was technically green: all 53 tests passed. It was also wrong. The generated patch repaired production behavior and widened a timing assertion in a test. The agent had changed the evidence used to judge itself.
I rejected the run and strengthened the product rather than polishing the demo. The patch prompt now forbids test changes. More importantly, the patch tool independently parses every changed path and rejects test-file modifications before applying anything. Evidence creation is gated on a passing patch, and report inputs must match the exact patch and replay retained in verified state.
What the debugger found
| Fault | Failure | Repair |
|---|---|---|
| Config | concurrency silently renamed to concurrent | Restored the public option and dependent default |
| Filtering | Skip predicate inverted | Restored normal-value retention |
| Scheduling | Capacity guard changed from AND to OR | Required both limits to have capacity |
| Ordering | Index incremented before capture | Restored zero-based assignment order |
On the integrity-enforced run, the recipe succeeded on repair attempt two. The patch touched only index.js. A post-run comparison against the sealed manifest showed that its content exactly reversed every injected source change.
Why three primitives, not one
The inspection sandbox establishes the failure independently. The repair sandbox prevents accidental dependence on state left behind by inspection. The recorded browser turns a transient run into reviewable evidence. None of those roles is interchangeable.
The replay is rrweb NDJSON downloaded immediately after session release, because signed cloud URLs expire. A local player makes the artifact durable and inspectable.
Watch the evidence replay View the recipe sourceWhere this becomes a product
The first customer is not “everyone who writes code.” It is the team paying an expensive interruption tax: platform engineers triaging failed upgrades, maintainers reproducing dependency regressions, support engineers escalating customer repositories, and SREs handling incidents where the first hour disappears into environment setup.
| Buyer or user | Pain today | Benefit |
|---|---|---|
| Platform and SRE teams | Senior engineers repeatedly rebuild failing environments | Sandbox reproduction turns an ambiguous ticket into a verified candidate fix |
| Developer-tool vendors | Support cannot safely run customer code on employee machines | Ephemeral execution contains untrusted workloads and preserves an audit trail |
| Open-source maintainers | Issue reports omit the context needed to reproduce failures | A consistent incident packet includes logs, patch, test result, and replay |
| Engineering leaders | AI-generated fixes are hard to govern or trust | Policy gates and clean-room verification make outcomes reviewable |
The wedge is automated bug reproduction and patch verification for CI failures. The broader platform opportunity is an evidence layer for agentic engineering: every autonomous change can be tied to the environment it ran in, the policy it passed, and the artifact a human can replay.
That changes the economics of debugging. The product does not promise to eliminate engineers; it compresses the low-leverage setup and reproduction loop so engineers spend their time on judgment. Value can be measured in mean time to reproduce, mean time to verified repair, escalation rate, first-pass acceptance, and reviewer minutes saved.
What changed while building it
- Provider portability: a provider-specific assumption became a configurable model API using the Responses interface.
- Observable orchestration: phase logging and incomplete-turn recovery replaced a silent model loop.
- Cumulative retries: every retry still starts clean, but now receives the previous patch and verification output so it can produce a complete replacement.
- Test integrity: policy is enforced in code, not entrusted only to a prompt.
- Durable evidence: browser recordings are downloaded and paired with a local replay page before signed URLs expire.
The lesson
That is the contribution I want to make to the Solari cookbook: a small but complete pattern for turning cloud primitives into a trustworthy engineering workflow.