<?xml version="1.0" encoding="UTF-8"?>
<rss version="2.0" xmlns:atom="http://www.w3.org/2005/Atom" xmlns:dc="http://purl.org/dc/elements/1.1/">
  <channel>
    <title>DEV Community: Git A</title>
    <description>The latest articles on DEV Community by Git A (git_a).</description>
    <link>https://dev.to/git_a</link>
    <image>
      <url>https://media2.dev.to/dynamic/image/width=90,height=90,fit=cover,gravity=auto,format=auto/https:%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Forganization%2Fprofile_image%2F16247%2F4c1fd38c-4d6b-450d-9fd0-f13aaebfa651.png</url>
      <title>DEV Community: Git A</title>
      <link>https://dev.to/git_a</link>
    </image>
    <atom:link rel="self" type="application/rss+xml" href="https://dev.to/feed/git_a"/>
    <language>en</language>
    <item>
      <title>Ten AI agents, one main branch: why the pushes get rejected, and what to do about it</title>
      <dc:creator>Git A</dc:creator>
      <pubDate>Wed, 18 Nov 2026 19:13:48 +0000</pubDate>
      <link>https://dev.to/git_a/ten-ai-agents-one-main-branch-why-the-pushes-get-rejected-and-what-to-do-about-it-3h9i</link>
      <guid>https://dev.to/git_a/ten-ai-agents-one-main-branch-why-the-pushes-get-rejected-and-what-to-do-about-it-3h9i</guid>
      <description>&lt;p&gt;&lt;em&gt;Disclosure: this post is from Git A, a paid code host for teams of AI agents. Most of this post is about plain Git and GitHub, and everything in the first four sections works without our product.&lt;/em&gt;&lt;/p&gt;

&lt;p&gt;If you run more than one AI coding agent on the same repository, say a few Claude Code or Codex sessions each fixing a different issue, you will hit this sooner or later: they finish at about the same time, they all push to &lt;code&gt;main&lt;/code&gt;, and most of them get this back:&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight plaintext"&gt;&lt;code&gt; ! [rejected]        main -&amp;gt; main (fetch first)
error: failed to push some refs to '…'
hint: Updates were rejected because the remote contains work that you do
hint: not have locally.
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;p&gt;This post explains why it happens, how bad it gets as you add agents, how to measure it on your own repo, and the setups that keep it under control.&lt;/p&gt;

&lt;h3&gt;
  
  
  1. Why the pushes get rejected
&lt;/h3&gt;

&lt;p&gt;A push to a branch is accepted only if it is a &lt;em&gt;fast-forward&lt;/em&gt;: the commit you send must build on the commit the branch points to right now. When ten agents start from the same &lt;code&gt;main&lt;/code&gt; and each makes one commit, all ten commits build on the same old &lt;code&gt;main&lt;/code&gt;. The first push to arrive is accepted and moves &lt;code&gt;main&lt;/code&gt;. The other nine are now built on a commit that is no longer the tip, so all nine are rejected.&lt;/p&gt;

&lt;p&gt;Each rejected agent does the right thing: it pulls (or rebases) and pushes again. But the other eight are doing the same at the same moment, so one wins and eight are rejected again. Round after round:&lt;/p&gt;

&lt;div class="table-wrapper-paragraph"&gt;&lt;table&gt;
&lt;thead&gt;
&lt;tr&gt;
&lt;th&gt;Agents&lt;/th&gt;
&lt;th&gt;Rejected pushes, if everyone retries every round&lt;/th&gt;
&lt;/tr&gt;
&lt;/thead&gt;
&lt;tbody&gt;
&lt;tr&gt;
&lt;td&gt;2&lt;/td&gt;
&lt;td&gt;1&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;5&lt;/td&gt;
&lt;td&gt;4 + 3 + 2 + 1 = 10&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;10&lt;/td&gt;
&lt;td&gt;9 + 8 + … + 1 = 45&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;20&lt;/td&gt;
&lt;td&gt;190&lt;/td&gt;
&lt;/tr&gt;
&lt;/tbody&gt;
&lt;/table&gt;&lt;/div&gt;

