AI Agents Now Fix Their Own Bugs Automatically

In software development, deploying code is often the easy part. The real begins after the release, when teams must scramble to determine if their latest changes broke something, whether it was actually their fault, and how to fix it before users notice. This post-deployment chaos consumes valuable engineering time and slows innovation. A new approach from LangChain seeks to automate this entire process, creating a self-healing system where AI agents detect regressions, triage causes, and propose fixes autonomously, closing the loop from error to repair without manual intervention.

The core innovation is a deployment pipeline that integrates existing tools with new automated reasoning. The system is built for a GTM Agent running on Deep Agents and deployed via LangSmith Deployments. It leverages an internal coding agent called Open SWE, an open-source async agent capable of researching codebases, writing fixes, and opening pull requests. The missing piece was automated regression detection and triage to connect production errors back to Open SWE, which this pipeline now provides through a two-path workflow triggered by a GitHub Action after each deployment.

Ology starts by capturing build and server logs immediately post-deploy. For build failures, the process is straightforward: if a Docker image fails to build, the pipeline automatically extracts error logs and the git diff from the last commit, then hands this data to Open SWE. Since build failures are almost always caused by the most recent change, this narrow context suffices for the agent to act. Server-side issues, however, require a more sophisticated approach due to background noise like network timeouts and third-party API failures.

To separate deployment-caused errors from existing noise, the system collects a baseline of error logs from the past seven days. These logs are normalized using regex to replace UUIDs, timestamps, and long numeric strings, then truncated to 200 characters, grouping logically identical errors into signatures. After deployment, it polls for errors over a 60-minute window, applying the same normalization. Using a Poisson distribution, it estimates the expected error rate per hour from the baseline and compares it to the observed count in the monitoring window, flagging potential regressions where the observed count significantly exceeds predictions (p < 0.05). New error signatures are flagged if they occur repeatedly.

Statistical detection alone isn't enough, as correlated failures from traffic spikes or external outages can violate independence assumptions. To address this, a triage agent built on Deep Agents acts as a gating mechanism. It receives the git diff and specific errors, first classifying changed files as runtime, prompt/config, test, docs, or CI. If only non-runtime files are touched, it dismisses the error as unlikely to be causal, preventing false positives. For runtime changes, it must establish a concrete causal link between a specific line in the diff and the observed error, returning a structured verdict with decision, confidence, and reasoning.

Once the triage agent green-lights an investigation, Open SWE takes over to work through the bug and open a pull request. The entire flow, from error detection to proposed fix, happens without manual intervention, with engineers only notified at review time. Early show the system is particularly effective at catching subtle bugs like silent failures that return wrong defaults, configuration mismatches, and cascading regressions where fixing one issue reveals another in subsequent deploys.

Despite its successes, the system has limitations. The triage agent currently only looks at the diff between the current and previous deployment, meaning bugs introduced earlier but surfacing later won't be auto-attributed. Widening the look-back could help but risks noisier signals and harder causal linking. Error normalization via regex sanitization, while functional, may still miss grouping related errors due to logic limitations, with potential improvements like embedding messages into a vector space for clustering or using smaller models for classification.

The approach reflects a broader trend toward autonomous systems in deployment. For instance, Ramp's approach involves generating monitors tailored to code changes upfront, providing clearer signals for downstream agents. Future enhancements could include deciding between fixing forward or rolling back based on severity and confidence, rather than always pushing patches. As these systems evolve, they promise to accelerate shipping by reducing the time engineers spend monitoring dashboards, shifting focus from maintenance to building.