Throughline

A GitLab Duo agent that takes a failing merge request and drives it all the way to a healthy production deploy — on its own, no human in the loop.

Comment

Inspiration

On 1 August 2012, Knight Capital pushed a release to seven of its eight servers. The eighth was running dormant code that woke up and fired more than four million orders in about 45 minutes. The loss came to roughly $440 million — more than the company was worth. The SEC later fined Knight $12 million and found it had no real controls around how it shipped software; the firm didn't survive it.

What stuck with us is that the mistake wasn't in the code. It was in everything that happens after the code is "done" — the deploy, the checks, the rollback that never came. That stretch is still mostly manual, it still lands on whoever's on call, and it still breaks at the worst possible time. We wanted to find out whether an agent could own that whole stretch — merge to production — without a human babysitting it.

What it does

Throughline watches a repository's merge requests. The moment one opens, a custom GitLab Duo flow picks it up — no mention, no button. It reads the pipeline, and if it's red, it goes to work:

  • it works out what's actually broken — build, tests, security, dependencies;
  • it fixes one thing at a time, committing each change with a plain-language comment explaining what it changed and why;
  • it re-runs the pipeline after every round, and if something's still red, it goes again;
  • it keeps going until everything passes, then ships the change to production on Google Cloud Run.

The demo runs on a real app — Throughline, a live trading terminal with an order-matching engine and a React UI (order book, market depth, a streaming price chart, positions and P&L). We open a merge request with four planted problems: a broken build, two failing tests, a hardcoded secret, and a dependency with a critical CVE. The agent clears all four across five rounds and deploys, with the full trail left on the merge request.

How we built it

  • The app — a FastAPI matching engine (multi-symbol, limit and market orders, positions, P&L, 5-second candles) with a background market simulation and a WebSocket feed, and a React + Vite terminal built on lightweight-charts. It runs as one container on Cloud Run.
  • The agent and flow — a custom flow on the GitLab Duo Agent Platform: a shipper that runs the loop, a fixer, and a verifier, handing work between them each round. It has its own service account and trigger conditions, and it fires on merge-request open. It runs on Anthropic's Claude, served through Google's Vertex AI.
  • The pipeline — GitLab CI with test, security-scan (secret + dependency audit), build (Kaniko), smoke-test, and a Cloud Run deploy stage. Green on main, red on the seeded feature branch so the agent has real work to catch.
  • Publishing — the flow and agent are published to the GitLab AI Catalog through the catalog-sync CI component on a tag.

Challenges we ran into

  • Getting a flow to actually run. Publishing a custom flow to the catalog is one thing; getting it to trigger and act is another. The catalog rejects certain fields, enabling a flow needs Group-Maintainer rights (the project owner enables it in the UI), and the flow token has to be sent as a Bearer token — a private token returns 401.
  • Keeping main honestly green while the demo is red. We moved the planted defects onto a feature branch so the baseline deploy stays credible and the red→green arc is the real story.
  • Making the agent act, not ask. Early versions kept asking for the MR URL instead of just reading it. We had to be explicit in the prompts and have it verify through the pipeline rather than trying to build locally in a sandbox.

Accomplishments that we're proud of

  • An agent that goes from a red merge request to a running Cloud Run deploy with no human in the loop — and leaves a readable audit trail while it does it.
  • A genuinely usable app underneath it (not a toy endpoint), which gives the security and test stages something real to scan.
  • Nine DevSecOps stages covered end to end, driven by a single flow.

What we learned

  • The GitLab Duo Agent Platform can carry far more than a review comment — a well-scoped flow can own a whole multi-round remediation loop.
  • Autonomy is a behaviour, not a trigger: one kickoff, then it runs to done.
  • The demo is only convincing when the baseline is honestly healthy and the failures are real.

What's next for Throughline

  • Progressive and canary deploys with automatic rollback on the four DORA signals — the control Knight Capital never had.
  • More failure classes: flaky tests, performance regressions, infrastructure drift.
  • Policy gates, so a team can set what the agent may ship on its own versus what still needs a human nod.

Built With

Share this project:

Updates

Submission history