&lt;p&gt;That is N × (N − 1) / 2: the retries grow with the square of the number of agents, and every round costs each agent a fetch, a rebase and another push. For an AI agent that is also tokens: it reads the error, decides what to do, runs the commands, and sometimes "fixes" a rebase it didn't need to touch.&lt;/p&gt;

&lt;p&gt;This is not a GitHub problem as such; any Git server enforces fast-forward pushes. It is what happens when many writers race for one branch tip.&lt;/p&gt;

&lt;h3&gt;
  
  
  2. Measure it on your own repository
&lt;/h3&gt;

&lt;p&gt;Numbers from someone else's repo only go so far. This script reproduces the race on your own repo, with your own network. It:&lt;/p&gt;

&lt;ol&gt;
&lt;li&gt;clones your repo once and creates a throwaway branch (it never touches &lt;code&gt;main&lt;/code&gt;),&lt;/li&gt;
&lt;li&gt;makes N more clones, and in each one commits one new file,&lt;/li&gt;
&lt;li&gt;pushes all N at the same moment, each retrying with &lt;code&gt;pull --rebase&lt;/code&gt; until it is in,&lt;/li&gt;
&lt;li&gt;prints the rejected pushes, how many changes landed and the wall time, then deletes the branch.&lt;/li&gt;
&lt;/ol&gt;

&lt;p&gt;It needs bash 5 or newer and git, and only talks to the repo URL you give it. Use a small test repository: it makes N full clones.&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight shell"&gt;&lt;code&gt;&lt;span class="c"&gt;#!/usr/bin/env bash&lt;/span&gt;
&lt;span class="c"&gt;# measure-rejected-pushes.sh: N agents push at the same moment, count rejected pushes.&lt;/span&gt;
&lt;span class="c"&gt;# Usage: bash measure-rejected-pushes.sh &amp;lt;repo-url&amp;gt; [agents]&lt;/span&gt;
&lt;span class="c"&gt;# Needs bash 5+ and git. Uses a throwaway branch, never main, and deletes it at the end.&lt;/span&gt;
&lt;span class="nb"&gt;set&lt;/span&gt; -euo pipefail
&lt;span class="nv"&gt;URL&lt;/span&gt;&lt;span class="o"&gt;=&lt;/span&gt;&lt;span class="s2"&gt;"$1"&lt;/span&gt;&lt;span class="o"&gt;;&lt;/span&gt; &lt;span class="nv"&gt;N&lt;/span&gt;&lt;span class="o"&gt;=&lt;/span&gt;&lt;span class="s2"&gt;"${2:-5}"&lt;/span&gt;
&lt;span class="nv"&gt;WORK&lt;/span&gt;&lt;span class="o"&gt;=&lt;/span&gt;&lt;span class="s2"&gt;"$(mktemp -d)"&lt;/span&gt;&lt;span class="o"&gt;;&lt;/span&gt; &lt;span class="nv"&gt;BR&lt;/span&gt;&lt;span class="o"&gt;=&lt;/span&gt;&lt;span class="s2"&gt;"race-$$-$RANDOM"&lt;/span&gt;
git clone -q &lt;span class="s2"&gt;"$URL"&lt;/span&gt; &lt;span class="s2"&gt;"$WORK/base"&lt;/span&gt;
git -C &lt;span class="s2"&gt;"$WORK/base"&lt;/span&gt; switch -q -c &lt;span class="s2"&gt;"$BR"&lt;/span&gt;
git -C &lt;span class="s2"&gt;"$WORK/base"&lt;/span&gt; push -q -u origin &lt;span class="s2"&gt;"$BR"&lt;/span&gt;
&lt;span class="k"&gt;for&lt;/span&gt; i &lt;span class="k"&gt;in&lt;/span&gt; &lt;span class="nv"&gt;$(&lt;/span&gt;seq 1 &lt;span class="s2"&gt;"$N"&lt;/span&gt;&lt;span class="o"&gt;)&lt;/span&gt;&lt;span class="o"&gt;;&lt;/span&gt; &lt;span class="k"&gt;do&lt;/span&gt;
  git clone -q --branch &lt;span class="s2"&gt;"$BR"&lt;/span&gt; &lt;span class="s2"&gt;"$URL"&lt;/span&gt; &lt;span class="s2"&gt;"$WORK/a$i"&lt;/span&gt;
  &lt;span class="nb"&gt;echo&lt;/span&gt; &lt;span class="s2"&gt;"agent $i"&lt;/span&gt; &lt;span class="o"&gt;&amp;gt;&lt;/span&gt; &lt;span class="s2"&gt;"$WORK/a$i/agent-$i.txt"&lt;/span&gt;
  git -C &lt;span class="s2"&gt;"$WORK/a$i"&lt;/span&gt; add &lt;span class="s2"&gt;"agent-$i.txt"&lt;/span&gt;
  git -C &lt;span class="s2"&gt;"$WORK/a$i"&lt;/span&gt; commit -q -m &lt;span class="s2"&gt;"agent $i: add agent-$i.txt"&lt;/span&gt;
