# GitHub as an Operating System for Non-Code Agent Teams

## Executive summary

The GitHub model transfers surprisingly well to non-code agent work, but only after one important correction: **“merge” and “execution” must be treated as separate operations**. In software, merging source code usually changes a canonical repository but does not necessarily deploy it. The same separation is essential for writing, design, labeling, decisions, business operations, and especially robotics. A merged change should mean “this is now the approved canonical intent”; applying that intent to customers, databases, money, machinery, or the physical world should be a second, independently authorized transition. Git itself already embodies the useful foundations: a staging area prepares the contents of a future commit, commits create identifiable snapshots, pull requests support discussion and approval, protected branches impose governance, and merge queues re-test changes in the context in which they will actually land.  [[1]](https://git-scm.com/docs/git-add)[[2]](https://docs.github.com/en/pull-requests/reference/pull-request-reviews)[[3]](https://docs.github.com/en/repositories/configuring-branches-and-merges-in-your-repository/configuring-pull-request-merges/managing-a-merge-queue)

The most useful generalized pipeline is therefore:

**private workspace → staged change set → immutable hand-in → review proposal → automated checks → approval → integration queue → canonical state → execution gate → observed outcome → compensating change if necessary.**

This model is strongest when work is decomposable into small, versionable artifacts and correctness can be partially expressed as executable invariants. It becomes weaker as work becomes subjective, globally coupled, or irreversible. Writing is highly versionable but semantically subjective; design has mergeable structure but visual/system-level interactions; labeling benefits from redundancy and statistical QA; organizational decisions are versionable but cannot literally be “unmade”; business transactions need compensating actions; robotics adds resource conflicts, real-time state drift, and irreversible physical consequences. Manubot demonstrates that ordinary GitHub review can govern collaborative manuscripts; Figma implements a native branch/review/merge model for designs; Labelbox separates labeling, review, approval, and rework; lakeFS provides Git-like branches and commits for data; Temporal implements durable human approval workflows; and Open-RMF maintains a changing traffic schedule and negotiates conflicts among robot fleets.  [[4]](https://journals.plos.org/ploscompbiol/article?id=10.1371/journal.pcbi.1007128)[[5]](https://help.figma.com/hc/en-us/sections/5665686755479-Branching-and-merging)[[6]](https://docs.labelbox.com/docs/what-is-a-project)[[7]](https://docs.lakefs.io/guides/version-data/)[[8]](https://docs.temporal.io/guides/reliable-document-approvals)[[9]](https://openrmf.readthedocs.io/en/latest/faq/index.html)

The principal scaling result from recent multi-agent research is that **more agents are not automatically better**. Google Research evaluated 180 agent configurations and found roughly an 81% improvement on the parallelizable Finance-Agent task but up to a 70% degradation on sequential PlanCraft; its predictive model selected the best architecture for 87% of unseen task configurations. A separate 2026 study scaling homogeneous LLM teams only to eight agents found diminishing or inverted-U returns, quadratic token growth in its interaction architecture, and a 27.45% accuracy decline from one to eight agents for Llama-3.1-70B on logical-reasoning tasks. These studies are not direct measurements of writing or robotics teams, but they provide strong evidence that task coupling, not raw team size, determines whether parallelism pays.  [[10]](https://research.google/blog/towards-a-science-of-scaling-agent-systems-when-and-why-agent-systems-work/)[[11]](https://research.google/blog/towards-a-science-of-scaling-agent-systems-when-and-why-agent-systems-work/)[12][13]

A second scaling result is that **parallel branches eventually create an integration problem even if every individual branch looks valid**. In a 2026 study of 33,596 agent-authored GitHub pull requests across 2,807 repositories, 79.4% of PRs overlapped in time with another agentic PR. Replay of concurrent changes found textual conflicts in 19.8% of same-agent pairs and 41.7% of cross-agent pairs. Because the study concerns code repositories, these percentages should not be transplanted directly to writing or business workflows, but the mechanism generalizes: independent workers operate against progressively stale views of canonical state, so integration risk rises as concurrent work overlaps.  [14][15]

Human review is likely to become the first bottleneck in **loosely coupled** domains; state contention and semantic conflicts are likely to break first in **tightly coupled** domains. Google's large-scale review study provides a useful calibrated reference point: its data covered roughly nine million reviewed changes and more than 25,000 authors/reviewers; median initial feedback was under an hour for small changes and about five hours for very large ones, overall median review latency was under four hours, the median reviewer handled four changes per week, and reviewers spent a median 2.6 hours per week reviewing. About 90% of changes touched fewer than ten files, the median change modified 24 lines, and more than 80% needed at most one comment-resolution iteration. The lesson for agent teams is not that these exact capacities will apply outside code, but that **small hand-ins, ownership-aware reviewer assignment, automated checks, and low reviewer counts are ingredients of a review system demonstrated to operate at very large scale**.  [[16]](https://research.google/pubs/modern-code-review-a-case-study-at-google/)[17][18][19][20]

The strongest authority rule is similarly simple: **the agent that proposes a change must not be able to manufacture the evidence that authorizes that change**. GitHub does not allow a PR author to approve their own PR, can invalidate approvals when later changes are pushed, and can require an approval covering the latest push. At the same time, GitHub documents that users with write permission can set repository status states, which is a warning against treating an author-writable label or status field as an independent control. For an agent operating model, tests should run under separate checker identities; approval should come from independent principals; and the capability to execute an approved change should be narrower still.  [[21]](https://docs.github.com/en/repositories/configuring-branches-and-merges-in-your-repository/managing-protected-branches/managing-a-branch-protection-rule)[22][23][24]

The other major design principle is to distinguish **syntactic convergence from semantic correctness**. CRDT-style shared workspaces can eliminate mechanical merge failures, but that does not prove that the combined result makes sense. CodeCRDT reported 100% replica convergence and zero merge failures across 600 trials, while its authors still estimated semantic conflicts at roughly 5–10%; depending on the task, parallel coordination ranged from a 21.1% speedup to a 39.4% slowdown. For non-code work, “the documents merged cleanly,” “the database accepted both writes,” or “the schedules are structurally valid” must therefore never be interpreted as equivalent to “the outcome is correct.”  [25][[26]](https://arxiv.org/abs/2510.18893)

**Unspecified assumptions.** The request does not specify the agents' models, autonomy level, regulator, safety classification, artifact sizes, expected team size, review staffing, acceptable latency, consistency requirements, or whether agents can directly affect external systems. The recommendations below therefore use a default risk-based model: low-risk reversible changes may be heavily automated; material or difficult-to-reverse changes require an independent approver; and safety-, financial-, legal-, or physically consequential execution should use separate human-controlled execution authority. Those thresholds should be replaced with domain-specific policy before deployment.

## The control model: translating Git semantics into work semantics

The most important conceptual move is to stop thinking of Git as being about files. Its deeper abstraction is a **transactional proposal protocol**: work occurs against a known baseline, a subset of changes is explicitly selected, the selection receives a durable identity, other principals inspect the delta, machines evaluate invariants, and only then is the new state admitted to a canonical history. `git add`, for example, places selected content in an index specifically used to prepare the next commit, and `git add -p` permits only selected hunks to be staged. That is exactly the behavior a non-code agent system needs from a staging layer.  [[1]](https://git-scm.com/docs/git-add)

| Git/GitHub concept | Generalized agent-team meaning | Required invariant | Typical non-code implementation |
|---|---|---|---|
| Working tree | Agent's private speculative workspace | Work here cannot mutate canonical state | Private document, design branch, sandbox DB, simulation, draft decision |
| `git add` / index | Explicitly selected candidate effects | Unstaged experimentation is excluded from hand-in | JSON Patch, selected labels, design component set, transaction proposal, planned robot actions |
| Commit | Immutable **hand-in** snapshot | Content, base version, author identity and provenance are frozen | Content-addressed artifact plus metadata |
| Branch | Isolated line of work | Concurrent workers do not silently overwrite each other | Git branch, Figma branch, data branch, shadow workflow state |
| Pull request | Request to make candidate state canonical | Diff, evidence, discussion and authority are visible together | Review object / change request |
| CI/checks | Executable acceptance evidence | Checks are reproducible and produced independently of author | Schema validation, factual tests, simulation, gold-set scoring, policy checks |
| CODEOWNERS | Semantic/domain ownership | Material changes cannot bypass responsible expertise | Owners by section, component, dataset class, account, facility, policy |
| Protected branch/ruleset | Governance policy | No direct mutation of canonical state | Policy engine / workflow gate |
| Merge queue | Serialized integration with current state | Candidate is retested against the state it will actually join | Queue + refresh/revalidation before commit |
| Merge | Make approved intent canonical | Atomic admission to authoritative history | New document baseline, dataset release, adopted decision |
| Deploy/apply | Produce external effects | **Separate from merge for consequential work** | Publish, modify CRM, transfer money, dispatch robot |
| Revert | New forward change that neutralizes an earlier one | History is not erased | Revert publication, compensating transaction, corrected labels, stop/replan |
| Tag/release | Named trusted baseline | Consumers can refer to a stable state | Publication version, signed dataset release, approved policy revision |
| Issue | Requested outcome / problem definition | Intent exists independently of implementation | Work order, brief, decision question |
| Audit log | Provenance ledger | Actor, action and time remain inspectable | Append-only event history; GitHub's audit log records who did what and when.  [[27]](https://docs.github.com/en/organizations/keeping-your-organization-secure/managing-security-settings-for-your-organization/reviewing-the-audit-log-for-your-organization) |

The analogy should **not** be “commit = do the action.” A commit should mean “I am handing in exactly this proposed state transition.” This distinction is easy to miss in non-code systems because the underlying tool may permit immediate writes. The safest architecture gives the agent a proposal interface rather than the production interface whenever practicable. lakeFS demonstrates the data version of this design: branches, commits and merges operate as metadata-level snapshots so production data changes can be reviewed before integration.  [[7]](https://docs.lakefs.io/guides/version-data/)

A useful generalized change object is:

```yaml
change_id: immutable-id
domain: writing | design | labeling | decision | robotics | business
base_version: canonical-version-read-by-author
author_principal: agent-identity
risk_class: low | material | high
scope:
  reads: [objects-and-versions-read]
  writes: [objects-or-properties-proposed]
preconditions:
  - facts-that-must-still-be-true-at-apply-time
artifacts:
  - content-addressed-candidate-output
tests_required:
  - schema
  - domain-quality
  - policy
  - regression
owners_required:
  - semantic-owner
rollback_or_compensation:
  strategy: explicit-description
execution:
  permitted_actor: separate-principal
  expires_at: timestamp
```

The important fields are `base_version`, read/write scope, preconditions, and compensation. Together they allow the system to distinguish “this change was once reasonable” from “this change is still safe to apply.”

A typical end-to-end flow should therefore look like this:

```mermaid
flowchart LR
    A[Issue / requested outcome] --> B[Agent private workspace]
    B --> C[Stage explicit change set]
    C --> D[Commit: immutable hand-in]
    D --> E[Pull request / review object]

    E --> F1[Schema & structural checks]
    E --> F2[Domain-quality tests]
    E --> F3[Policy & permission checks]
    E --> F4[Simulation / regression checks]

    F1 --> G[Independent review]
    F2 --> G
    F3 --> G
    F4 --> G

    G -->|changes requested| B
    G -->|approved| H[Merge queue]
    H --> I[Refresh against latest canonical state]
    I -->|conflict| B
    I -->|green| J[Merge: canonical intent]

    J --> K{External effect?}
    K -->|No| L[Done / release]
    K -->|Yes| M[Separate execution authorization]
    M --> N[Apply to external world]
    N --> O[Observe outcome]
    O -->|healthy| L
    O -->|bad outcome| P[Compensating / revert PR]
    P --> E
```

GitHub's merge queue captures the crucial integration insight: a PR that passed checks in isolation is tested again against the current target branch and preceding queued changes. For agent systems, this means **“green at submission time” is not sufficient; material checks must be evaluated on the candidate integration state**.  [[3]](https://docs.github.com/en/repositories/configuring-branches-and-merges-in-your-repository/configuring-pull-request-merges/managing-a-merge-queue)

## Domain mappings and concrete operating patterns

The analogy becomes useful only when “diff,” “test,” “merge,” and “rollback” acquire domain-specific semantics.

| Domain | Stage / branch | Commit = hand-in | PR = review | CI/tests | Merge vs. apply | Rollback / compensation | Evidence |
|---|---|---|---|---|---|---|---|
| **Writing** | Draft branch; stage paragraphs, claims, citations or sections | Frozen manuscript snapshot with sources and claim manifest | Editorial/factual review | Build, broken-reference checks, citation completeness, style/schema checks, claim-source tests, plagiarism/licensing checks where appropriate | Merge updates canonical manuscript; publishing remains separate | Revert text or publish corrective revision | Manubot explicitly adopts software-development review for manuscripts and requires proposed changes to be discussed/reviewed.  [[4]](https://journals.plos.org/ploscompbiol/article?id=10.1371/journal.pcbi.1007128) |
| **Design** | Figma branch or isolated design copy; stage components/tokens/screens | Candidate component/system state | Designer/system-owner review | Token/schema rules, contrast/accessibility checks, missing variants, screenshot/regression comparisons, prototype tests | Merge changes main design file/library; product release is downstream | Restore prior branch/main version, but beware later main changes can be lost in restoration | Figma exposes branch sharing, review and merge; restoring old main state affects everyone and can discard subsequent changes.  [[5]](https://help.figma.com/hc/en-us/sections/5665686755479-Branching-and-merging)[[28]](https://help.figma.com/hc/en-us/articles/5691750511383-Incomplete-merges-or-updates) |
| **Data labeling** | Candidate annotation batch against fixed ontology/version | Immutable labels + item IDs + annotator/provenance | QA reviewer approves or rejects to rework | Schema, class validity, gold items, inter-annotator consensus, distribution/drift checks | Merge admits labels to trusted dataset; model-training release is separate | Revert batch or supersede labels with corrected version | Labelbox separates initial labeling from review/rework and provides consensus/benchmark QA.  [[6]](https://docs.labelbox.com/docs/what-is-a-project) |
| **Data engineering** | lakeFS branch / shadow dataset | Dataset snapshot | Data PR | Row counts, constraints, reconciliation, data-quality suite, privacy policy | Merge points canonical data state to new snapshot | Revert/reset to known-good snapshot | lakeFS implements branches, commits, PRs, branch protection and rollback for data.  [[7]](https://docs.lakefs.io/guides/version-data/) |
| **Decision-making** | Versioned proposal/RFC/ADR | Frozen recommendation plus assumptions and evidence | Deliberation and formal approval | Required fields, conflicting-policy checks, dependency/cost models, scenario tests | Merge means “adopted decision”; implementation remains separate work | Superseding decision referencing old decision; never erase rationale | Kubernetes distinguishes review/approval responsibilities and assigns reviewers/approvers from ownership metadata, including a rotating PR Wrangler in docs.  [[29]](https://kubernetes.io/docs/contribute/review/for-approvers/) |
| **Robotics** | Planned mission/trajectory in simulation or schedule | Versioned intended trajectory/task graph | Fleet/safety/system review or automated negotiation | Collision checks, reachability, timing, resource capacity, safety envelope, digital twin/simulation | Merge means schedule/plan accepted; dispatch is a second gate | Safe stop, replan, return-to-safe-state or compensating mission—not physical time reversal | Open-RMF maintains a living schedule of fleet itineraries and negotiates conflicts that prediction could not avoid.  [[9]](https://openrmf.readthedocs.io/en/latest/faq/index.html)[30] |
| **Business process** | Proposed transaction/workflow update in durable pending state | Frozen proposed operation and inputs | Human or policy approval | Schema, policy, budget, segregation-of-duties, fraud/risk, duplicate/idempotency checks | Approval enters canonical workflow state; side effect executed separately | Saga-style compensating activity or corrective transaction | Temporal documents durable approval workflows with decisions, SLAs, escalation and audit records, and its AI patterns include compensating Saga actions.  [[8]](https://docs.temporal.io/guides/reliable-document-approvals)[31] |

**Writing.** Manubot is perhaps the cleanest existing proof that this is not merely an analogy. Its published workflow uses GitHub to organize collaborative manuscripts and adopts software-development practices that let contributors edit manuscript content while requiring proposed changes to pass discussion and review. A writing-agent team can extend this by making every commit carry a machine-readable claim inventory: claim text, source ID, quotation/paraphrase status, retrieval date, and confidence. CI can reliably test citation existence, duplicated references, style, schema, link health and numerical consistency; it is much less reliable at deciding whether an argument is persuasive or whether a source truly warrants a subtle claim, so those remain reviewer responsibilities.  [[4]](https://journals.plos.org/ploscompbiol/article?id=10.1371/journal.pcbi.1007128)

A useful writing PR is therefore deliberately small: one thesis change, subsection, fact update, or coherent group of edits rather than “rewrite the report.” Google's unrelated but instructive large-scale review evidence supports this strategy: about 90% of its reviewed changes touched fewer than ten files, the median change was only 24 modified lines, and review latency increased with size. That evidence is from software, so the transferable principle is **reviewable granularity**, not the literal line counts.  [18][32]

**Design.** Native design branching already looks strikingly like Git. Figma exposes branch creation, updating from main, branch review, and merging. Its rollback documentation also reveals why non-code rollback needs care: restoring an old main-file version applies globally and does not preserve other changes made after that version. The safe generalized pattern is therefore to prefer a **forward inverse patch**—a new reviewed change that undoes selected elements—over resetting the entire canonical design to an old snapshot.  [[5]](https://help.figma.com/hc/en-us/sections/5665686755479-Branching-and-merging)[[28]](https://help.figma.com/hc/en-us/articles/5691750511383-Incomplete-merges-or-updates)

Design CI should use two layers. Mechanical checks can cover component references, token values, naming, accessibility constraints and required variants. Perceptual tests should produce evidence—screenshots, visual diffs, interaction recordings—for a reviewer rather than pretending that a single scalar “design score” is authoritative. The PR should assign ownership by the semantic thing affected: design system, checkout, identity, accessibility, brand, localization, and so forth. This is the non-code equivalent of path-based ownership.

**Data labeling.** Labeling is particularly compatible with the model because “CI” can be statistical. Labelbox's workflow explicitly supports a label → independent review → approve or reject-to-rework sequence, with consensus and benchmark mechanisms for quality assessment.  [[6]](https://docs.labelbox.com/docs/what-is-a-project)

The classic Snow et al. Mechanical Turk study gives a useful quantitative demonstration of redundant checking. It collected ten independent annotations per item across five NLP tasks. In its affect-labeling experiment, an average of roughly four non-expert annotations per item was enough to reach the inter-annotator agreement of a single expert; in its word-similarity experiment, 300 annotations by ten annotators were completed in under eleven minutes, approximately 1,724 annotations/hour. On an RTE subset, ten-worker majority aggregation reached a maximum reported accuracy of 89.7%. The economics are from 2008 and should not be projected to 2026, but the more durable result is that **independent redundant judgments can be treated as a test ensemble rather than as duplicated waste**.  [[33]](https://aclanthology.org/D08-1027.pdf)[34][35]

For agent labeling, a good “PR” is not merely “review these 50,000 labels.” It is a batch with stratified QA: every candidate batch has ontology-version checks, a hidden or access-controlled gold sample, disagreement sampling, class-distribution comparisons, and targeted review of low-confidence or high-impact classes. The resulting consensus score belongs in CI evidence, but adjudication should create a new label version rather than silently overwrite history.

**Decision-making.** Here the commit is a versioned **argument**, not an action. The branch contains a proposal and supporting analysis; the PR is deliberation; CI checks whether required evidence and impact analyses exist; merge means the institution has adopted the decision. Kubernetes provides a useful governance pattern because its contribution process separates reviewers and approvers and automatically routes work based on ownership. That distinction transfers naturally: a reviewer asks “is this analysis sound?” while an approver asks “am I authorized to bind the organization to this outcome?”  [[29]](https://kubernetes.io/docs/contribute/review/for-approvers/)

A decision commit should therefore capture not just the conclusion but its **decision inputs**: assumptions, alternatives rejected, forecast metrics, policy constraints, dissent, owner, review deadline, and conditions that would trigger reconsideration. The rollback operation is a superseding decision that explicitly references the earlier one. Deleting or rewriting the original rationale destroys exactly the audit trail the GitHub model is meant to preserve.

**Robotics.** A robot team cannot safely treat a merged plan as an immediately executing command. Open-RMF illustrates the right decomposition: fleet managers report expected itineraries to a changing traffic schedule; when upcoming conflicts are detected, relevant fleets negotiate alternatives. The schedule is consequently closer to a canonical branch of **declared intent** than to the physical world itself.  [30][[9]](https://openrmf.readthedocs.io/en/latest/faq/index.html)

The robotic hand-in should include planned trajectory, map/version, resource reservations, timing envelope and state assumptions. CI runs collision checks, kinematic/resource constraints and simulation. A merge admits the trajectory into the authorized coordination schedule. Only an execution authority, observing sufficiently fresh physical state, may dispatch it. “Revert” means halt/replan/recover from the state that now physically exists. Once a robot moved an object, opened a valve or transported a patient, history cannot be rewound; recovery is a new physical operation.

**Business processes.** Temporal's document-approval guide is almost a literal non-code PR implementation. It models pending, approved, rejected, escalated and timed-out decisions; records an approver identity and decision time; maintains an audit trail; handles duplicate resubmission IDs; waits durably for decisions; enforces SLA timeouts; and can escalate if an approver does not respond.  [36][37][38][39]

For money, customer communications, procurement, HR changes or account modifications, this suggests a strong pattern: **the PR contains the requested transaction; CI evaluates policy; approval authorizes it; a durable workflow performs it; and a compensation is registered before execution**. Temporal's documented Saga pattern explicitly represents distributed operations whose later failure is handled with compensating actions.  [31]

## Shared state, synchronization, conflicts, authority and security

A multi-agent system should make its consistency model explicit. “Everybody has access to the same memory” is not a consistency model. Agents need to know what version they read, which objects their decision depended upon, whether those objects changed, and what form of reconciliation is required.

Consider two agents that begin from version `V42`:

```mermaid
sequenceDiagram
    participant A as Agent A
    participant B as Agent B
    participant C as Canonical state
    participant Q as Review / merge queue

    A->>C: Read objects at V42
    B->>C: Read objects at V42

    A->>Q: Submit change A, base=V42
    Q->>Q: Checks + approval
    Q->>C: Merge A
    C-->>A: Canonical state becomes V43

    B->>Q: Submit change B, base=V42
    Q->>C: Validate read/write set
    C-->>Q: Relevant dependency changed
    Q-->>B: STALE / semantic conflict

    B->>C: Refresh affected state at V43
    B->>B: Repair or regenerate dependent work
    B->>Q: Resubmit as base=V43
    Q->>Q: Re-run checks + re-approval
    Q->>C: Merge B as V44
```

That protocol is an instance of optimistic concurrency: allow speculative work in parallel, then reject or repair work whose assumptions became stale. It is often a better default for minute-long agent tasks than holding coarse locks for the entire inference interval.

The choice among synchronization mechanisms should depend on the conflict structure:

| State strategy | What it guarantees | Best fit | First failure as scale rises | Recommended use |
|---|---|---|---|---|
| **Isolated branches + merge** | Strong isolation before integration | Long-form writing, independent analyses, design variants | Conflicts are discovered late, after expensive work | Default when overlap is low and changes are readily mergeable |
| **Optimistic concurrency + read/version sets** | No silent stale overwrite if preconditions are checked | Records, decisions, labels, workflows | Abort/repair rate rises with contention | Default for shared structured state |
| **Locks / leases / resource claims** | Exclusive mutation/use | Scarce physical resources, account-level transactions | Queueing, head-of-line blocking, lease expiry | Keep lock scope narrow; lock resources, not whole projects |
| **Merge queue** | Serialized integration against recent canonical state | High-volume independent submissions | Queue latency and repeated test cost | Use when many individually valid changes may interact; GitHub explicitly positions merge queues for high-PR-volume branches.  [[3]](https://docs.github.com/en/repositories/configuring-branches-and-merges-in-your-repository/configuring-pull-request-merges/managing-a-merge-queue) |
| **CRDT/shared convergent workspace** | Deterministic structural convergence | Text blocks, notes, low-coupling collaborative state | Semantic contradictions remain even when merge succeeds | Use for cooperative editing, not as a semantic safety guarantee |
| **Central orchestrator** | Central assignment and synthesis | Parallel search, independent subtasks | Orchestrator attention/context bottleneck | Good where decomposition is clean |
| **Durable event/workflow state** | Long-lived state survives worker failures and delayed human decisions | Business processes and approvals | Workflow/history growth; operational complexity | Preferred for externally consequential long-running work.  [[8]](https://docs.temporal.io/guides/reliable-document-approvals)[31] |

Recent agent-systems research reinforces the distinction. CodeCRDT coordinated agents through observable CRDT-backed shared state and achieved structural convergence with zero merge failures, yet still reported an estimated 5–10% semantic-conflict rate. Another 2026 preprint, STORM, explicitly argues that isolated worktrees defer conflicts until an expensive post-hoc merge and instead mediates state at write time; its reported gains were +18.7 points on Commit0-Lite and +1.4 on PaperBench versus its worktree-based multi-agent baseline. These are new research results rather than mature production guarantees, but both point toward the same architecture: **state awareness should be part of the agent protocol, not left solely to final merging**.  [[26]](https://arxiv.org/abs/2510.18893)[[40]](https://arxiv.org/abs/2605.20563)

CoAgent pushes the idea further for systems in which writes cannot be cleanly sandboxed: rather than always blocking or aborting a long-running agent after a conflict, it notifies affected agents and repairs only work dependent on the conflicting state while using registered inverse operations for speculative writes. Across ten contended workloads, its authors report correctness within 5% of serial execution with about a 1.4× speedup; this should be treated as promising research evidence, not a universal production result.  [[41]](https://arxiv.org/abs/2606.15376)[42]

**Conflict detection should be broader than diff overlap.** A mature system needs at least the following categories:

| Conflict type | Example | Detection | Resolution |
|---|---|---|---|
| Structural write/write | Two writers edit the same paragraph, field, label or design component | Overlapping write sets / diff | Rebase, reconcile or designate winner |
| Stale-read | Agent prices a contract using an older policy version | Read-version precondition | Refresh only invalidated dependencies; re-review |
| Semantic invariant | Two individually valid decisions exceed a shared budget | Constraint solver / domain tests | Joint optimization or higher-level adjudication |
| Dependency conflict | One PR removes an assumption another relies on | Dependency graph + impact checks | Recompute downstream work |
| Resource/time conflict | Two robots reserve the same corridor | Reservation table / schedule | Queue, negotiate or replan; Open-RMF uses schedule-based detection and negotiation.  [[9]](https://openrmf.readthedocs.io/en/latest/faq/index.html) |
| Authority conflict | Two owners approve incompatible policy directions | Governance graph | Escalate to principal with scope over both |
| Provenance conflict | Shared memory contains contradictory or untrusted facts | Source/version provenance | Quarantine, validate, select authoritative source |
| Execution conflict | Approved transaction is no longer valid at execution time | Re-check preconditions immediately before action | Cancel or reopen PR |

The measured agentic GitHub conflict study illustrates how quickly simple branch isolation can become expensive. Among replayable concurrent pairs, same-agent changes conflicted textually 19.8% of the time and cross-agent changes 41.7%; 57.6% of observed conflict reports were content conflicts, 26.8% modify/delete, and 15.1% add/add. These are code-specific results, but the large structural fraction is particularly instructive for non-code agents: conflicts are often not “we chose different words,” but “one agent thinks this thing exists while another thinks it should be removed.”  [15]

```mermaid
xychart-beta
    title "Textual conflict rate in concurrent agent-authored PR pairs"
    x-axis ["Same agent", "Different agents"]
    y-axis "Conflict rate (%)" 0 --> 50
    bar [19.8, 41.7]
```

*Source: 2026 merge-replay study; 601 evaluable same-agent pairs and 115 evaluable cross-agent pairs. The result concerns software repositories and is a warning signal, not a forecast for non-code workflows.*  [15]

**Shared memory should be treated like a versioned database, not a communal scratchpad.** Each durable memory record should have an identity, version, source/provenance, access class and validity interval. An agent's task context should carry a read-set manifest. When the agent hands in work, the system can decide whether changed memories are irrelevant, require automatic recomputation, or invalidate the submission. This avoids both extremes of always restarting on any global change and silently continuing on stale facts.

CRDTs are useful where agents need to observe one another in real time, but they solve a narrower problem than many agent architectures imply. Structural convergence does not settle contradictory claims, priorities or intentions. CodeCRDT's measured combination of 100% convergence and nonzero semantic conflict is a useful empirical example of that boundary.  [25]

**Authority should be split by capability, not merely by “agent role.”**

| Principal | May create proposal? | May alter canonical state? | May approve own work? | May cause external effect? | Typical authority |
|---|---:|---:|---:|---:|---|
| Author agent | Yes | No | **No** | No | Read scoped context; write own branch |
| Reviewer agent | Comments/tests | No | N/A | No | Read candidate + evidence; no merge token |
| CI/checker service | Evidence only | No | N/A | No | Read candidate; narrowly scoped test resources |
| Human/domain approver | Optionally | Through approval | Not own proposal | Usually no | Approve within owned semantic scope |
| Integrator/merge service | No | Yes, after policy | N/A | No | Merge-only capability |
| Execution service/operator | No | No | N/A | Yes, approved change only | Narrow action capability + precondition checks |
| Auditor | No | No | No | No | Read immutable provenance and decisions |
| Emergency authority | Exceptional | Exceptional | N/A | Exceptional | Human-held break-glass role, separately logged |

GitHub itself supplies several useful governance primitives: repository roles distinguish read, triage, write and maintain capabilities; protected branches can require approval and owner review; new commits can dismiss stale reviews; and PR authors cannot approve their own PRs. GitHub rulesets can additionally require an approval from someone other than the person who made the latest push.  [[43]](https://docs.github.com/en/organizations/managing-user-access-to-your-organizations-repositories/managing-repository-roles/repository-roles-for-an-organization)[[21]](https://docs.github.com/en/repositories/configuring-branches-and-merges-in-your-repository/managing-protected-branches/managing-a-branch-protection-rule)[22][23]

An especially important implementation trap is **self-certifying gates**. GitHub's status-check documentation states that anyone with repository write permission can set the state of a status check. In a generalized agent system, an “approved=true” field, `qa-passed` label, or check status that the authoring principal can write is evidence of nothing independent. Checks and approvals should therefore be cryptographically or infrastructurally attributable to a distinct service identity whose credentials the authoring agent cannot access.  [24]

Access control should follow resource-level least privilege rather than trusting an agent because it is “inside” the system. NIST's Zero Trust Architecture explicitly rejects implicit trust based on network location or ownership and treats authentication and authorization as discrete decisions before access to resources. GitHub similarly recommends minimizing `GITHUB_TOKEN` permissions and allows job-specific token permissions. For agent teams, the practical translation is: unique service identities per agent/session; minimum read/write scopes; short-lived credentials; no wildcard production capability; separate credentials for propose, approve, merge and execute; and immediate revocation at task termination.  [[44]](https://csrc.nist.gov/pubs/sp/800/207/final)[45]

Agent-specific security guidance adds two controls worth making architectural: isolate memory/context between principals, and separate decision-making from execution for irreversible operations. OWASP's current agent-security guidance also recommends least-privilege tool permissions, structured outputs, human oversight for high-risk actions, signed/verified inter-agent communication, explicit validation evidence and limits on recursion/retries/tool chaining.  [[46]](https://cheatsheetseries.owasp.org/cheatsheets/AI_Agent_Security_Cheat_Sheet.html)

Finally, the audit trail should not merely log the final answer. A useful “commit object” for an autonomous worker records:

**task ID; agent/service identity; model and configuration; base-state versions; inputs actually read; sources/provenance; selected staged effects; artifact hashes; tests and their checker identities; approval identities and timestamps; changes after approval; merge position; permissions granted; executed tool calls; external-effect result; compensation/revert links; and accepted exceptions.**

GitHub's organization audit log records actor, action and time, while Temporal's approval example explicitly stores timestamp, workflow ID, action, actor, details and approval level. Those are good minimum models, not maxima.  [[27]](https://docs.github.com/en/organizations/keeping-your-organization-secure/managing-security-settings-for-your-organization/reviewing-the-audit-log-for-your-organization)[36]

## Scaling: what breaks first, and the measured evidence

There is no single team size at which the model fails. The break point depends mainly on **work coupling**, **review service capacity**, **artifact size**, **test latency**, **state freshness requirements**, and **how many submissions touch the same semantic resources**.

A useful first-principles model for review is a queue. Let:

\[
\lambda=\text{submissions per hour},\quad
c=\text{number of independent reviewers},\quad
\mu=\text{review completions per reviewer-hour}
\]

Then reviewer utilization is:

\[
\rho=\frac{\lambda}{c\mu}
\]

As arrival rate approaches total service capacity, queued work accumulates faster and review delay becomes increasingly sensitive to small variations in review time. Therefore, adding authoring agents without increasing reviewer capacity can increase total latency even when artifact-generation time falls. This is one reason “agents produce work faster” does not imply “the organization ships decisions faster.”

The failure order is typically:

**For independent, low-coupling work:** reviewer queue → CI capacity → provenance/audit volume → occasional integration conflicts.

**For shared, highly coupled work:** stale context/merge conflicts → communication and coordination overhead → reviewer load → CI/integration queue.

**For safety-critical or irreversible work:** execution authority and validation capacity dominate first; additional producers often add little useful throughput unless safety review and resource scheduling scale with them.

| Failure mode | Why it grows | Leading indicator | Operational response |
|---|---|---|---|
| Review bottleneck | Submission rate grows faster than qualified approval capacity | Commit→first-review delay; open PR age; reviewer queue depth | Smaller PRs; owner routing; reviewer pools; automate mechanical review |
| Cognitive overload | Each reviewer must reconstruct more context | Review time/PR; defect escape rate; comments/PR; reopen rate | Diff summaries, provenance, scoped ownership, semantic impact graph |
| Merge conflict | More overlapping writers share increasingly stale base state | Conflict rate; stale-base rate; overlapping write-set rate | Partition ownership, read-set OCC, merge queue, smaller changes |
| Semantic collision | Changes do not textually overlap but violate shared constraints | Post-merge test failures; invariant violations | Combined-state CI, dependency graph, scenario simulation |
| CI latency | Every candidate triggers expensive checks | Queue time vs test time; runner utilization | Tier checks, cache immutable evidence, batch safe checks, merge queue |
| Coordination tax | Agent-to-agent messages and shared context grow rapidly | Tokens/message count per accepted artifact | Hierarchy, partitions, sparse directed communication |
| Trust decay | More autonomous principals and evidence producers enlarge attack/error surface | Unauthorized action attempts, forged/self-generated gate evidence, overrides | Distinct identities, attested checks, least privilege, independent approval |
| Rework amplification | Late conflict invalidates minutes/hours of completed inference/work | Repair/retry cost; abandoned PR rate | Detect conflict at write/read-set level; incremental repair |
| Resource contention | Agents compete over exclusive real-world resources | Wait-for-resource time; reservation conflicts | Leases, scheduling, priority policy, explicit arbitration |

The largest empirical study here of human review is Google's 2018 case study: roughly nine million reviewed changes, more than 25,000 authors/reviewers, and about 20,000 qualifying changes per workday. The median reviewer reviewed four changes per week, 80% reviewed fewer than ten, initial feedback was under one hour for small changes and about five hours for very large changes, and the median end-to-end review latency was under four hours. Reviewers spent an average 3.2 hours and median 2.6 hours per week reviewing.  [[16]](https://research.google/pubs/modern-code-review-a-case-study-at-google/)[17][18][20]

That scale was not achieved by making each review maximally elaborate. Fewer than 25% of changes had more than one reviewer, the median reviewer count was one, more than 80% required at most one iteration to address comments, and Google used automated pre-commit analyses alongside human review. Reviewer recommendation also considered ownership/history, and some teams used round-robin assignment with review load and absences taken into account.  [19][32]

For a non-code agent organization, the implication is strong: **do not respond to increased agent count by adding an ever-larger review committee to each artifact**. Route a small change to the smallest independent set of principals with the necessary authority, automate objective checks, and escalate only changes whose risk or cross-domain scope warrants additional reviewers.

The newer multi-agent evidence shows a second scaling boundary: coordination itself can destroy the benefit of parallel generation. Google Research's 180-configuration evaluation found approximately +81% performance on the parallelizable Finance-Agent benchmark for a suitable multi-agent setup versus a single-agent baseline, but up to −70% on sequential PlanCraft; its architecture-selection model selected the optimal architecture for 87% of unseen configurations.  [[10]](https://research.google/blog/towards-a-science-of-scaling-agent-systems-when-and-why-agent-systems-work/)[[11]](https://research.google/blog/towards-a-science-of-scaling-agent-systems-when-and-why-agent-systems-work/)

The core pattern is task topology:

| Work topology | Preferred team architecture | Why |
|---|---|---|
| Many independent evidence-gathering subtasks | Parallel workers + central synthesis | Parallelism is real and outputs can be integrated cheaply |
| Sequential plan where each action changes the next | Single agent or tightly controlled handoff | Extra agents see stale/partial states and add coordination overhead |
| Multiple independent hypotheses | Independent workers + evaluator | Diversity is useful; consensus at the end |
| Shared mutable artifact with weak coupling | Observable shared state / CRDT + semantic checks | Fast convergence; agents can avoid duplicating work |
| Shared mutable artifact with strong coupling | Serialized ownership or OCC with repair | Prevents late merge disasters |
| Multiple organizational domains | Hierarchy of owners + cross-domain approval only where affected | Prevents all-to-all communication |
| Scarce physical resources | Central scheduler / reservation service | The environment itself serializes conflicting actions |

A 2026 Fudan study independently observed diminishing/inverted-U behavior as homogeneous agent count increased to eight. Its authors report that token cost in their SIMAS architecture grows quadratically with team size, and Llama-3.1-70B lost 27.45% accuracy between one and eight agents on logical-reasoning tasks. They explicitly caution that the study only went to eight agents and used a minimalist homogeneous architecture, so it should not be read as establishing a universal optimum at any specific count.  [12][13]

One of its reported examples, Qwen2.5-72B on abstract algebra under a controlled setup, rose from 60.78% at two agents to 72.55% at four and then fell to 64.71% at eight—an illustrative inverted-U rather than a universal curve.  [[47]](https://arxiv.org/abs/2606.00655)

```mermaid
xychart-beta
    title "Illustrative multi-agent scaling: Qwen2.5-72B abstract algebra"
    x-axis "Number of agents" [2, 4, 8]
    y-axis "Accuracy (%)" 50 --> 80
    line [60.78, 72.55, 64.71]
```

This suggests that an operating system for agent teams should **scale by partitioning authority and work**, not by putting every agent in one conversation. Give each agent a bounded branch, expose relevant upstream changes through subscriptions, and let only designated integrators synthesize across partitions.

A compact view of the strongest measured evidence is:

| Study / system | Measurement | Result | What it says about non-code agent teams |
|---|---|---|---|
| Google modern code review | ~9M changes; >25k authors/reviewers | Median overall review <4 h; median reviewer 4 changes/week; median 2.6 review hours/week; >80% ≤1 revision iteration.  [18][19][20] | Review can scale, but demonstrated practice relies on small changes, automated checks and narrow reviewer sets |
| Google agent-scaling study, 2026 | 180 configurations | ~+81% on parallel Finance-Agent; as low as −70% on sequential PlanCraft; architecture predictor 87% on unseen cases.  [[10]](https://research.google/blog/towards-a-science-of-scaling-agent-systems-when-and-why-agent-systems-work/)[[11]](https://research.google/blog/towards-a-science-of-scaling-agent-systems-when-and-why-agent-systems-work/) | Parallelism helps only when task structure supports it |
| Fudan MAS scaling, 2026 | Teams up to 8 agents | Quadratic token growth in SIMAS; Llama 70B logical-reasoning result down 27.45% from 1→8.  [12][13] | Communication/context overhead can outweigh extra reasoning |
| Agentic GitHub PR study, 2026 | 33,596 PRs; 2,807 repos | 79.4% of PRs co-active at exact overlap; 19.8% same-agent vs 41.7% cross-agent textual conflict in sampled replay.  [14][15] | Parallel isolated branches accumulate integration risk |
| CodeCRDT, 2025 | 600 trials | Up to +21.1% speedup or −39.4% slowdown; 100% convergence; estimated 5–10% semantic conflicts.  [25][[26]](https://arxiv.org/abs/2510.18893) | Mechanical merge success does not establish semantic correctness |
| Snow et al. labeling, 2008 | 10 independent annotations/item across five NLP tasks | Affect task averaged ~4 non-expert labels to single-expert agreement; one experiment reached ~1,724 annotations/hour.  [[33]](https://aclanthology.org/D08-1027.pdf)[34] | Redundancy can be turned into statistical CI, but adds multiplicative review cost |

One requested concept—**trust decay with team size**—does not currently have a comparably strong cross-domain quantitative law in the primary material reviewed here. It should therefore be measured operationally rather than assigned a speculative number. Useful indicators are the fraction of accepted changes later overturned; reviewer–author disagreement rate; self-generated versus independently generated test evidence; policy-bypass rate; provenance failures; unauthorized tool attempts; post-merge corrections; and incidents attributable to poisoned or stale shared memory. Security guidance strongly supports the mechanism—more privileges and untrusted inter-agent content enlarge the failure surface—but a universal “trust decreases X% per N agents” claim would not be supported by the evidence.  [[46]](https://cheatsheetseries.owasp.org/cheatsheets/AI_Agent_Security_Cheat_Sheet.html)[[44]](https://csrc.nist.gov/pubs/sp/800/207/final)

## An actionable operating blueprint

A workable implementation should have a **control plane** separate from the domain tools themselves. The domain tool may be Google Docs, Figma, Labelbox, a database, a CRM, a planning engine or a robot fleet manager; the control plane owns work IDs, immutable snapshots, diffs, policies, reviews, checks, approvals and execution authorizations.

A minimal object model is:

| Object | Purpose | Must be immutable? |
|---|---|---:|
| `WorkItem` | Desired outcome, constraints, owner | Versioned |
| `Workspace` | Private speculative state | No |
| `ChangeSet` | Explicit staged writes + read dependencies | Frozen at commit |
| `Snapshot` | Content-addressed hand-in | Yes |
| `Review` | Comments and requested changes against a specific snapshot | Append-only |
| `CheckRun` | Machine evidence produced by named checker/version | Yes |
| `Approval` | Principal authorizes a specific snapshot under a policy | Yes |
| `MergeRecord` | Ordered admission to canonical history | Yes |
| `ExecutionAuthorization` | Narrow, expiring permission for an approved external effect | Yes |
| `ExecutionResult` | Observed effect, IDs, timestamps, output | Yes |
| `Compensation` | Link to inverse/corrective change | Yes |

**The PR template** should force agents to surface what reviewers otherwise have to reconstruct:

```text
Objective
What outcome does this change produce?

Base state
Which canonical version and relevant object versions were read?

Change scope
Exactly which objects/properties/claims/resources change?

Non-goals
What intentionally remains unchanged?

Evidence
Which tests ran? Which sources support factual claims?
Which simulation/gold-set/scenario results are attached?

Risk
What could break if this is wrong?
Who or what is affected?

Dependencies
Which other decisions, artifacts or live resources does this assume?

Rollback/compensation
How do we restore business consistency if the result is bad?
What is not actually reversible?

Approval
Which semantic owners are required, and why?

Execution
Does merge merely update canonical intent, or may it cause an external effect?
Who is allowed to execute it?
When does the authorization expire?
```

**CI should be layered rather than treated as one pass/fail oracle.**

| Check class | Writing | Design | Labeling/data | Decisions | Robotics | Business |
|---|---|---|---|---|---|---|
| Structural | Build, reference schema | Component/token validity | Ontology/schema | Required proposal fields | Plan/schema validity | Request/schema validity |
| Consistency | Figures vs text, citation IDs | Token/library consistency | Row/entity constraints | Budget/policy dependencies | Resource/schedule consistency | Account/state preconditions |
| Quality regression | Known claims / benchmark examples | Screenshot/interaction diffs | Gold set, consensus, drift | Scenario suite | Simulation/regression missions | Historical transaction cases |
| Safety/policy | Source/license policy | Accessibility policy | Privacy/PII policy | Legal/governance rules | Safety envelope | Limits, fraud, segregation of duties |
| Integration | Build full manuscript | Candidate design system | Candidate dataset snapshot | Portfolio-level impact | Multi-robot simulation | Full workflow sandbox |
| Adversarial | Unsupported-claim probes | Edge layouts/content | Ambiguous/adversarial examples | Counterarguments/red team | obstacle/failure injection | duplicate, replay, malformed input |

Automated evaluation should take work **away from reviewers**, not manufacture confidence. Google's review study specifically describes automated analysis and pre-commit tests being exposed alongside human comments, allowing people to concentrate on higher-level review rather than trivial mechanical defects.  [32]

For subjective deliverables, the machine gate should distinguish **“definitely violates an invariant”** from **“scored poorly according to a heuristic.”** The former can block automatically; the latter should usually create review evidence. An LLM critique score, aesthetic model, or business-judgment model should not be silently elevated to the equivalent of a deterministic unit test without empirical calibration.

**A practical risk-based sign-off policy** can look like this:

| Risk tier | Examples | Required checks | Required review | Apply authority |
|---|---|---|---|---|
| Reversible / low impact | Internal draft, exploratory labels, non-production design | Structural + basic domain CI | Optional or one independent reviewer | Agent may merge; no consequential external effect |
| Material but reversible | Published content, production dataset, customer-facing design | Full domain + integration CI | One domain owner independent of author | Separate service after approval |
| Difficult to reverse | Pricing policy, mass communications, customer records | Full CI + scenario/red-team checks | Domain owner + independent risk/policy reviewer | Explicit narrow authorization |
| Safety/legal/financial critical | Money movement, employment decision, robot actuation in safety-sensitive area | Full checks + fresh execution-time preconditions | Human dual control / designated accountable authority | Human-controlled or safety-certified execution path |

The precise risk boundaries are unspecified in the request and should be determined by the applicable regulator, safety case and organizational accountability model. The structural principle is nevertheless supported by both GitHub's independent-review model and current agent-security guidance favoring human oversight for high-impact actions.  [22][[46]](https://cheatsheetseries.owasp.org/cheatsheets/AI_Agent_Security_Cheat_Sheet.html)

**Use stale-approval invalidation aggressively.** An approval belongs to a snapshot, not to a branch name. If an agent changes material content after approval, the old approval should either be invalidated or a designated independent reviewer should explicitly approve the latest snapshot. GitHub provides both stale-review dismissal and “someone other than the latest pusher” controls, which make good templates for non-code policy engines.  [[21]](https://docs.github.com/en/repositories/configuring-branches-and-merges-in-your-repository/managing-protected-branches/managing-a-branch-protection-rule)[23]

**Route by ownership rather than broadcast.** Build a semantic equivalent of `CODEOWNERS`: `claims/clinical/* → medical reviewer`; `design/identity/* → identity owner`; `data/customer-eu/* → privacy owner`; `robots/zone-A/* → facility controller`; `finance/refunds/* → finance operations`. GitHub can require owner approval on affected paths, and Kubernetes uses ownership metadata to assign reviewers and approvers.  [48][[29]](https://kubernetes.io/docs/contribute/review/for-approvers/)

**Put a merge queue in front of high-contention canonical state.** When change volume is low, direct merge after approval may be fine. Once multiple approved PRs are concurrently targeting the same state, queue them, construct the candidate state against the latest baseline, rerun the integration-relevant tests, and merge only if still green. GitHub explicitly designed merge queues for branches receiving many PRs from many users and supports configurable build concurrency from 1 to 100.  [[3]](https://docs.github.com/en/repositories/configuring-branches-and-merges-in-your-repository/configuring-pull-request-merges/managing-a-merge-queue)

**Do not automatically rerun every expensive test after every trivial update.** Checks should declare their dependency footprint. A citation-formatting update need not rerun a robotics simulator; a change to a global pricing rule probably should invalidate every dependent financial scenario. This is effectively a test dependency graph and becomes increasingly important as agent throughput grows.

**Measure the operating system, not just agent accuracy.** The most useful dashboard is:

| Metric | Definition | Why it matters |
|---|---|---|
| Hand-in throughput | committed candidate snapshots / time | Raw producer capacity |
| Accepted throughput | merged changes / time | Actual organizational throughput |
| Execution throughput | successfully applied consequential changes / time | End-to-end value |
| Review queue delay | commit → first independent review | Detects reviewer bottleneck |
| Review service time | active reviewer time/change | Staffing and artifact-size signal |
| Merge latency | approval → canonical merge | Integration bottleneck |
| Execution latency | merge → verified effect | Downstream operations bottleneck |
| PR/change size | affected semantic objects / claims / records | Predictor of cognitive load |
| Stale-base rate | submissions whose dependency versions changed | Synchronization pressure |
| Conflict rate | PRs requiring manual/agent reconciliation | Parallel-work contention |
| Semantic-conflict escape rate | conflicts found after merge | Weakness of pre-merge validation |
| CI false-negative rate | bad change passed checks | Trustworthiness of gate |
| CI false-positive/flaky rate | good change blocked inconsistently | Wasted retries / queue pollution |
| Rework iterations | hand-in → revisions → approval | Brief quality and reviewer load |
| Reviewer load | reviews and active minutes/principal/time | Human bottleneck |
| Override/bypass rate | merges/actions using exceptional authority | Governance erosion |
| Revert/compensation rate | merged/applied changes later neutralized | Quality outcome |
| Memory staleness | age/version lag of facts used in hand-ins | Shared-state health |
| Provenance completeness | claims/actions with verifiable source lineage | Auditability |
| Unauthorized attempt rate | denied calls beyond task permission | Access-control effectiveness |
| Cost per accepted change | model + checks + reviewer + execution cost | Prevents “more agents” from disguising inefficiency |

Two ratios are particularly revealing:

\[
\text{Acceptance efficiency}
=
\frac{\text{accepted changes}}
{\text{hand-ins}}
\]

and

\[
\text{Coordination tax}
=
\frac{\text{review + retry + merge + communication cost}}
{\text{total end-to-end cost}}
\]

A new agent is genuinely scaling the system only if accepted or executed throughput increases without unacceptable increases in latency, escaped errors, reviewer load or coordination tax.

A sensible rollout is consequently progressive. First instrument the existing workflow and establish baseline latency, error, review and compensation rates. Next run agents in **shadow mode**, where they produce commits and PRs but cannot merge or act. Then permit low-risk merges while retaining human execution. Only after check quality, conflict rates and provenance have been measured should selected reversible actions receive automatic execution authority. High-consequence operations should remain behind independent authorization even when authorship is fully automated. This progression follows the broader least-privilege principle that authority should be granted only to the extent required for the current task.  [[44]](https://csrc.nist.gov/pubs/sp/800/207/final)[[46]](https://cheatsheetseries.owasp.org/cheatsheets/AI_Agent_Security_Cheat_Sheet.html)

The architectural end state is not “a swarm of agents all sharing a chat.” It is closer to a well-run distributed organization:

**agents own bounded branches; state carries versions; changes are explicit objects; reviewers own semantic domains; tests produce attributable evidence; an integration layer serializes conflicting changes; permissions are narrow and temporary; consequential effects use a second gate; and every correction is another traceable forward event rather than an erased mistake.**

That is the part of GitHub worth copying.

## Primary sources and links

The research above prioritizes official documentation and original papers. The most directly useful sources are collected here.

| Topic | Primary / official source |
|---|---|
| Git staging semantics | [Git — `git add` documentation](https://git-scm.com/docs/git-add)  [[1]](https://git-scm.com/docs/git-add) |
| GitHub review model | [GitHub — Pull request reviews](https://docs.github.com/en/pull-requests/reference/pull-request-reviews)  [[2]](https://docs.github.com/en/pull-requests/reference/pull-request-reviews) |
| Protected branches / stale approvals | [GitHub — Managing a branch protection rule](https://docs.github.com/en/repositories/configuring-branches-and-merges-in-your-repository/managing-protected-branches/managing-a-branch-protection-rule)  [[21]](https://docs.github.com/en/repositories/configuring-branches-and-merges-in-your-repository/managing-protected-branches/managing-a-branch-protection-rule) |
| Merge queues | [GitHub — Managing a merge queue](https://docs.github.com/en/repositories/configuring-branches-and-merges-in-your-repository/configuring-pull-request-merges/managing-a-merge-queue)  [[3]](https://docs.github.com/en/repositories/configuring-branches-and-merges-in-your-repository/configuring-pull-request-merges/managing-a-merge-queue) |
| Access roles | [GitHub — Repository roles](https://docs.github.com/en/organizations/managing-user-access-to-your-organizations-repositories/managing-repository-roles/repository-roles-for-an-organization)  [[43]](https://docs.github.com/en/organizations/managing-user-access-to-your-organizations-repositories/managing-repository-roles/repository-roles-for-an-organization) |
| Audit trail | [GitHub — Reviewing the organization audit log](https://docs.github.com/en/organizations/keeping-your-organization-secure/managing-security-settings-for-your-organization/reviewing-the-audit-log-for-your-organization)  [[27]](https://docs.github.com/en/organizations/keeping-your-organization-secure/managing-security-settings-for-your-organization/reviewing-the-audit-log-for-your-organization) |
| Large-scale human review metrics | [Sadowski et al., “Modern Code Review: A Case Study at Google”](https://research.google/pubs/modern-code-review-a-case-study-at-google/)  [[49]](https://research.google/pubs/modern-code-review-a-case-study-at-google/)[[16]](https://research.google/pubs/modern-code-review-a-case-study-at-google/) |
| Collaborative writing | [Himmelstein et al., “Open collaborative writing with Manubot”](https://journals.plos.org/ploscompbiol/article?id=10.1371/journal.pcbi.1007128)  [[4]](https://journals.plos.org/ploscompbiol/article?id=10.1371/journal.pcbi.1007128) |
| Design branching | [Figma — Branching and merging](https://help.figma.com/hc/en-us/sections/5665686755479-Branching-and-merging)  [[5]](https://help.figma.com/hc/en-us/sections/5665686755479-Branching-and-merging) |
| Design rollback limitations | [Figma — Incomplete merges or updates](https://help.figma.com/hc/en-us/articles/5691750511383-Incomplete-merges-or-updates)  [[28]](https://help.figma.com/hc/en-us/articles/5691750511383-Incomplete-merges-or-updates) |
| Data-labeling review workflow | [Labelbox — Project overview](https://docs.labelbox.com/docs/what-is-a-project)  [[6]](https://docs.labelbox.com/docs/what-is-a-project) |
| Label redundancy research | [Snow et al., “Cheap and Fast — But is it Good?”](https://aclanthology.org/D08-1027.pdf)  [[33]](https://aclanthology.org/D08-1027.pdf) |
| Data versioning | [lakeFS — Version Data](https://docs.lakefs.io/guides/version-data/)  [[7]](https://docs.lakefs.io/guides/version-data/) |
| Governance/reviewer ownership | [Kubernetes — Reviewing for approvers and reviewers](https://kubernetes.io/docs/contribute/review/for-approvers/)  [[29]](https://kubernetes.io/docs/contribute/review/for-approvers/) |
| Multi-fleet robotic coordination | [Open-RMF — Traffic-conflict FAQ](https://openrmf.readthedocs.io/en/latest/faq/index.html)  [[9]](https://openrmf.readthedocs.io/en/latest/faq/index.html) |
| Durable approval workflows | [Temporal — Reliable document approvals](https://docs.temporal.io/guides/reliable-document-approvals)  [[8]](https://docs.temporal.io/guides/reliable-document-approvals) |
| Agent architecture scaling | [Google Research — “Towards a science of scaling agent systems”](https://research.google/blog/towards-a-science-of-scaling-agent-systems-when-and-why-agent-systems-work/)  [[10]](https://research.google/blog/towards-a-science-of-scaling-agent-systems-when-and-why-agent-systems-work/)[[11]](https://research.google/blog/towards-a-science-of-scaling-agent-systems-when-and-why-agent-systems-work/) |
| Multi-agent scaling with agent count | [“Scaling Behavior of Single LLM-Driven Multi-Agent Systems”](https://arxiv.org/abs/2606.00655)  [[47]](https://arxiv.org/abs/2606.00655) |
| Measured concurrent-agent merge conflicts | [“AI Agent Pull Requests on GitHub: Frequency, Structure, and Merge Conflict Rates”](https://arxiv.org/abs/2607.04697)  [[50]](https://arxiv.org/abs/2607.04697) |
| CRDT coordination | [“CodeCRDT: Observation-Driven Coordination for Multi-Agent LLM Code Generation”](https://arxiv.org/abs/2510.18893)  [[26]](https://arxiv.org/abs/2510.18893) |
| Shared-state mediation | [“Multi-agent Collaboration with State Management” / STORM](https://arxiv.org/abs/2605.20563)  [[40]](https://arxiv.org/abs/2605.20563) |
| Conflict repair / concurrency control | [“CoAgent: Concurrency Control for Multi-Agent Systems”](https://arxiv.org/abs/2606.15376)  [[41]](https://arxiv.org/abs/2606.15376) |
| Least-privilege architecture | [NIST SP 800-207 — Zero Trust Architecture](https://csrc.nist.gov/pubs/sp/800/207/final)  [[44]](https://csrc.nist.gov/pubs/sp/800/207/final) |
| Agent-specific security controls | [OWASP — AI Agent Security Cheat Sheet](https://cheatsheetseries.owasp.org/cheatsheets/AI_Agent_Security_Cheat_Sheet.html)  [[46]](https://cheatsheetseries.owasp.org/cheatsheets/AI_Agent_Security_Cheat_Sheet.html) |

The overall evidence supports a fairly sharp conclusion: the GitHub analogy is most powerful not because “commits and PRs are familiar,” but because it creates **explicit speculation, immutable hand-ins, independent evidence, scoped authority, serialized integration and durable accountability**. The analogy breaks precisely where those concepts are treated superficially—when a commit immediately acts on the world, when an author can self-certify its checks, when shared memory has no version semantics, when clean structural merging is mistaken for semantic consistency, or when agent throughput is increased without simultaneously designing review and integration capacity.  [[3]](https://docs.github.com/en/repositories/configuring-branches-and-merges-in-your-repository/configuring-pull-request-merges/managing-a-merge-queue)[22][24][[26]](https://arxiv.org/abs/2510.18893)[[11]](https://research.google/blog/towards-a-science-of-scaling-agent-systems-when-and-why-agent-systems-work/)
---

## Sources

50 citations. 26 name a source you can open; 24 point to an internal reference that did not survive the export.

1. [https://git-scm.com/docs/git-add](https://git-scm.com/docs/git-add)
2. [https://docs.github.com/en/pull-requests/reference/pull-request-reviews](https://docs.github.com/en/pull-requests/reference/pull-request-reviews)
3. [https://docs.github.com/en/repositories/configuring-branches-and-merges-in-your-repository/configuring-pull-request-merges/managing-a-merge-queue](https://docs.github.com/en/repositories/configuring-branches-and-merges-in-your-repository/configuring-pull-request-merges/managing-a-merge-queue)
4. [https://journals.plos.org/ploscompbiol/article?id=10.1371/journal.pcbi.1007128](https://journals.plos.org/ploscompbiol/article?id=10.1371/journal.pcbi.1007128)
5. [https://help.figma.com/hc/en-us/sections/5665686755479-Branching-and-merging](https://help.figma.com/hc/en-us/sections/5665686755479-Branching-and-merging)
6. [https://docs.labelbox.com/docs/what-is-a-project](https://docs.labelbox.com/docs/what-is-a-project)
7. [https://docs.lakefs.io/guides/version-data/](https://docs.lakefs.io/guides/version-data/)
8. [https://docs.temporal.io/guides/reliable-document-approvals](https://docs.temporal.io/guides/reliable-document-approvals)
9. [https://openrmf.readthedocs.io/en/latest/faq/index.html](https://openrmf.readthedocs.io/en/latest/faq/index.html)
10. [https://research.google/blog/towards-a-science-of-scaling-agent-systems-when-and-why-agent-systems-work/](https://research.google/blog/towards-a-science-of-scaling-agent-systems-when-and-why-agent-systems-work/)
11. [https://research.google/blog/towards-a-science-of-scaling-agent-systems-when-and-why-agent-systems-work/](https://research.google/blog/towards-a-science-of-scaling-agent-systems-when-and-why-agent-systems-work/)
12. *No link given.*
13. *No link given.*
14. *No link given.*
15. *No link given.*
16. [https://research.google/pubs/modern-code-review-a-case-study-at-google/](https://research.google/pubs/modern-code-review-a-case-study-at-google/)
17. *No link given.*
18. *No link given.*
19. *No link given.*
20. *No link given.*
21. [https://docs.github.com/en/repositories/configuring-branches-and-merges-in-your-repository/managing-protected-branches/managing-a-branch-protection-rule](https://docs.github.com/en/repositories/configuring-branches-and-merges-in-your-repository/managing-protected-branches/managing-a-branch-protection-rule)
22. *No link given.*
23. *No link given.*
24. *No link given.*
25. *No link given.*
26. [https://arxiv.org/abs/2510.18893](https://arxiv.org/abs/2510.18893)
27. [https://docs.github.com/en/organizations/keeping-your-organization-secure/managing-security-settings-for-your-organization/reviewing-the-audit-log-for-your-organization](https://docs.github.com/en/organizations/keeping-your-organization-secure/managing-security-settings-for-your-organization/reviewing-the-audit-log-for-your-organization)
28. [https://help.figma.com/hc/en-us/articles/5691750511383-Incomplete-merges-or-updates](https://help.figma.com/hc/en-us/articles/5691750511383-Incomplete-merges-or-updates)
29. [https://kubernetes.io/docs/contribute/review/for-approvers/](https://kubernetes.io/docs/contribute/review/for-approvers/)
30. *No link given.*
31. *No link given.*
32. *No link given.*
33. [https://aclanthology.org/D08-1027.pdf](https://aclanthology.org/D08-1027.pdf)
34. *No link given.*
35. *No link given.*
36. *No link given.*
37. *No link given.*
38. *No link given.*
39. *No link given.*
40. [https://arxiv.org/abs/2605.20563](https://arxiv.org/abs/2605.20563)
41. [https://arxiv.org/abs/2606.15376](https://arxiv.org/abs/2606.15376)
42. *No link given.*
43. [https://docs.github.com/en/organizations/managing-user-access-to-your-organizations-repositories/managing-repository-roles/repository-roles-for-an-organization](https://docs.github.com/en/organizations/managing-user-access-to-your-organizations-repositories/managing-repository-roles/repository-roles-for-an-organization)
44. [https://csrc.nist.gov/pubs/sp/800/207/final](https://csrc.nist.gov/pubs/sp/800/207/final)
45. *No link given.*
46. [https://cheatsheetseries.owasp.org/cheatsheets/AI_Agent_Security_Cheat_Sheet.html](https://cheatsheetseries.owasp.org/cheatsheets/AI_Agent_Security_Cheat_Sheet.html)
47. [https://arxiv.org/abs/2606.00655](https://arxiv.org/abs/2606.00655)
48. *No link given.*
49. [https://research.google/pubs/modern-code-review-a-case-study-at-google/](https://research.google/pubs/modern-code-review-a-case-study-at-google/)
50. [https://arxiv.org/abs/2607.04697](https://arxiv.org/abs/2607.04697)
