Source: docs/research/2026-09-03-defensibility/appendices/B-public-evidence.md

Panout — public evidence file

Compiled 2026-09-03. Every claim carries a URL. Items I could not confirm from a primary or reputable secondary source are tagged UNVERIFIED. Facts only — no recommendations.

Method note for the GitHub measurements: I used the authenticated gh CLI (gh api search/issues, gh api repos/{o}/{r}/pulls/{n}, .../pulls/{n}/reviews). Search results were sorted by updated, so samples skew toward recently-active repos and are not a uniform random sample of all merged agent PRs. Treat the percentages as indicative of a large, real population, not as unbiased estimates.

Q1. Do developers merge agent-authored code without reading it, at scale?

1a. Population size (measured 2026-09-03 via gh api search/issues)

Merged PRs on public GitHub, by agent identity:

Reproduce: gh api -X GET search/issues -f q='is:pr is:merged author:app/copilot-swe-agent' -f per_page=1 --jq .total_count Search UI equivalent: https://github.com/search?q=is%3Apr+is%3Amerged+author%3Aapp%2Fcopilot-swe-agent&type=pullrequests

Notes: author:app/codex, author:app/chatgpt-codex-connector and author:app/openai-codex all return 0 — Codex pushes branches under the human's identity, so head:codex/ is the usable proxy. Branch-prefix queries therefore mix agent-authored and human-authored commits on the same branch; counts are an upper bound. Counts across rows overlap.

1b. Review depth on merged agent PRs (measured samples)

I sampled merged PRs and pulled, for each, the formal review count (/pulls/{n}/reviews length), review comments, issue comments, diff size, and created→merged latency.

Sample A — author:app/copilot-swe-agent, all repos, n=150

• 25% (38/150) merged with zero formal reviews
• 14% (21/150) merged with zero reviews AND zero comments of any kind
• 70% merged within 10 minutes of PR creation; 89% within 60 minutes
• Median time from PR open to merge: 1.3 minutes
• Mean additions per PR: 397 lines

Sample B — author:app/copilot-swe-agent stars:>500, n=98

• 50% merged with zero formal reviews
• 38% merged with zero reviews and zero comments
• 36% merged within 10 minutes; 67% within 60 minutes
• Median latency: 19.6 minutes
• Mean additions per PR: 1,800 lines

Sample C — head:codex/ stars:>500, n=100

• 40% merged with zero formal reviews
• 25% merged with zero reviews and zero comments
• 36% within 10 minutes; 54% within 60 minutes
• Median latency: 28.4 minutes
• Mean additions per PR: 16,946 lines

Sample D — author:app/devin-ai-integration, all repos, n=150

• 63% merged with zero formal reviews
• 6% with zero reviews and zero comments (Devin posts bot comments on its own PRs, which inflates the comment count without implying human reading)
• 39% within 10 minutes; 66% within 60 minutes
• Median latency: 22.4 minutes
• Mean additions per PR: 2,916 lines

Sample E — CONTROL: merged PRs NOT from app/copilot-swe-agent, stars:>500, created:>2026-08-01, bot authors (*[bot]) stripped, n=85

• 49% merged with zero formal reviews
• 28% merged with zero reviews and zero comments
• 34% within 10 minutes; 56% within 60 minutes
• Median latency: 25.1 minutes
• Mean additions per PR: 12,604 lines

This control substantially qualifies the headline. In popular repos, merging with no formal review is the norm for all PRs, not a distinctive property of agent PRs: the Copilot >500-star sample (50% zero-review) and the codex-branch >500-star sample (40%) are statistically indistinguishable from the 49% baseline. Solo maintainers self-merging, trunk-based teams that review out-of-band, and PRs used as a deploy mechanism all produce zero-review merges.

Two things survive the control:

1. Merge latency in the unfiltered Copilot sample is an order of magnitude faster — median 1.3 minutes and 70% merged inside 10 minutes, versus 25.1 minutes and 34% for the control. A 397-line mean diff merged at a 1.3-minute median is not consistent with reading.
2. The control is itself contaminated in a way that cuts toward the thesis, not against it. Codex, Claude Code and Cursor push under the human's GitHub identity, so an unknown and growing share of the "control" is itself agent-authored (see the Claude Code ~4%-of-public-commits estimate in Q6). There is no clean human-authored baseline available from the GitHub API in 2026.

Reproduce the control: gh api -X GET search/issues -f q='is:pr is:merged -author:app/copilot-swe-agent stars:>500 created:>2026-08-01' -f per_page=50 -f sort=updated

Caveat: "zero formal reviews" is a lower bound on unread merges in one direction (a reviewer can read without leaving a review) and an upper bound in another (an approving review can be rubber-stamped). Merge latency under 10 minutes on a 1,000+ line diff is the stronger signal.

Example merged PRs with zero reviews, zero review comments, zero issue comments, self-merged by the repo owner:

• https://github.com/darksilenxe/auto-bughunter/pull/91 — +4,568 / −1,798 across 37 files
• https://github.com/Wiuvel/rvn-web/pull/7 — +4,889 / −473 across 13 files (Devin)
• https://github.com/mryk814/tasuken/pull/500 — +9,439 / −2,760 (codex branch, >500-star repo)
• https://github.com/TiagoX8/card-admin-portal/pull/1 — +2,006 / −2 across 24 files (Devin)
• https://github.com/szmyty/szmyty/pull/137 — +1,905 / −244 (Copilot, >500-star repo)
• https://github.com/Lyrion1/LyrionAtelier/pull/415 — +1,891 / −273 (Copilot, >500-star repo)
• https://github.com/andreww99982-code/women/pull/8 — +727 / −124
• https://github.com/Wiuvel/rvn-web/pull/6 — +2,348 / −0 across 17 files (Devin)

1c. Stated behaviour: developers say they don't read the diffs

• Sonar State of Code survey (>1,100 developers): 96% believe AI-generated code is not reliably functionally correct, yet only 48% say they always check AI code before committing; ~61% agree AI code "looks correct but isn't." Reported by The Register, 2026-01-09: https://www.theregister.com/2026/01/09/devs_ai_code/ and TechRadar: https://www.techradar.com/pro/devs-dont-trust-ai-code-but-many-say-they-still-dont-check-it-anyways
• METR RCT instrument explicitly offered "did not read the AI-generated code at all" as a response option, i.e. the behaviour was common enough to instrument: https://arxiv.org/pdf/2507.09089
• Addy Osmani, "Code Review in the Age of AI" quotes developer Peter Steinberger: "I don't read much code anymore." Osmani also documents OCaml maintainers rejecting a 13,000-line AI-generated PR on review-bandwidth grounds, not quality. https://addyosmani.com/blog/code-review-ai/ and https://addyo.substack.com/p/code-review-ai
• Stack Overflow 2025 Developer Survey — developers "willing but reluctant" on AI; trust down while usage up: https://stackoverflow.blog/2025/12/29/developers-remain-willing-but-reluctant-to-use-ai-the-2025-developer-survey-results-are-here/
• UNVERIFIED: a widely-quoted "11.4 hrs/week reviewing AI code vs 9.8 hrs writing" 2026 survey statistic surfaced in search but I could not trace it to a named, primary publisher. Do not cite without a source.
• UNVERIFIED: I found no public case study of a named company stating it auto-merges agent PRs as policy. GitHub's own docs frame auto-merge as gated on configured checks, not as an agent-trust decision (see Q5).

Q2. Do unread agent merges cause incidents?

2a. Named incidents