&lt;span class="k"&gt;done&lt;/span&gt;
agent&lt;span class="o"&gt;(&lt;/span&gt;&lt;span class="o"&gt;)&lt;/span&gt; &lt;span class="o"&gt;{&lt;/span&gt;   &lt;span class="c"&gt;# push; on rejection, catch up and try again&lt;/span&gt;
  &lt;span class="kd"&gt;local&lt;/span&gt; &lt;span class="nv"&gt;i&lt;/span&gt;&lt;span class="o"&gt;=&lt;/span&gt;&lt;span class="s2"&gt;"$1"&lt;/span&gt; &lt;span class="nv"&gt;rejected&lt;/span&gt;&lt;span class="o"&gt;=&lt;/span&gt;0
  &lt;span class="k"&gt;until&lt;/span&gt; git -C &lt;span class="s2"&gt;"$WORK/a$i"&lt;/span&gt; push -q origin &lt;span class="s2"&gt;"HEAD:$BR"&lt;/span&gt; 2&lt;span class="o"&gt;&amp;gt;&lt;/span&gt;/dev/null&lt;span class="o"&gt;;&lt;/span&gt; &lt;span class="k"&gt;do&lt;/span&gt;
    &lt;span class="nv"&gt;rejected&lt;/span&gt;&lt;span class="o"&gt;=&lt;/span&gt;&lt;span class="nv"&gt;$(&lt;/span&gt;&lt;span class="o"&gt;(&lt;/span&gt;rejected + 1&lt;span class="o"&gt;)&lt;/span&gt;&lt;span class="o"&gt;)&lt;/span&gt;
    git -C &lt;span class="s2"&gt;"$WORK/a$i"&lt;/span&gt; pull -q --rebase origin &lt;span class="s2"&gt;"$BR"&lt;/span&gt;
  &lt;span class="k"&gt;done&lt;/span&gt;
  &lt;span class="nb"&gt;echo&lt;/span&gt; &lt;span class="s2"&gt;"$rejected"&lt;/span&gt; &lt;span class="o"&gt;&amp;gt;&lt;/span&gt; &lt;span class="s2"&gt;"$WORK/rejected-$i"&lt;/span&gt;
&lt;span class="o"&gt;}&lt;/span&gt;
&lt;span class="nv"&gt;start&lt;/span&gt;&lt;span class="o"&gt;=&lt;/span&gt;&lt;span class="nv"&gt;$EPOCHREALTIME&lt;/span&gt;
&lt;span class="k"&gt;for&lt;/span&gt; i &lt;span class="k"&gt;in&lt;/span&gt; &lt;span class="nv"&gt;$(&lt;/span&gt;seq 1 &lt;span class="s2"&gt;"$N"&lt;/span&gt;&lt;span class="o"&gt;)&lt;/span&gt;&lt;span class="o"&gt;;&lt;/span&gt; &lt;span class="k"&gt;do&lt;/span&gt; agent &lt;span class="s2"&gt;"$i"&lt;/span&gt; &lt;span class="o"&gt;&amp;amp;&lt;/span&gt; &lt;span class="k"&gt;done&lt;/span&gt;
&lt;span class="nb"&gt;wait&lt;/span&gt;
&lt;span class="nv"&gt;end&lt;/span&gt;&lt;span class="o"&gt;=&lt;/span&gt;&lt;span class="nv"&gt;$EPOCHREALTIME&lt;/span&gt;
&lt;span class="nv"&gt;total&lt;/span&gt;&lt;span class="o"&gt;=&lt;/span&gt;&lt;span class="nv"&gt;$(&lt;/span&gt;cat &lt;span class="s2"&gt;"$WORK"&lt;/span&gt;/rejected-* &lt;span class="o"&gt;|&lt;/span&gt; awk &lt;span class="s1"&gt;'{s += $1} END {print s}'&lt;/span&gt;&lt;span class="o"&gt;)&lt;/span&gt;
git -C &lt;span class="s2"&gt;"$WORK/base"&lt;/span&gt; fetch -q origin &lt;span class="s2"&gt;"$BR"&lt;/span&gt;
&lt;span class="nv"&gt;landed&lt;/span&gt;&lt;span class="o"&gt;=&lt;/span&gt;&lt;span class="nv"&gt;$(&lt;/span&gt;git -C &lt;span class="s2"&gt;"$WORK/base"&lt;/span&gt; log --oneline FETCH_HEAD &lt;span class="o"&gt;|&lt;/span&gt; grep -c &lt;span class="s2"&gt;"agent [0-9]*: add"&lt;/span&gt; &lt;span class="o"&gt;||&lt;/span&gt; &lt;span class="kc"&gt;true&lt;/span&gt;&lt;span class="o"&gt;)&lt;/span&gt;
awk -v &lt;span class="nv"&gt;n&lt;/span&gt;&lt;span class="o"&gt;=&lt;/span&gt;&lt;span class="s2"&gt;"$N"&lt;/span&gt; -v &lt;span class="nv"&gt;r&lt;/span&gt;&lt;span class="o"&gt;=&lt;/span&gt;&lt;span class="s2"&gt;"$total"&lt;/span&gt; -v &lt;span class="nv"&gt;l&lt;/span&gt;&lt;span class="o"&gt;=&lt;/span&gt;&lt;span class="s2"&gt;"$landed"&lt;/span&gt; -v &lt;span class="nv"&gt;a&lt;/span&gt;&lt;span class="o"&gt;=&lt;/span&gt;&lt;span class="s2"&gt;"$start"&lt;/span&gt; -v &lt;span class="nv"&gt;b&lt;/span&gt;&lt;span class="o"&gt;=&lt;/span&gt;&lt;span class="s2"&gt;"$end"&lt;/span&gt; \
  &lt;span class="s1"&gt;'BEGIN {printf "agents=%d rejected_pushes=%d changes_on_branch=%d seconds=%.2f\n", n, r, l, b - a}'&lt;/span&gt;
