Skip to content

Head-to-head · measured 1–2 Nov 2026

In our test, 5 to 10 agents got their changes onto main 4.2–46× faster on Git A than on GitHub.

We ran the same agent workload on GitHub.com and on Git A, back to back from one laptop at near-equal network distance (67 ms vs 59 ms). Every test shows both numbers; fresh clone and initial upload gained less, and CI is not included.

1–2 Nov 2026 · Express.js, 6,183 commits · laptop in Kolkata → GitHub.com vs Git A (Mumbai) · near-equal distance: 67 ms GitHub, 59 ms Git A · many-agent tests: median of 5 runs · CI not included · one repository, one location · full conditions

Many agents, one main branch

10 agents put a change on main at the same moment.

On GitHub, every agent runs the usual loop: commit, push, and when the push is rejected because main moved, pull, rebase and push again. On Git A, each agent writes its change and puts it on main in one step. In the median of 5 runs, when agents change different files or different places in one file, no agent is turned away.

Median of 5 runs for each size and situation, measured 2 Nov 2026. Every run checked: each agent’s change is on main exactly once on both servers.

GitHub

27.17 s

45 rejected pushes

Git A

0.69 s

0 retries

Different files: time until every agent’s change is on main

Same scale for every many-agent bar on this page. Lower is better.

5 agents

9×faster

GitHub13.25 s10 rejected pushes
Git A1.44 s0 retries

10 agents

39×faster

GitHub27.17 s45 rejected pushes
Git A0.69 s0 retries

From 5 to 10 agents, GitHub’s time doubled (13.25 s → 27.17 s) as rejected pushes grew from 10 to 45. Git A’s did not grow (1.44 s → 0.69 s), with no retries.

Same file, different places

Every agent changes the same file, each in its own place.

5 agents

28×faster

GitHub12.71 s10 rejected pushes
Git A0.45 s0 retries

10 agents

46×faster

GitHub26.43 s45 rejected pushes
Git A0.57 s0 retries

Same file, same place (measured before Git A kept both changes)

Every agent added a line at the very same place. When this was measured, Git A had each later agent re-apply its line; today both changes usually land, and nobody redoes anything.

5 agents

4.2×faster

GitHub13.00 s10 conflicts fixed
Git A3.08 s8–10 clashes re-applied

10 agents

4.8×faster

GitHub27.54 s45 conflicts fixed
Git A5.64 s36–42 clashes re-applied

When agents change the very same line, both services still make the later agent redo its change. Git A shows the agent exactly what clashed, and every agent’s change still ends up on main.

One agent, step by step

Bars are scaled within each test. Lower is better.

  • One agent change

    Edit one file, commit, push to a branch. Median of 10 changes in a row; no push failed on either side.

    8.1×faster

    GitHub1,531 ms
    Git A187 ms
  • Pull request, opened to merged

    Open a pull request from that branch and squash-merge it. On GitHub this includes waiting until GitHub reports it mergeable.

    12–17×faster

    GitHub6.38 s
    Git A0.36 s

    GitHub: 4.34 s without the mergeable wait

  • Catch up on the others’ work

    Pull main after the other agents have put their changes on it.

    12.5×faster

    GitHub2.50 s
    Git A0.20 s
  • Initial upload

    Push the full history (6,183 commits) to a new, empty repository. One run each: a second would not be an initial upload.

    3.0×faster

    GitHub5.97 s
    Git A1.95 s
  • Fresh clone

    Clone the full history into an empty folder. Median of 3.

    6.9%faster

    GitHub2.73 s
    Git A2.54 s
  • Data sent for that clone

    Size of the repository data received for the fresh clone above.

    53%less data

    GitHub10.0 MB
    Git A4.7 MB

How we measured

Conditions for every number above.

When
1 and 2 November 2026: one-agent tests on 1 November, many-agent tests on 2 November. Both sides back to back, same machine, same network.
Repository
Express.js (MIT licence), full history: 6,183 commits. Identical commit IDs on both servers.
From
One developer laptop on a home internet connection in Kolkata, India.
Servers
GitHub.com (private repository) and Git A v0.4.0 hosted in Mumbai, both over HTTPS (a newer build of v0.4.0 for the many-agent tests on 2 November).
Network distance
Near-equal: 67 ms to github.com, 59 ms to git--a.com, so Git A was 8 ms closer (time to connect, average of 5). The many-agent tests ran on 2 November on the same setup. The clone, upload and data rows come from an earlier run on 1 November on the same build as the other one-agent rows, also at near-equal distance.
Runs
Many-agent tests: median of 5 runs for each size and situation, GitHub and Git A taking turns going first. One agent change: median of 10. Fresh clone: median of 3. Pull request, catch-up and initial upload: one run each. Multipliers are computed from the numbers shown and rounded down.
Agent tools
GitHub: git and the GitHub REST API. Git A: the ga command line. Scripted, no human in the loop.
Checked
Every run was checked on both servers: in the many-agent tests, each agent’s change is on main exactly once; each one-agent change matches the agent’s own commit, and both pull requests were merged.
Not included
CI. No GitHub Actions minutes and no runners were used on either side.
Limits
One repository, one location, two days. Your numbers will differ with your repository, your network and your distance to each server.

Measure your own repository

Run our script on a repository of yours: several agents push at the same moment and it counts the rejected pushes. It talks only to your repository, never to Git A.

Measure your agents’ rejected pushes