• Amazon Retail, March 2026 — the strongest public case. An internal memo from Dave Treadwell (SVP, eCommerce Services) described a "trend of incidents" with "high blast radius" and "Gen-AI assisted changes," listing use of generative AI tools "for which best practices and safeguards are not yet fully established" as a contributing factor, plus a lack of "automated pre-deployment validation." A ~6-hour retail-site outage; the week of March 2–5 reportedly involved four Sev-1 incidents and an estimated 6.3M lost orders. Remediation is directly on point: AI-assisted code changes must now be approved by a senior engineer before deployment — junior and mid-level engineers can no longer ship AI-assisted code to production unreviewed; Amazon called this "controlled friction." Tom's Hardware: https://www.tomshardware.com/tech-industry/artificial-intelligence/amazon-calls-engineers-to-address-issues-caused-by-use-of-ai-tools-report-claims-company-says-recent-incidents-had-high-blast-radius-and-were-allegedly-related-to-gen-ai-assisted-changes TechRadar: https://www.techradar.com/pro/amazon-is-making-even-senior-engineers-get-code-signed-off-following-multiple-recent-outages The New Stack: https://thenewstack.io/amazon-ai-assisted-errors/ Originating reporting attributed to the Financial Times and CNBC. Amazon disputes the framing, calling TWiST a routine weekly meeting and, in earlier AWS incidents, describing the cause as "user error, not AI error." Fortune reported Amazon's position that in the one AI-involved incident the root cause was an engineer acting on inaccurate advice an agent inferred from an outdated internal wiki.
• AWS Cost Explorer, ~Dec 2025 — 13-hour outage in mainland China, linked in reporting to the Kiro agent mandate; in one instance the agent autonomously deleted and recreated part of its environment. AWS response: mandatory peer reviews and staff training for agentic tools. Secondary source only: https://www.pagerly.io/blog/ai-generated-code-incidents-2026-data-2026-08-30 — UNVERIFIED (no official AWS post-event summary located).
• GitHub Merge Queue regression, 2026-04-23 — a merge-queue bug reverted changes from previously-merged PRs, affecting 2,092 pull requests; root cause given as an incomplete feature flag plus inadequate test coverage. Note: this is an incident in the merge-gating infrastructure, not caused by an agent PR. Secondary: https://blog.incidenthub.cloud/github-reliability-outage-history-2025-2026 — UNVERIFIED against GitHub's own availability report.
• Anthropic, April 2026 postmortem — acknowledged regressions that slipped past "multiple human and automated code reviews, unit tests, end-to-end tests, automated verification, and dogfooding." Cited secondhand; primary Anthropic engineering post not located in this pass — UNVERIFIED.
• PocketOS, April 2026 — production database and backups deleted by an agent. Secondary/blog sourcing only — UNVERIFIED.

2b. Revert volume on GitHub (measured 2026-09-03)