git -C &lt;span class="s2"&gt;"$WORK/base"&lt;/span&gt; push -q origin --delete &lt;span class="s2"&gt;"$BR"&lt;/span&gt;
rm -rf &lt;span class="s2"&gt;"$WORK"&lt;/span&gt;
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;p&gt;Run it with 5 and then 10:&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight shell"&gt;&lt;code&gt;bash measure-rejected-pushes.sh git@github.com:you/test-repo.git 5
bash measure-rejected-pushes.sh git@github.com:you/test-repo.git 10
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;p&gt;Each agent changes a &lt;em&gt;different&lt;/em&gt; file, so there is never a real conflict: every rejection is pure waiting. Even against a bare repository on the same laptop, our runs came out at exactly 10 and 45. Over the internet, each round also costs a network round trip or three, and that's where the seconds go.&lt;/p&gt;

&lt;h3&gt;
  
  
  3. What we measured
&lt;/h3&gt;

&lt;p&gt;We ran this kind of test against GitHub.com on 2 November 2026, with scripted agents and no human in the loop, median of 5 runs:&lt;/p&gt;

&lt;div class="table-wrapper-paragraph"&gt;&lt;table&gt;
&lt;thead&gt;
&lt;tr&gt;
&lt;th&gt;Situation&lt;/th&gt;
&lt;th&gt;Agents&lt;/th&gt;
&lt;th&gt;GitHub.com&lt;/th&gt;
&lt;/tr&gt;
&lt;/thead&gt;
&lt;tbody&gt;
&lt;tr&gt;
&lt;td&gt;Each agent changes a different file&lt;/td&gt;
&lt;td&gt;5&lt;/td&gt;
&lt;td&gt;13.25 s, 10 rejected pushes&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Each agent changes a different file&lt;/td&gt;
&lt;td&gt;10&lt;/td&gt;
&lt;td&gt;27.17 s, 45 rejected pushes&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Same file, each in its own place&lt;/td&gt;
&lt;td&gt;10&lt;/td&gt;
&lt;td&gt;26.43 s, 45 rejected pushes&lt;/td&gt;
&lt;/tr&gt;
&lt;/tbody&gt;
&lt;/table&gt;&lt;/div&gt;

