← Back to Blog

· Updated · Mason Bachmann

After the Alert: Error Monitoring and Autonomous Maintenance

TL;DR: Error monitoring made production failures visible, and it is still how most teams see what is happening in their software. What has changed is that software can now also do the work that follows an alert: find the cause, write the fix, run CI, and open a pull request for a person to approve. We call that autonomous software maintenance. It sits next to monitoring and uses what monitoring reports.

For ten years, the error monitoring platform has been at the centre of production engineering. Sentry, Rollbar, Bugsnag, Honeybadger and Airbrake capture exceptions, group similar ones together, route alerts to the right engineer, and give the team a dashboard for triage.

These tools are good at what they do, and they keep getting better. Capture is faster, grouping is smarter, and most of them now cover performance, session replay, release health and profiling as well.

What happens after the alert has mostly been a person's job: read it, find the cause, write the fix, open a pull request, merge. That part of the loop is now changing too.

Why the Work After the Alert Was Manual

For most of the history of software, only a person could read a stack trace, understand the code around it, and write a correct fix. Error monitoring was designed around that fact, and designed well.

Ownership rules exist so an alert finds the right person. Triage workflows exist so people can decide which bugs matter. Grouping and deduplication exist because nobody can read 500 identical alerts. All of it gets the right information to the right engineer quickly, and that is still what you want for any problem that needs a person.

What Changed

Three things happened over the last two years.

Frontier AI models can write production code. Until late 2024, AI could suggest code but could not reliably take a production error to a correct fix. Since 2025, frontier models such as Claude can read a stack trace, locate the bug in the source, write a fix in the style of the surrounding code, and explain their reasoning.

CI pipelines became universal. Almost every codebase that ships to production now runs automated tests, linting, and type checking on every commit. This is the safety net that makes automated fixes practical. An agent's change goes through the same checks as anyone else's before it can merge.

Developer time got more expensive. Engineering salaries continued to climb while the volume of production code grew faster than headcount. Having a senior engineer spend 30 minutes diagnosing a null pointer exception costs more every year.

Together, these mean the fix step can now be automated for a meaningful share of production problems.

What Maintenance Adds

Monitoring surfaces information. Maintenance acts on it. For a production error, the pipeline looks like this:

  1. Capture. The error arrives with its context: stack trace, route, request shape, environment. It can come from an SDK in the application or from the monitoring tool the team already runs.
  2. Diagnose. The agent pulls the relevant source code from the repository and finds the cause.
  3. Fix. The agent generates the patch.
  4. Validate. The fix runs through the existing CI pipeline. Tests, linter, type checker.
  5. Ship. The fix arrives as a pull request. Depending on the autonomy level set for the repository, a person merges it, or it merges on its own once CI passes and Bugstack's sandbox proof holds: a test that reproduces the bug fails before the fix and passes after.

Monitoring vendors are building in this direction as well. Sentry's Seer analyses issues inside Sentry and can draft a pull request. We think that is good news for everyone: it shows the work after the alert can be automated, and teams get to choose where that work happens.

Errors are also only one input. The same system can act on failed deploys and failing CI, and scan the repository for known-vulnerable packages, committed secrets, and outdated packages. That is why we call the category autonomous software maintenance.

For a deeper technical breakdown of how this works in practice, see our complete guide to autonomous software maintenance.

What Monitoring Does That Maintenance Does Not

A maintenance system does not replace your monitoring. Monitoring does several things that maintenance has no answer for:

Visibility into errors that can't be auto-fixed. Many production bugs are stack-trace-anchored and small enough to fix automatically. The rest are logic errors, architectural problems, business rule violations, and silent failures. Those need people, and people need visibility. Bugstack, for example, captures uncaught server-side errors. It does not cover browser-side errors or silent failures, and while it watches your metrics, it does not profile or fix slowdowns today.

Aggregate trend analysis. Knowing that errors are up 30 percent week-over-week is useful whether or not the individual errors get fixed automatically.

Long-tail debugging. When a complex bug takes hours of investigation, the context a monitoring tool provides (breadcrumbs, session replay, related events) is what the engineer works from.

Most engineering teams will run both: a monitoring tool for visibility, and a maintenance system that takes the routine fixes off their plate.

Where the Person Sits

In a maintenance system the agent reads the error and writes and tests the fix. A person decides what merges. That decision is the control that matters, so it should be explicit.

Bugstack makes it a setting on each repository: Suggest (it writes the fix and waits), Review (a pull request per fix, a person merges) or Autopilot (it merges once tests pass and the proof is green). New repositories start on Review. In production, sensitive changes, such as rolling back a deploy, always wait for a person, and Bugstack never rotates a secret itself.

What to Expect

Monitoring is staying. The share of production problems that software can fix on its own will grow each year, and more teams will hand that share over as they come to trust it.

The teams running production codebases in 2030 will still open their monitoring dashboard. They will also review the pull requests their maintenance system opened overnight.


Want to see what this looks like in practice? Bugstack is an autonomous maintenance department for your software. It takes problems from its own SDK (and from Sentry, which we connect with you), writes the fix, runs your CI, and sends you a pull request you control. Sign up with GitHub (a card is required) to start a 14-day trial of Bugstack Pro: $50 of credit, plus a first security audit on us. After the trial, Pro is $100 a month with $100 of usage credit every month. Or book a demo and we set it up with you.

Get started →

Bugstack vs Sentry: What Each Does and How They Work Together

Sentry shows you what broke. Bugstack sends the fix as a pull request you control. What each one does, and how they work together.

What Is Autonomous Software Maintenance? Complete 2026 Guide

A guide to systems that find maintenance work themselves: automated bug fixing (once called autonomous code repair), deploy and CI fixes, and repository scans.

The Most Common Production Bugs (And How AI Fixes Them)

The most common production bugs that AI can fix automatically. See real examples of null references, unhandled promises and type errors, with the fix for each.

See it work on your own code.

$100 a month

Includes $100 of usage credit every month. Start with a 14-day trial: $50 of credit and a first security audit on us. A card is required.