These are title-string matches, so they undercount (most reverts don't name the agent) and overcount slightly (title text can coincide). No star-filtered examples returned, so I have no high-profile named revert to point at.

2c. Aggregate defect / churn / instability numbers

• DORA 2025 State of AI-Assisted Software Development (~5,000 respondents): AI adoption at 90% (+14 pts YoY); >80% report productivity gains; AI is now linked to higher throughput but continues to increase instability — more change failures, more rework, longer time to restore. ~30% of developers report little or no trust in AI output. Analysts note the likely driver is that AI raises code-generation rate faster than review/deploy infrastructure absorbs it. https://dora.dev/research/2025/ (2024 edition, which found AI hurt both stability and throughput: https://dora.dev/research/2024/dora-report/) Summaries: https://www.faros.ai/blog/key-takeaways-from-the-dora-report-2025 , https://redmonk.com/rstephens/2025/12/18/dora2025/ , https://devops.com/dora-2025-faster-but-are-we-any-better/
• GitClear, "The Maintainability Gap" (2026) — >600M analyzed commits: block duplication per million changed lines rose 40.3 (2023) → 73.0 (2026 YTD), +81% and an all-time high; moved (refactored) code fell 21% (2022) → 3.8% (2026 YTD); copy/paste rose 9.4% (2022) → 15.7% (H1 2026); code churn rose from a ~3.3% pre-AI baseline to 5.7% (2024) to 7.1% (2025). https://www.gitclear.com/the_ai_code_quality_maintainability_gap Earlier: https://www.gitclear.com/ai_assistant_code_quality_2025_research Caveat GitClear's own readers raise: correlational, no control group.
• Veracode 2025 GenAI Code Security Report — 80 curated tasks × 100+ LLMs: models chose the insecure implementation in 45% of cases; Java worst at a 72% failure rate; XSS defence failed in 86% of relevant samples; security pass rates flat at 45–55% across model generations while syntactic correctness rose past 95%. https://www.veracode.com/resources/analyst-reports/2025-genai-code-security-report/ Spring 2026 re-test, same 45%: https://www.veracode.com/blog/spring-2026-genai-code-security/ Press release: https://www.businesswire.com/news/home/20250730694951/en/AI-Generated-Code-Poses-Major-Security-Risks-in-Nearly-Half-of-All-Development-Tasks-Veracode-Research-Reveals
• METR RCT (July 2025) — 16 experienced OSS developers, 246 tasks in their own mature repos: AI made them 19% slower, while they believed it made them 20% faster (forecast: 24% faster). CI +2% to +39%. https://metr.org/blog/2025-07-10-early-2025-ai-experienced-os-dev-study/ Paper: https://arxiv.org/pdf/2507.09089 Important update: METR now labels this historical and, in Feb 2026, published new data on late-2025 tools estimating a speedup for returning participants: https://metr.org/blog/2026-02-24-uplift-update/
• CodeRabbit (Dec 2025): AI-generated code carries security issues at 1.5–2× the human rate and performance inefficiencies at ~8× — UNVERIFIED (cited only through secondary aggregators in this pass).
• "45% of AI-generated code changes require debugging in production" — circulating widely; I could not trace it to a primary publisher — UNVERIFIED.

Q3. Is anyone asked for provenance of AI-written code?

Short answer from the evidence: provenance obligations today attach to AI-generated content and training data, not to the authorship of source code. I found no framework, auditor requirement, or standard questionnaire that asks "what fraction of your code is AI-generated."

• EU AI Act Article 50(2) requires providers of systems generating synthetic audio/image/video/text to mark outputs machine-readably and detectably. Applies from 2 August 2026; the May 2026 AI Omnibus provisional agreement gives generative systems already on market until 2 December 2026. Article text: https://artificialintelligenceact.eu/article/50/ Practical guide: https://artificialintelligenceact.eu/transparency-rules-article-50/ Commission FAQ: https://digital-strategy.ec.europa.eu/en/faqs/transparency-obligations-under-article-50-ai-act Code of Practice on Transparency of AI-Generated Content: https://digital-strategy.ec.europa.eu/en/policies/code-practice-ai-generated-content Key limit: the duty falls on the provider of the generative system, not on a team committing AI-assisted code, and there is an exemption where the system performs an assistive editing function that does not substantially alter the deployer's input. There is no free-standing "document that this code was AI-generated" obligation. Legal analysis: https://www.orrick.com/en/Insights/2026/08/EU-AI-Act-Transparency-Obligations-for-AI-Generated-Content-Article-50 , https://www.hsfkramer.com/notes/ip/2026-03/transparency-obligations-for-ai-generated-content-under-the-eu-ai-act-from-principle-to-practice Penalties: up to €15M or 3% of global turnover for high-risk breaches. Coding-assistant scope analysis (vendor blog): https://www.augmentcode.com/guides/eu-ai-act-2026
• ISO/IEC 42001 — 38 Annex A controls across 9 domains, including data governance and data provenance (training-data origin, documented and auditable), AI impact assessment, AI lifecycle, and third-party relationships. Practitioner estimates put SOC 2 overlap at ~40–50%. Certification ecosystem still immature as of 2026. https://www.vanta.com/products/ai (Vanta's own framing of ISO 42001 vs ISO 27001/SOC 2) https://truvocyber.com/blog/iso-42001-ai-saas-compliance-guide https://www.augmentcode.com/guides/ai-governance-framework-for-soc-2-and-iso-42001-compliance
• GPAI Code of Practice makes provenance tracking, watermarking and privacy-preserving data logging monitoring obligations for signatories, with documentation retained at least 10 years and available to the AI Office on request. https://code-of-practice.ai/ , https://artificialintelligenceact.eu/code-of-practice-overview/
• SOC 2 as of 2026: no AICPA "AI SOC 2 certification" exists; auditors sample SDLC change-management evidence, code-review controls, logging retention, tenant isolation, and model/dependency provenance (OWASP LLM03 supply chain) rather than AI-authorship share. https://soc2vendors.com/guides/ai-controls-in-soc-2-2026/ , https://soc2auditors.org/insights/soc-2-for-ai-companies/
• Vanta / Drata / SafeBase ship questionnaire-response automation, not code provenance tracking. https://drata.com/products/ai-questionnaire-assistance , https://www.vanta.com/products/ai
• UNVERIFIED: I found no published enterprise vendor security questionnaire that asks for the AI-generated share of a supplier's codebase. If it is being asked, it is being asked bespoke and privately.

Q4. Comparables — network-effect trust layer, priced per transaction

• Stripe Radar — pricing is now tiered subscription: Standard from $10/mo, Plus from $14/mo, Pro from $20/mo for standard businesses ($20 / $44 / $70 for platforms), each including a set number of screens per transaction / active account / customer; historic list pricing was 5¢ per screened transaction (7¢ for Radar for Fraud Teams). https://stripe.com/radar/pricing Network effect is the explicit pitch: trained on >70 trillion data points across the Stripe network, and 89% of cards presented to a business have been seen before by Radar. Radar is usable independently of Stripe Payments. https://stripe.com/radar , https://docs.stripe.com/radar
• Sift — consortium/network fraud data model. UNVERIFIED: no current pricing or revenue figures retrieved in this pass.
• Chainguard — closest "trust/provenance layer sold to engineering orgs" comparable. Series D $356M at $3.5B post (Kleiner Perkins + IVP), total raised $612M; ARR grew 7× to $40M in FY2025 with a stated >$100M FY2026 target; a further $280M from General Catalyst's Customer Value Fund at the same $3.5B in Oct 2025. https://www.prnewswire.com/news-releases/chainguard-raises-356-million-in-series-d-funding-to-be-the-safe-source-for-all-open-source-302435220.html , https://sacra.com/c/chainguard/
• Snyk — developer security; ~$326M ARR (Feb 2026), +7% YoY, last valued $7.4B; IPO discussed for 2026. https://sacra.com/c/snyk/ , https://www.globes.co.il/news/article.aspx?did=1001496365 (Growth has decelerated sharply — relevant as a cautionary comparable.)
• Surge AI — expert-label revenue: ~$1.2B annualized (2024) per Sacra, ~50,000 expert contractors vs ~130 FTEs; first external raise July 2025 seeking up to $1B at >$15B (Reuters), with later reports of talks at ~$25B (Bloomberg). https://sacra.com/c/surge-ai/
• Scale AI — ~$2B revenue 2025 (from $870M in 2024) per Sacra; Meta's $14B investment (June 2025) plus a five-year contract worth ≥$450M/yr; pivoting from labeling toward applications (~$200M annualized). https://sacra.com/c/scale-ai/ , https://scale.com/blog/scales-next-era-building-for-2026
• LMArena — closest "evaluation-as-a-network" comparable. $150M Series A at $1.7B post (Felicis + UC Investments; a16z, Kleiner, Lightspeed, House Fund, LDVP, Laude), Jan 2026, four months after launching its first commercial product; >$30M annualized consumption run rate; 5M+ monthly users across 150 countries, 60M conversations/month. Prior seed: $100M at $600M (May 2025). https://techcrunch.com/2026/01/06/lmarena-lands-1-7b-valuation-four-months-after-launching-its-product/ , https://www.prnewswire.com/news-releases/lmarena-raises-150-million-to-build-the-worlds-most-trusted-ai-evaluation-platform-302653012.html

Q5. What incumbents already ship at this boundary (Sept 2026)

For each, the three probe questions are: (a) learns a per-team acceptance bar from history? (b) enforces autonomy levels per task class? (c) records rejected/discarded agent work that never became a commit?

GitHub Copilot code review

https://docs.github.com/en/copilot/concepts/agents/code-review

• Reviews PRs, identifies issues, suggests fixes. Two review effort levels ("Lite" and "Balanced") — these control analysis depth, not autonomy.
• New and material: Copilot can now submit approving reviews that satisfy repository approval requirements (public preview). This is a change from the earlier position, widely reported through mid-2026, that Copilot review is structurally a Comment and never an Approve.
• Docs do not mention merging.
• (a) No — no evidence of learning an acceptance bar from team history.
• (b) No — effort levels are not task-class autonomy tiers.
• (c) No — no mention of recording rejected suggestions or discarded work.

GitHub rulesets + merge queue + auto-merge

• Rulesets support optional merge gating: PRs with unresolved rules-based findings, or below a coverage threshold, can be blocked from merging. https://docs.github.com/en/copilot/concepts/agents/code-review
• Documented operational hazard: auto-merge only waits for explicitly configured conditions, so a PR can merge while a Copilot review is still running unless you build a custom status check. https://devactivity.com/insights/integrating-ai-reviews-how-to-ensure-github-copilot-blocks-auto-merge-for-better-code-review-analytics/
• (a) No. (b) No — gating is per-branch/per-path, not per-task-class autonomy. (c) No — rulesets see PRs, not discarded agent attempts.
• Emerging practice (not product) is "review depth proportional to blast radius," with auth, payments, schema migrations, deletion paths and regulated data held in human-required categories. Vendor/commentary sources only: https://www.augmentcode.com/guides/autonomous-engineering-loop , https://www.developersdigest.tech/blog/agent-pr-governance-github-copilot-review

Linear — Coding Sessions and Guided Reviews

• Coding Sessions GA 2026-06-11, on Basic/Business/Enterprise with AI credits; agent writes code using Claude Code and Codex, runs in the cloud with workspace context, returns a diff. Linear says it resolves ~30% of incoming bug reports internally this way, mostly first-pass. https://linear.app/changelog/2026-06-11-coding-sessions
• Guided Reviews GA ~late July 2026 — decomposes large diffs into focused sections with explainers on what changed and why, core changes first, glue code separated. Shipped alongside GitHub team review requests in Linear, signed commits for coding sessions, and GitHub Copilot for Linear. https://linear.app/changelog
• Mobile coding-session review, 2026-07-30: review diffs, comment on lines, iterate.
• (a) No — Guided Reviews restructure the diff for a human; they do not learn a bar. (b) No. (c) Partial and incidental — a coding session thread retains iterations within the session, so superseded work inside a session is visible; there is no product concept of a rejected-work corpus.
• Walkthrough video: https://www.youtube.com/watch?v=o_FRV_H_NVE

Cursor — Bugbot, Agent Review, Security Review

• Bugbot moved from $40/seat/month to usage-based billing for Teams and Individuals, effective at the first renewal after 2026-06-08; average run $1.00–$1.50 depending on PR size; selectable effort level per review. https://cursor.com/blog/may-2026-bugbot-changes , https://cursor.com/docs/bugbot
• June 2026: >3× faster, 22% cheaper, 10% more bugs found, 90% of runs under three minutes, powered by Composer 2.5. https://cursor.com/blog/bugbot-updates-june-2026
• /review, /review-bugbot, /review-security in Cursor 3.7+ and at cursor.com/agents; CLI support "coming soon." Runs on every commit push, not once per PR. If you run /review locally and then open a PR with the same diff, Bugbot recognises it and skips. Reads repo rules from BUGBOT.md. https://cursor.com/docs/agent/agent-review
• (a) Closest thing in market, but rule-based not learned — Bugbot reviews "using team-tuned rules" from BUGBOT.md, i.e. a written bar, not one inferred from acceptance history. (b) No — effort level is a cost/depth dial. (c) No.
• Pricing per review is the closest existing per-transaction trust pricing in this category: ~$1.20 per default-effort review per third-party calculator (competitor marketing page, treat with caution): https://getoptimal.ai/bugbot-cost-calculator

Anthropic Claude Code — hooks, OTel, autonomy modes

• Hooks run locally between the model's decision and tool execution and can block a tool call or a prompt — the only deterministic pre-execution enforcement point.
• OTel is the evidence layer: records tool-permission decisions and who made them (policy, hook, or user waving it through). Critically, permission changes into bypassPermissions / auto mode are logged in OTel but NOT in the Compliance API — so autonomy-mode escalations are invisible to Compliance-API-only governance. https://generalanalysis.com/guides/claude-code-control-observability-opentelemetry https://generalanalysis.com/guides/claude-code-enterprise-security-deployment
• Aug 2026 Compliance API / identity governance coverage: https://thehackernews.com/2026/08/securing-claude-code-new-compliance-api.html
• AWS documents a gateway pattern (IdP sign-in, no developer API keys, managed settings by IdP group, usage telemetry relayed to observability): https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/coding-agents-claude-code.html Self-host walkthrough: https://signoz.io/blog/claude-code-monitoring-with-opentelemetry/
• (a) No. (b) Partial — permission modes and managed settings are global/session scoped, not per-task-class; hooks can approximate task-class rules but must be hand-written. (c) Partial and the most interesting gap — OTel captures tool calls and permission decisions locally, so some work that never became a commit is observable, but there is no product surface that treats discarded agent work as a first-class record. Also flagged: telemetry ≠ intent; and the OTel endpoint consent prompt is binary (accept managed settings or exit).

OpenAI Codex — code review

https://developers.openai.com/codex/integrations/github

• Once enabled on a repo, Codex automatically reviews PRs as they move from draft to ready; @codex review on demand, with steerable guidance ("review for security vulnerabilities"). In GitHub, Codex flags only P0 and P1 issues.
• OpenAI's stated dogfood result: Codex reviews the vast majority of OpenAI's own PRs and catches hundreds of issues daily, often before human review begins. https://openai.com/index/introducing-upgrades-to-codex/
• Roll-your-own: openai/codex-action (https://github.com/openai/codex-action) and a Codex SDK cookbook recipe that drops sudo so Codex cannot read its own API key: https://developers.openai.com/cookbook/examples/codex/build_code_review_with_codex_sdk
• 2026 "Codex for (almost) everything" release added computer use, in-app browser, PR review, SSH to remote dev boxes, 90+ plugins. https://thenewstack.io/openai-codex-claude-code/
• (a) No. (b) Partial only in the crudest sense — a fixed P0/P1 severity filter. (c) No.

"Entire CLI" (experts, judge)

UNVERIFIED — I could not find any product named "Entire" with experts or judge features in public search. Either the name differs, or it is unindexed/private. The nearest public analogues are Cursor's selectable effort levels and public benchmark harnesses (SWE-bench Verified, Terminal-Bench 2.0) used as judges.

Summary of the three probes across all incumbents

No incumbent found in this pass ships (a). None ships (b) as a per-task-class policy engine. None ships (c) as a first-class record.

Q6. Size of the wave

Share of code written by AI

• Microsoft: Satya Nadella, April 2025 — 20–30% of code in Microsoft repos is AI-generated. https://www.entrepreneur.com/business-news/ai-is-taking-over-coding-at-microsoft-google-and-meta/490896
• Google: Sundar Pichai, late 2024 earnings call — ~30%. One 2026 tracker reports Google stating 75% of all new code AI-generated and approved by engineers as of April 2026 — UNVERIFIED against a primary Google statement: https://www.secondtalent.com/resources/how-much-software-written-by-ai/
• Meta: ~30%, with a stated 50%-by-2026 expectation (same Entrepreneur source).
• Anthropic: Dario Amodei projected 80–90% (March 2025); Boris Cherny (head of Claude Code) put it at 80% on the Latent Space podcast, and in a January 2026 post said 100% of his own code and "pretty much 100%" company-wide is AI-written (he shipped 22 PRs in one day, 27 the day before) — while adding that humans still direct and review. Reported: https://dc.fortune.com/2026/01/29/100-percent-of-code-at-anthropic-and-openai-is-now-ai-written-boris-cherny-roon Skeptical read: https://kevinkuipers.substack.com/p/the-80-ai-coding-stunt-clever-probably
• Definitional caveat that matters: "AI-written" variously means accepted completions, agent-generated diffs, or human-approved agent output. These are directional, not comparable.

Users and revenue

• GitHub Copilot: passed 20M users in 2025; Microsoft now reports >26M; 90% of the Fortune 100. Secondary aggregation — UNVERIFIED against a primary Microsoft disclosure for the 26M figure.
• OpenAI Codex: near-zero mid-2025 → >2M weekly active developers (March 2026) → 3M+ weekly (April 2026); switched to token-based credit billing 2026-04-02. https://en.wikipedia.org/wiki/OpenAI_Codex_(AI_agent) , https://thenewstack.io/openai-codex-claude-code/
• Cursor (Anysphere): crossed $2B annualized revenue March 2026 (from $1B in Nov 2025); >7M MAU, >1M DAU, 50,000+ paying teams. Reported April 2026 talks at a $50B valuation; SpaceX closed a $60B all-stock acquisition of Cursor in mid-August 2026 — UNVERIFIED, this last item is significant enough that it should be confirmed against a primary source before use. https://en.wikipedia.org/wiki/Cursor_(company)
• Claude Code: $1B annualized within ~6 months of May 2025 GA; $2.5B ARR by Feb 2026; ~$8B by May 2026; Menlo Ventures puts enterprise AI-coding share at 54%; $1M+ enterprise accounts doubled 500+ (Feb 2026) → 1,000+ (May 2026). Most load-bearing single number for Panout: SemiAnalysis attributes ~4% of all public GitHub commits to Claude Code, projecting >20% by end of 2026. All via secondary aggregation — https://aibusinessweekly.net/p/claude-code-statistics , https://serpsculpt.com/claude-code-usage-statistics/ — UNVERIFIED against Anthropic or SemiAnalysis primary publications.
• Pricing convergence: Codex, Cursor and Claude Code all cap top individual plans at $200/month in 2026; agentic usage adds $200–$2,000+/engineer/month in token costs versus the $20–60 completion era. https://www.agensi.io/learn/ai-coding-agent-costs-compared-2026

GitHub-wide volume

Measured directly today rather than cited: >5.8M merged PRs on codex/* branches and >1.49M merged PRs from app/copilot-swe-agent alone (see Q1a). A total annual GitHub PR/commit figure for 2026 (Octoverse-equivalent) was not located in this pass — UNVERIFIED.

Confidence summary

Strongest, directly measured: Q1a population counts and Q1b review-depth samples — these are my own measurements against the GitHub API and are reproducible today. But read Sample E before using Q1b: the zero-review rate on agent PRs in popular repos is not meaningfully different from the all-PR baseline. The defensible measured claim is about merge latency, not about review counts.

Strong, well-sourced secondary: Q2c aggregates (DORA, GitClear, Veracode, METR), Q5 product capabilities (mostly vendor docs and changelogs), Q4 comparables.

Weakest: Q2a named incidents beyond Amazon (mostly blog aggregation), Q3 (the honest finding is negative — nobody is asking for code-authorship provenance yet), and the Q6 revenue/user figures, which are almost entirely third-party estimates.