&lt;p&gt;Conditions: the Express.js repository (6,183 commits), one laptop on a home connection in Kolkata, a private repository on GitHub.com, CI not included, one repository, one location. Your numbers will differ with your repo and your distance to the server.&lt;/p&gt;

&lt;p&gt;Twenty-seven seconds doesn't sound like much. But it happens every time a batch of agents finishes, the rejected agents each run several rebases, and it doesn't include CI. Run 10 agents through a working day and it adds up.&lt;/p&gt;

&lt;h3&gt;
  
  
  4. Setups that help on plain Git and GitHub
&lt;/h3&gt;

&lt;p&gt;These are what we used before we built our own host, roughly from cheapest to most robust.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;One working folder per agent.&lt;/strong&gt; Never let two agents share a checkout: they will fight over the index, the stash and each other's half-written files. &lt;code&gt;git worktree&lt;/code&gt; gives each agent its own folder and branch, sharing one object store:&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight shell"&gt;&lt;code&gt;git fetch origin
git worktree add ../agent-1 -b agent/1/fix-login origin/main
git worktree add ../agent-2 -b agent/2/add-export origin/main
&lt;span class="c"&gt;# start each agent in its own folder; when done:&lt;/span&gt;
git worktree remove ../agent-1
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;p&gt;&lt;strong&gt;Tell each agent how to finish.&lt;/strong&gt; Put it in &lt;code&gt;AGENTS.md&lt;/code&gt; or &lt;code&gt;CLAUDE.md&lt;/code&gt;, so they don't improvise with force pushes:&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight markdown"&gt;&lt;code&gt;&lt;span class="gu"&gt;## Finishing a task
&lt;/span&gt;&lt;span class="k"&gt;- &lt;/span&gt;Work only in your own worktree and branch.
&lt;span class="k"&gt;- &lt;/span&gt;Run the tests before you finish.
&lt;span class="k"&gt;- &lt;/span&gt;Push your branch and open a pull request. Never push to main. Never force-push.
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;p&gt;&lt;strong&gt;A branch and a pull request per agent.&lt;/strong&gt; Nothing is rejected, because nobody pushes to the same branch. The cost moves to review and merge: every change is a pull request, a CI run and a merge wait, and when many PRs merge in a row, later ones can fall out of date and need another CI run.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;A merge queue&lt;/strong&gt; on top of that keeps &lt;code&gt;main&lt;/code&gt; green when many PRs are ready at once. It adds waiting time per change and CI minutes per queue entry; for a handful of agents that is usually fine.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;A retry loop&lt;/strong&gt;, if your agents do push straight to &lt;code&gt;main&lt;/code&gt; (small repos, trusted agents):&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight shell"&gt;&lt;code&gt;&lt;span class="k"&gt;until&lt;/span&gt; git push origin HEAD:main&lt;span class="o"&gt;;&lt;/span&gt; &lt;span class="k"&gt;do&lt;/span&gt;
  git pull --rebase origin main &lt;span class="o"&gt;||&lt;/span&gt; &lt;span class="o"&gt;{&lt;/span&gt; &lt;span class="nb"&gt;echo&lt;/span&gt; &lt;span class="s2"&gt;"real conflict: stop and ask"&lt;/span&gt;&lt;span class="o"&gt;;&lt;/span&gt; &lt;span class="nb"&gt;exit&lt;/span&gt; 1&lt;span class="o"&gt;;&lt;/span&gt; &lt;span class="o"&gt;}&lt;/span&gt;
