Systems integration · agent orchestration · automated investigation
Automated bug investigation, from Azure DevOps to a reviewed GitHub issue
A pipeline that investigates treated bugs with parallel coding agents and writes each resolution plan into a reviewable issue — where every mutating step is decided by deterministic script logic, never by an agent reporting its own success.
Tickets lived in Azure DevOps. Moving them to GitHub was never the hard part — understanding them was. This system does the investigation, stops short of the fix, and hands a human a plan.
The problem
Bugs were filed in Azure DevOps. Migrating them to GitHub should have been a data move, and instead it was two jobs: move the tickets, and investigate each one — root cause, defect location, proposed fix, what could regress.
Investigating is skilled work per bug. A bulk export would have moved the tickets and left the understanding behind: the same fields, filled in the same shallow way, with nobody any better off. So the choice was between paying for the investigation by hand forever, or automating it — and automating it meant trusting agents, which is where it gets interesting.
How it works
One bug in, one investigation out. The fan-out is the easy half; the gate is the point.
The scope is deliberately narrow: bug in, reviewed issue out. The system does not write application code, does not open pull requests, and does not decide that a fix is ready. It hands over a plan a person can read and argue with.
Every bug in a run reads the same read-only worktree rather than getting its own clone. That works because the investigation agent only ever reads code and writes its own uniquely named report — so a single detached checkout is both safe and cheap.
What made it interesting: the trust problem
An agent that reports success is not evidence of success. It can hallucinate a completion, misread its own output, or be interrupted halfway — and a pipeline that takes its word will happily create issues from nothing.
So the design puts a hard line between what an agent says and what the system does. Every mutating step — creating an issue, commenting on a ticket, changing a tag, updating state — is decided by deterministic script logic reading a verified report file on disk.
Two smaller decisions fall out of the same instinct. Concurrent state writes are guarded by a lock and written atomically, so two runs cannot corrupt each other's bookkeeping. And a partially failed run has a repair script that finishes the missing steps — rather than a re-run, which would investigate the same bugs again and risk duplicate issues.
Everything defaults to a dry run. You can see exactly what would be created before anything touches a real ticket.
What it saves, per sprint
The saving is not the migration. It is the investigation: every bug this handles is one somebody does not have to read, trace, diagnose, plan a fix for and judge for regression. That work lands on whoever picks the ticket up, and it is the same work whether or not anyone has already done it once.
So the saving scales with two things, and both are facts about a workflow rather than about the software — how many bugs a sprint moves, and how long one investigation takes by hand. The arithmetic is trivial, which is rather the point:
| bugs / sprint | 30 min each | 1 hour each | 90 min each | 2 hours each |
|---|---|---|---|---|
| 5 | 2.5 | 5 | 7.5 | 10 |
| 10 | 5 | 10 | 15 | 20 |
| 20 | 10 | 20 | 30 | 40 |
| 40 | 20 | 40 | 60 | 80 |
Hours, not a measurement. Pick the row and column that match reality.
Ten bugs a sprint at an hour each is a working day and a bit recovered every sprint. And that is only the first-order saving. The larger one is harder to count: because the plan is the issue body, the person reviewing it reads a plan instead of re-doing the investigation — so review gets cheaper as well as faster. There is also an outcome that beats saving time outright: a bug already fixed in the code is closed with the evidence, and nobody investigates it at all.
There is no headline number here, deliberately. Nobody has measured how long a manual investigation takes, and a figure I invented would be worth less than no figure at all. That is why the table is a table of inputs: the mechanism is real, the multiplication takes seconds, and the two numbers belong to whoever runs the system.
What it does not do
The boundary is a feature, so it is worth stating plainly: no code changes, no pull requests, no test runs, no assignment. The tracking issue is the end of this system's responsibility.
Facts, in a form you can check
| Language & licence | Bash · MIT |
|---|---|
| Surface | Ubuntu and Debian, WSL2 included, with Windows launcher scripts |
| Fan-out | One coding agent per bug, driven through Herdr panes |
| Isolation | One shared read-only worktree per run, not one clone per bug |
| Validation | Reports are structurally checked before anything is written |
| Concurrency | State writes lock-guarded and atomic |
| Safety default | Dry run; the installer can verify an installation without changing it |
| Delegation | Root-cause analysis itself belongs to the target repository's own agent, not this repo |