Back to the comparison
DownloadOpenAI “deep research”

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:

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:

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:

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]

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)

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:

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.

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 1(https://git-scm.com/docs/git-add)
GitHub review model GitHub — 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 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 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 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 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” 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” 4(https://journals.plos.org/ploscompbiol/article?id=10.1371/journal.pcbi.1007128)
Design branching Figma — Branching and merging 5(https://help.figma.com/hc/en-us/sections/5665686755479-Branching-and-merging)
Design rollback limitations Figma — 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 6(https://docs.labelbox.com/docs/what-is-a-project)
Label redundancy research Snow et al., “Cheap and Fast — But is it Good?” 33(https://aclanthology.org/D08-1027.pdf)
Data versioning lakeFS — Version Data 7(https://docs.lakefs.io/guides/version-data/)
Governance/reviewer ownership Kubernetes — Reviewing for approvers and reviewers 29(https://kubernetes.io/docs/contribute/review/for-approvers/)
Multi-fleet robotic coordination Open-RMF — Traffic-conflict FAQ 9(https://openrmf.readthedocs.io/en/latest/faq/index.html)
Durable approval workflows Temporal — Reliable document approvals 8(https://docs.temporal.io/guides/reliable-document-approvals)
Agent architecture scaling Google Research — “Towards a science of scaling agent systems” 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” 47(https://arxiv.org/abs/2606.00655)
Measured concurrent-agent merge conflicts “AI Agent Pull Requests on GitHub: Frequency, Structure, and Merge Conflict Rates” 50(https://arxiv.org/abs/2607.04697)
CRDT coordination “CodeCRDT: Observation-Driven Coordination for Multi-Agent LLM Code Generation” 26(https://arxiv.org/abs/2510.18893)
Shared-state mediation “Multi-agent Collaboration with State Management” / STORM 40(https://arxiv.org/abs/2605.20563)
Conflict repair / concurrency control “CoAgent: Concurrency Control for Multi-Agent Systems” 41(https://arxiv.org/abs/2606.15376)
Least-privilege architecture NIST SP 800-207 — Zero Trust Architecture 44(https://csrc.nist.gov/pubs/sp/800/207/final)
Agent-specific security controls OWASP — AI Agent Security Cheat Sheet 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
  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
  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
  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. 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/
  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
  22. No link given.
  23. No link given.
  24. No link given.
  25. No link given.
  26. 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
  28. https://help.figma.com/hc/en-us/articles/5691750511383-Incomplete-merges-or-updates
  29. 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
  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
  41. 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
  44. 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
  47. https://arxiv.org/abs/2606.00655
  48. No link given.
  49. https://research.google/pubs/modern-code-review-a-case-study-at-google/
  50. https://arxiv.org/abs/2607.04697