DEV Community

Git A for Git A

Posted on Fully Autonomous

"Why not just use a merge queue?" We timed 10 AI agents through GitHub's merge queue and Git A

Disclosure: I work on Git A, a home for code where many AI agents work on one main branch. All numbers below were measured on 22–23 Nov 2026; the setup and the limits are at the end.

Every time we post that 10 coding agents pushing to one main branch cause 45 rejected pushes, someone answers: "That's what a merge queue is for."

It's a fair answer. So we measured it.

The three setups

Ten agents each change their own file and all try to get that change onto main at the same moment. Same laptop, same network, same Express.js repository, back to back.

  1. GitHub, plain push. Each agent pushes; when main has moved, the push is rejected and the agent pulls, rebases and tries again.
  2. GitHub with a merge queue. Each agent pushes a branch, opens a pull request and puts it in the queue. main requires one check: a job that does nothing but print a line, so we measure the queue, not a test suite.
  3. Git A. Each agent proposes its change. The repository is set to Auto when checks pass, with the same do-nothing check as a required check, so each change lands by itself once that check passes on it together with the latest main.

Results (10 agents, medians)

Time until all 10 changes are on main Rejected pushes Check runs Time each agent spends getting its change in
GitHub, plain push (5 runs) 30.0 s 45 none the whole retry loop
GitHub merge queue (8 runs) 71.0 s 0 20 12.2 s
Git A, Auto (8 runs) 55.5 s 0 19 0.66 s

What the merge queue gets right

It does what it promises: zero rejected pushes, and every change is checked together with the changes ahead of it. If you're on GitHub with many agents, a merge queue is a real improvement over the push-rebase-push loop.

But look at the first column: it was slower than plain pushing. Every change now waits for a check machine on its pull request and again in the queue. The rejected pushes are gone; the waiting moved somewhere else.

Where Git A is different

  • All 10 changes reached main 1.28× sooner (55.5 s vs 71.0 s), with the same kind of check and about the same number of check runs (19 vs 20). Most of both totals is waiting for a fresh check machine, so we'd rather show you that honestly than round it away.
  • Each agent was free 18× sooner. On GitHub an agent spent about 12 seconds pushing a branch, opening a pull request and entering the queue. On Git A it handed over its change in 0.66 seconds and could start its next task. Across a day of many agents and many small changes, that's the number that adds up.
  • Private repositories. On GitHub, a merge queue on a private repository needs GitHub Enterprise Cloud ($21 per user per month as of November 2026). Our test used a public repository for that reason.

Try it on your own repository

Create an empty repository on git--a.com, bring your history over (every commit keeps its ID) and require a check:

ga import https://github.com/you/api              # makes the folder ./api with your full history
cd api
ga remote add origin https://git--a.com/you/api
ga push -u origin main
ga propose policy --require "CI / test" --auto    # changes land by themselves once the check passes
Enter fullscreen mode Exit fullscreen mode

Then point your agents at it. From a terminal:

ga ws open --intent "Fix the login timeout"
ga ws write src/login.js --from login.js
ga ws land -m "Fix the login timeout"             # proposes the change; it lands once the check passes
ga propose status                                 # follow it
Enter fullscreen mode Exit fullscreen mode

Or connect Claude Code, Cursor or ChatGPT over MCP and they do the same with the Git A tools. git--a.com walks you through it, and you can measure the rejected pushes on your own repo first.

How we measured, and the limits

  • 22–23 Nov 2026, one laptop on a home connection in Kolkata; GitHub.com and Git A's Mumbai region. Express.js (MIT), full history.
  • GitHub merge queue: public organization repository, merge method "merge", up to 10 changes built and merged per group, no waiting for a minimum group, required check = one GitHub Actions job that only prints a line, run on pull requests and in the queue.
  • Git A: Auto when checks pass, required check = one Git A Actions job that only prints a line, on a fresh Git A machine.
  • The clock starts when all 10 agents start and stops when all 10 changes are on main. 8 runs per side: 5 in a block, then 3 pairs alternating which side went first. The pairs alone: GitHub 70.8–72.3 s, Git A 53.7–56.1 s. One GitHub run took 144.6 s; the median keeps one slow run from deciding the result.
  • Not tested: real test suites (they'd add the same time to both sides), bigger groups, private repositories, other locations.

What does your agent fleet do today: plain pushes, a merge queue, or something else? And how long does a change wait before it's on main?

Top comments (0)