&lt;span class="k"&gt;done&lt;/span&gt;
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;p&gt;It is correct and simple; it is just quadratic, as section 1 shows. Add a small random sleep before each retry so the agents stop colliding in lockstep.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;Don't split work by file&lt;/strong&gt; to avoid conflicts. It sounds tidy, but it forces you to plan around Git instead of around the task, and two agents still need the same &lt;code&gt;package.json&lt;/code&gt; sooner or later.&lt;/p&gt;

&lt;h3&gt;
  
  
  5. What we built instead (our product, disclosed)
&lt;/h3&gt;

&lt;p&gt;We built Git A because we wanted many agents on one &lt;code&gt;main&lt;/code&gt; without the retry rounds. On the same test, same day and same conditions (Git A hosted in Mumbai, near-equal network distance: 67 ms to github.com, 59 ms to git--a.com):&lt;/p&gt;

&lt;div class="table-wrapper-paragraph"&gt;&lt;table&gt;
&lt;thead&gt;
&lt;tr&gt;
&lt;th&gt;Situation&lt;/th&gt;
&lt;th&gt;Agents&lt;/th&gt;
&lt;th&gt;GitHub.com&lt;/th&gt;
&lt;th&gt;Git A&lt;/th&gt;
&lt;/tr&gt;
&lt;/thead&gt;
&lt;tbody&gt;
&lt;tr&gt;
&lt;td&gt;Different files&lt;/td&gt;
&lt;td&gt;10&lt;/td&gt;
&lt;td&gt;27.17 s, 45 rejected pushes&lt;/td&gt;
&lt;td&gt;0.69 s, no retries&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Same file, different places&lt;/td&gt;
&lt;td&gt;10&lt;/td&gt;
&lt;td&gt;26.43 s, 45 rejected pushes&lt;/td&gt;
&lt;td&gt;0.57 s, no retries&lt;/td&gt;
&lt;/tr&gt;
&lt;/tbody&gt;
&lt;/table&gt;&lt;/div&gt;

&lt;p&gt;When two agents add different things at the same spot, or change neighbouring lines, both changes usually land. When they change the very same lines, one of them hears back at once which lines clashed, redoes its part, and loses nothing.&lt;/p&gt;

&lt;p&gt;How to try it with your own agents:&lt;/p&gt;

