← All work

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 pipeline: one tagged bug per investigation agent, validated before anything is written Azure DevOps bugs tagged for migration are checked out into one shared read-only worktree. One investigation agent per bug runs in parallel through Herdr panes. Each agent writes a uniquely named report file. A deterministic gate checks the report contains every required section; only then is a GitHub tracking issue created. Two other outcomes post a comment and tag on the original ticket instead. Source Azure DevOps bugs tagged for migration One per run, not per bug A shared read-only worktree detached checkout · never written to Parallel investigation — one agent per bug Claude Codeagent · bug 1 Claude Codeagent · bug 2 Claude Codeagent · bug 3 Claude Codeagent · bug n driven through Herdr panes each writes its own report file The gate — deterministic Every required section present? A complete plan creates the tracking issue the plan is the issue body Not enough information comments the blocker creates nothing · marks BLOCKED Already fixed in the code posts the fixing commit creates nothing · retags
One bug in, exactly one of three things out. Nothing is created unless a report passes the gate — a report missing any required section is treated as a failed investigation, not as a plan.

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.

The trust boundary: the agent's output is treated as input, not as truth On the left, an agent produces a report file. A dashed vertical boundary separates it from everything the system does. On the right, deterministic script logic reads the file, validates that every required section is present, and only then performs a mutation. What the agent produces a report file, on disk → Root Cause Analysis → Resolution Plan → Defect Location → Proposed Fix → Files to Modify → Regression Risk …and the rest of the required set the boundary What the system acts on Deterministic script logic reads the file 1 · is every required section present? a missing one = failed investigation 2 · has this bug already been handled? the state map is consulted, under a lock 3 · only then, one mutation issue · comment · tag · state write
The agent's claim is never the trigger. And because the boundary is a file on disk, a half-finished run leaves evidence rather than a silent success — which is what makes the repair path possible.

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:

Hours recovered per sprint — by how many bugs a sprint moves, and how long one manual investigation takes.
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 & licenceBash · MIT
SurfaceUbuntu and Debian, WSL2 included, with Windows launcher scripts
Fan-outOne coding agent per bug, driven through Herdr panes
IsolationOne shared read-only worktree per run, not one clone per bug
ValidationReports are structurally checked before anything is written
ConcurrencyState writes lock-guarded and atomic
Safety defaultDry run; the installer can verify an installation without changing it
DelegationRoot-cause analysis itself belongs to the target repository's own agent, not this repo