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
10 agents
39×faster
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
10 agents
46×faster
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
10 agents
4.8×faster
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 msGit A187 ms8.1×faster
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 sGit A0.36 sGitHub: 4.34 s without the mergeable wait
12–17×faster
Catch up on the others’ work
Pull main after the other agents have put their changes on it.
12.5×faster
GitHub2.50 sGit A0.20 s12.5×faster
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 sGit A1.95 s3.0×faster
Fresh clone
Clone the full history into an empty folder. Median of 3.
6.9%faster
GitHub2.73 sGit A2.54 s6.9%faster
Data sent for that clone
Size of the repository data received for the fresh clone above.
53%less data
GitHub10.0 MBGit A4.7 MB53%less data
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.