&lt;ol&gt;
&lt;li&gt;Create an organization at git--a.com, pick its region and add prepaid credit (plans from $10 a month, the smallest top-up is $25; there is no free tier, and agents are free, never seats). Outside India you pay online with PayPal, in USD.&lt;/li&gt;
&lt;li&gt;Bring a repository over: &lt;code&gt;ga import https://github.com/you/repo&lt;/code&gt;, then &lt;code&gt;ga push&lt;/code&gt; it to your new Git A repository. Every commit ID stays the same, and &lt;code&gt;ga export&lt;/code&gt; sends it back. &lt;code&gt;ga&lt;/code&gt; comes from &lt;strong&gt;Downloads&lt;/strong&gt; in your organization and runs on 64-bit Linux. Plain git works too (&lt;code&gt;git remote add gita https://git--a.com/you/repo.git&lt;/code&gt;, then &lt;code&gt;git push gita main&lt;/code&gt;), but the numbers above were measured with &lt;code&gt;ga&lt;/code&gt;.&lt;/li&gt;
&lt;li&gt;Connect each agent over MCP. For Claude Code, one line per repository, with the agent's own key in &lt;code&gt;GITA_TOKEN&lt;/code&gt;:
&lt;/li&gt;
&lt;/ol&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight shell"&gt;&lt;code&gt;   claude mcp add --transport http gita https://git--a.com/api/v1/repos/acme/api/mcp \
     --header &lt;span class="s2"&gt;"Authorization: Bearer $GITA_TOKEN"&lt;/span&gt;
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;p&gt;In Claude, ChatGPT, Cursor or VS Code you can add &lt;code&gt;https://git--a.com/mcp&lt;/code&gt; as a connector and sign in instead; no key to copy.&lt;/p&gt;

&lt;ol&gt;
&lt;li&gt;In the repository's settings choose &lt;strong&gt;Ask me&lt;/strong&gt; (you approve every agent change) or &lt;strong&gt;Auto when checks pass&lt;/strong&gt;.&lt;/li&gt;
&lt;li&gt;Start your agents. Each one works in its own lane and finishes with a proposal; you follow each change in the live panel or with &lt;code&gt;ga propose status&lt;/code&gt;.&lt;/li&gt;
&lt;/ol&gt;

&lt;p&gt;Limits, honestly: one region today (Mumbai, on AWS), so if you are far from India expect more latency than we had; the &lt;code&gt;ga&lt;/code&gt; command line is 64-bit Linux only for now (agents elsewhere connect over the web or plain git); one repository and one location in our measurement. Credits are prepaid and final. If you don't run agents in parallel, plain GitHub is the simpler choice.&lt;/p&gt;

&lt;p&gt;Full conditions of every number: git--a.com/vs-github. The script, with its checksum: git--a.com/measure&lt;/p&gt;

&lt;h3&gt;
  
  
  Takeaways
&lt;/h3&gt;

&lt;ul&gt;
&lt;li&gt;With N agents racing for one branch, rejected pushes grow like N × (N − 1) / 2.&lt;/li&gt;
&lt;li&gt;Measure it on your own repo before you redesign anything; the script above takes a minute.&lt;/li&gt;
&lt;li&gt;On plain Git: one worktree per agent, clear finishing rules in &lt;code&gt;AGENTS.md&lt;/code&gt;, and PRs or a jittered retry loop depending on how much you trust the agents.&lt;/li&gt;
&lt;li&gt;If you run many agents every day, a host built for that removes the retry rounds altogether.&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;What does the script print for your repo? We'd like to know how the numbers change with distance to the server.&lt;/p&gt;

&lt;p&gt;&lt;em&gt;This article was written by an AI assistant working for Git A. The script was run before publishing (it printed 10 and 45 on a local test repository), and every number is from our published measurement at git--a.com/vs-github.&lt;/em&gt;&lt;/p&gt;

</description>
      <category>ai</category>
      <category>git</category>
      <category>devops</category>
      <category>productivity</category>
    </item>
  </channel>
</rss>
