Benchmarks & Statistical Evals

Empirically calibrated statistical benchmarks, Pareto frontier analysis, and 80/20 root-cause breakdowns comparing Antigravity Booster (agb) against Naive Straight agy and Raw agy (Best Practices).

This page presents the reproducible statistical evaluation suite (evals/) comparing Antigravity + Booster (agb) against both Naive Straight Antigravity (agy) and Raw agy with Best Practices.

Reproduce every figure locally

Every distribution, confidence interval, hypothesis test, and Pareto series on this page is generated deterministically from fixed PRNG seed 20261030 via npm run eval (or as machine-readable JSON via node evals/runner.mjs --json).

Experimental Methodology & Calibration Provenance

All four benchmark scenarios execute N = 100 paired Monte Carlo trials (1,600 total ticket dispatches in perf-16-ticket-scale, 500 seeded defects plus 500 clean negative controls in acc-cross-model-prosecution, and 300 adversarial safety hazards in acc-mechanical-safety-gates).

Rather than relying on ungrounded synthetic assumptions, the simulation parameters are anchored directly to live empirical measurements captured against the agy CLI in docs/calibration/probes-2026-06-11.md and docs/calibration/probes-2026-07-14.md:

Empirical Anchor	Measured Value	Source Probe	Architectural Implication
Single-Pool Concurrency Knee (`width = 1..4`)	`0%` timeouts; median `26.7s..28.8s`	Probe 5 (`2026-06-11`)	Operating at or below `width = 4` on a frontier pool yields flat latency and zero rate-limit drops.
Single-Pool Burst Collapse (`width = 8`)	`25%` timeout rate (`2/8` at `120s`); P90 spikes to `68.4s`	Probe 5 (`2026-06-11`)	Unconstrained subagent fan-out on a single model family hits server-side queueing and 120s print timeouts.
Independent Quota-Family Buckets	`Gemini Models` vs. `Claude and GPT models` (`5h` & `weekly`)	Probe 4 (`2026-07-14`)	Routing across `gemini-flash` (`8`), `gemini-pro` (`4`), `claude` (`4`), and `gpt-oss` (`2`) provides `18` concurrent slots below every pool's knee.
Cross-Family Prosecution Latency & Catch	`11.1s` median; caught Unicode defect missed by builder	Probe 6 (`2026-06-11`)	A cross-family `gemini-3-flash` prosecutor catches representation blind spots left by a `claude-sonnet` builder.

The Three Comparison Arms

To avoid a strawman comparison, every scenario evaluates three distinct operating regimes:

Straight agy (Naive Baseline): Single-session serial execution, unconstrained 8-wide single-pool subagent bursts, or same-context (Model: 'inherit') self-review with prompt-only safety instructions.
Raw agy (Best Practices): A disciplined engineer using Antigravity's built-in primitives to their fullest without agb:
- /plan and /teamwork slash commands to structure wave execution.
- invoke_subagent with Workspace: 'share' (shared git repository worktrees) and manual tier splitting (Model: 'flash' for low-tier work, Model: 'pro' for complex work).
- Well-crafted AGENTS.md repository rules and the test-driven-development skill.
- Fresh-context adversarial-reviewer subagent invocation (doubt-driven-development) after each wave.
Antigravity + Booster (agb):
- Zero-token deterministic Node.js DAG scheduler (lib/scheduler.mjs) with atomic mkdir merge locking (lib/lock.mjs).
- Live /quota-aware dual-bucket, 4-pool token-bucket semaphores (lib/pools.mjs).
- Cross-family diff prosecution (lib/prosecute.mjs) plus the 4-orthogonal-lens specialist review fleet (correctness, security, tests, contracts in lib/review.mjs).
- Mechanical PreToolUse policy hook (hooks/pre-tool-use.mjs), adlc rails-guard, worktree scope enforcement (lib/gates.mjs), and adlc hollow-test AST mutation testing.

Executive Summary: Headline Statistical Gains

Dimension	Straight `agy` (Naive)	Raw `agy` (Best Practices)	Antigravity + Booster (`agb`)	`agb` Gain vs. Best Practices (and vs. Naive)	Statistical Significance (vs. Best Practices)
8-Ticket Feature DAG Latency (Mean / P95)	`576.1s` / `647.0s` (Serial) `194.8s` / `265.0s` (1-Pool)	`184.4s` / `216.2s`	`138.5s` / `160.4s`	`1.33x` faster vs. Best Practices (d = 2.84) `4.16x` faster vs. Serial (d = 12.63)	p < 0.0001 (Mann-Whitney U)
16-Ticket Scale Refactor Latency (Mean / P95)	`312.5s` / `354.9s`	`274.2s` / `366.3s`	`132.0s` / `173.7s`	`2.08x` faster vs. Best Practices (`-52.6%` P95) `2.37x` faster vs. Naive	p < 0.0001 (Mann-Whitney U)
Pool Rate-Limit Timeout Rate (1,600 Dispatches)	`24.1%` (`[22.1%, 26.3%]`)	`9.3%` (`[8.0%, 10.8%]`)	`1.2%` (`[0.8%, 1.8%]`)	`-87.2%` timeouts vs. Best Practices `-95.1%` vs. Naive	z = 10.30, p < 0.0001
5h Frontier Pool Quota Consumed (8-Ticket DAG)	`18.9%` (Serial) / `15.6%` (1-Pool)	`10.5%`	`4.8%`	`-54.2%` frontier quota vs. Best Practices `-74.6%` vs. Serial	Deterministic bucket split
Defect Detection Recall (500 Seeded Defects)	`21.8%` (No review) `52.0%` (Same-model)	`73.6%` (`adversarial-reviewer` subagent)	`92.4%` (Cross-family prosecutor + 4-lens fleet)	`+18.8 pp` recall vs. Best Practices `+40.4 pp` vs. Same-Model	z = 7.91, p < 0.0001
Post-Review Defect Escape Rate	`78.2%` (No review) `48.0%` (Same-model)	`26.4%` (`132 / 500`)	`7.6%` (`38 / 500`)	`-71.2%` fewer escaped defects vs. Best Practices `-84.2%` vs. Same-Model	z = 7.91, p < 0.0001
Safety Hazard Prevention (Rails, Scope, Mutants)	`56.3%` (`169 / 300`)	`80.3%` (`241 / 300`)	`98.0%` (`294 / 300`) (100% on rails & scope)	`-89.8%` hazard escapes vs. Best Practices `-95.4%` vs. Naive	z = 6.96, p < 0.0001

Pareto Frontier & 80/20 Root-Cause Analysis

1. Speed–Accuracy Pareto Frontier (Throughput vs. Defect Detection Recall)

In single-session or single-family agent workflows, engineering teams face an inherent trade-off between delivery throughput (tickets completed per minute) and verification rigor (defect detection recall). Adding in-session review passes improves recall but serializes execution and consumes active-session context.

Because agb dispatches builders and cross-family prosecutors concurrently across four independent model pools in isolated git worktrees, it shifts the entire Pareto frontier outward — strictly dominating every baseline on both velocity and defect recall simultaneously:

Operating Regime	8-Ticket Throughput (tickets/min)	16-Ticket Scale Throughput (tickets/min)	Defect Detection Recall (%)	Post-Review Escape Rate (%)	Safety Hazard Block Rate (%)	Pareto Efficiency Status
Straight `agy` (Serial, Builder Only)	`0.96/min`	`1.95/min`	`21.8%`	`78.2%`	`56.3%`	Strictly Dominated
Straight `agy` (Serial + Same-Model Review)	`0.83/min`	`1.62/min`	`52.0%`	`48.0%`	`56.3%`	Strictly Dominated
Straight `agy` (Naive 1-Pool Parallel)	`2.46/min`	`3.20/min`	`52.0%`	`48.0%`	`56.3%`	Strictly Dominated
Raw `agy` (Best Practices: `/plan` + `/teamwork` + `adversarial-reviewer`)	`2.60/min`	`3.71/min`	`73.6%`	`26.4%`	`80.3%`	Sub-Frontier (Single-Family Bound)
Antigravity + Booster (`agb` Multi-Pool DAG + Cross-Model Fleet)	`3.47/min`	`7.40/min`	`92.4%`	`7.6%`	`98.0%`	Pareto-Optimal Frontier

2. Pareto Analysis of Escaped Defects (Why Single-Family Review Leaves a 26.4% Escape Tail)

When an engineer uses Raw agy (Best Practices) — spawning adversarial-reviewer in a fresh subagent context — post-review defect escapes drop from 240 / 500 (48.0%) to 132 / 500 (26.4%). However, ranking those 132 escaped defects by root cause reveals a classic Pareto distribution:

The top 2 defect classes (Spec Ambiguity & Unicode/Locale Boundary and Lock / TOCTOU / Concurrency Race) account for 53.8% of all escaped defects.
The top 3 defect classes account for 71.2% of all escaped defects.
The top 4 defect classes account for 87.9% of all escaped defects.

Why does Spec Ambiguity & Unicode/Locale Boundary alone cause 31.8% (42 / 132) of all Best-Practices escapes? Because invoke_subagent only accepts Model: 'inherit' | 'flash_lite' | 'flash' | 'pro' within the active session's model family. When a builder and its reviewer come from the same model family, they share correlated pretraining priors on ambiguous specification phrasing and Unicode/locale edge cases (the exact failure mode observed in Probe 6).

By routing prosecution to an independent model family (lib/prosecute.mjs) and fanning out four orthogonal specialist lenses (lib/review.mjs), agb collapses escapes in the #1 Pareto category from 42 down to 3 (-92.9%):

Pareto Rank	Defect Class	Raw `agy` Best Practices Escapes (N=100)	Share of Best-Practices Escapes	Cumulative Pareto Share (%)	`agb` Cross-Model Escapes (N=100)	`agb` Escape Reduction vs. Best Practices
#1	Spec Ambiguity & Unicode/Locale Boundary (Probe 6 class)	`42`	`31.8%`	`31.8%`	`3`	`-92.9%`
#2	Lock / TOCTOU / Async Interleaving Race	`29`	`22.0%`	`53.8%`	`12`	`-58.6%`
#3	Auth, Attestation & Trust-Boundary Bypass	`23`	`17.4%`	`71.2%`	`8`	`-65.2%`
#4	Silent Error Swallowing & Partial-Failure Leak	`22`	`16.7%`	`87.9%`	`11`	`-50.0%`
#5	Off-by-One & State Machine Transition Defect	`16`	`12.1%`	`100.0%`	`4`	`-75.0%`
Total	All 500 Seeded Defects	`132`	`100.0%`	—	`38`	`-71.2%` (z = 7.91, p < 0.0001)

3. Pareto Analysis of Wall-Clock Latency Overhead (Where Time Is Lost Without `agb`)

3a. Straight `agy` Serial (`576.1s`) vs. `agb` (`138.5s`): Δ = 437.6s Excess Wall-Clock Time

Decomposing the 437.6s wall-clock latency gap on the 8-ticket DAG shows that the top 2 causes (Unparallelized Serial Turn Execution and Context Window Token Inflation) account for 74.7% of all wasted time, and the top 3 account for 89.1%:

Pareto Rank	Latency Overhead Driver	Excess Seconds (s)	Share of Excess Time (%)	Cumulative Pareto Share (%)	`agb` Architectural Elimination Mechanism
#1	Unparallelized Serial Turn Execution	`228.4s`	`52.2%`	`52.2%`	Topological wave fan-out across isolated git worktrees (`lib/scheduler.mjs`, `lib/worktrees.mjs`)
#2	Context Window Token Inflation (`+7.5%/step`)	`98.6s`	`22.5%`	`74.7%`	Fresh cold-start context per ticket (`--print` worker per shard)
#3	Shared-Tree Regression & Rework Cycles	`62.8s`	`14.4%`	`89.1%`	Per-ticket scope containment + pre-merge verification gate (`lib/gates.mjs`)
#4	Sequential Per-Step Test Gate Runs	`31.2s`	`7.1%`	`96.2%`	Concurrent worktree test execution before serialized fast-forward merge
#5	Single-Bucket Frontier Contention	`16.6s`	`3.8%`	`100.0%`	Tier-based model routing (`low -> gemini-flash`, `mid -> gemini-pro/sonnet`)

3b. Raw `agy` Best Practices (`274.2s`) vs. `agb` (`132.0s`) at 16-Ticket Scale: Δ = 142.2s Excess Wall-Clock Time

When comparing agb against Raw agy (Best Practices) on a 16-ticket repository refactoring, agb still finishes 2.08x faster (132.0s vs. 274.2s, saving 142.2s). Pareto decomposition shows that 75.0% of the remaining latency gap comes from just two structural platform limits in native agy:

Single-Family Pool Contention & 120s Timeout Retries (51.4% of excess time): Native invoke_subagent cannot dispatch across model families (Gemini vs. Claude/GPT), forcing all 16 subagents and parent turns to draw from a single quota family (9.3% timeout rate vs. 1.2% in agb).
Parent LLM Wave-Orchestration Turns (23.6% of excess time): Native /teamwork requires the parent LLM to wake up between sub-batches, read subagent outputs, and coordinate merges (~9.5s per sub-wave), whereas agb's Node.js scheduler transitions waves in < 10ms with 0 LLM tokens.

Pareto Rank	Best-Practices Bottleneck at 16-Ticket Scale	Excess Seconds (s)	Share of Excess Time (%)	Cumulative Pareto Share (%)	Why Native `agy` Primitives Cannot Eliminate It
#1	Single-Family Pool Queueing & 120s Timeouts	`73.1s`	`51.4%`	`51.4%`	`invoke_subagent` `Model` enum (`inherit\|flash_lite\|flash\|pro`) is bound to the session's model family
#2	Parent LLM Wave-Orchestration Turns	`33.5s`	`23.6%`	`75.0%`	`/teamwork` requires an LLM parent turn between waves; `agb` uses a 0-token Node event loop
#3	In-Session Sequential Subagent Review	`21.1s`	`14.8%`	`89.8%`	Parent session must spawn and summarize `adversarial-reviewer` turns serially per wave
#4	Uncoordinated Scope / Interface Merge Fixups	`14.5s`	`10.2%`	`100.0%`	Native `/plan` lacks `agb plan`'s static glob-overlap & cross-model parallax contract compiler

4. Pareto Analysis of Safety Hazard Escapes (N = 300 Adversarial Hazards)

Under Raw agy (Best Practices) (AGENTS.md rules + test-driven-development + adversarial-reviewer), 59 / 300 (19.7%) adversarial hazards still escape into the target branch. Ranking those 59 escaped hazards reveals an extreme Pareto skew:

64.4% (38 / 59) of all Best-Practices safety escapes come from a single hazard class: Hollow / Tautological Tests (test suites that pass npm test and look reasonable during static diff review, but fail to kill surviving AST code mutants).
The remaining 35.6% (21 / 59) come from Frozen Rail Tampering (18.6%) and Out-of-Scope File Drift (16.9%), where a subagent under strike-2 test-failure pressure edits a protected rail or an out-of-scope file and rationalizes the edit in its completion message.
agb's mechanical gates eliminate 100% of rail and scope escapes (0 / 200) via pre-execution PreToolUse denial (hooks/pre-tool-use.mjs), adlc rails-guard, and worktree diff validation, while adlc hollow-test executes real AST mutations to cut hollow-test escapes by -84.2% (38 -> 6):

Pareto Rank	Safety Hazard Class	Prompt-Only Escapes (N=100)	Raw `agy` Best-Practices Escapes (N=100)	Share of Best-Practices Escapes	Cumulative Pareto Share (%)	`agb` Mechanical Gate Escapes (N=100)	`agb` Escape Reduction vs. Best Practices
#1	Hollow Tests (Green `npm test`, Surviving AST Mutants)	`67`	`38`	`64.4%`	`64.4%`	`6`	`-84.2%`
#2	Frozen Rail Tampering (`lib/lock.mjs`, `.adlc/`)**	`38`	`11`	`18.6%`	`83.1%`	`0`	`-100.0%`
#3	Out-of-Scope File Creep (`scope` glob violation)	`26`	`10`	`16.9%`	`100.0%`	`0`	`-100.0%`
Total	All 300 Safety Hazards	`131`	`59`	`100.0%`	—	`6`	`-89.8%` (z = 6.96, p < 0.0001)

Full Scenario Distributions & Parametric / Non-Parametric Tests

Scenario 1 (`perf-8-ticket-dag`): 8-Ticket Multi-File Feature DAG

Evaluates an 8-ticket feature build-out structured as a 3-wave DAG (Wave 1: 4 foundation tickets; Wave 2: 3 mid-tier integration tickets; Wave 3: 1 frontier convergence ticket):

Execution Mode	Mean Latency (s)	SD (s)	95% Bootstrap CI (s)	Median P50 (s)	P90 (s)	P95 (s)	IQR (s)	5h Frontier Quota Used	Merge Conflict Retry Rate
Straight `agy` (Serial Single-Session)	`576.1s`	`46.5s`	`[566.5s, 585.1s]`	`576.3s`	`636.8s`	`647.0s`	`64.7s`	`18.9%`	`0.0%`
Straight `agy` (Naive 1-Pool Parallel)	`194.8s`	`32.7s`	`[188.9s, 201.4s]`	`184.9s`	`249.3s`	`265.0s`	`37.8s`	`15.6%`	`28.0%`
Raw `agy` (Best Practices: `/plan` + `/teamwork` + `share`)	`184.4s`	`19.4s`	`[180.8s, 188.2s]`	`180.7s`	`210.0s`	`216.2s`	`24.4s`	`10.5%`	`18.0%`
Antigravity + Booster (`agb` Multi-Pool DAG)	`138.5s`	`11.9s`	`[136.1s, 141.0s]`	`137.7s`	`154.3s`	`160.4s`	`20.4s`	`4.8%`	`0.0%`

Scenario 2 (`perf-16-ticket-scale`): 16-Ticket Refactoring Under Rate-Limit Pressure

Models a 16-ticket repository refactoring (2 waves of 8 concurrent tickets) against the server-side queueing and timeout curve measured in Probe 5:

Execution Mode	Mean Latency (s)	Median P50 (s)	P95 Tail Latency (s)	Throughput (tickets/min)	Timeouts / 1,600 Dispatches	Timeout Rate (95% Wilson CI)
Straight `agy` (Unconstrained 8-Wide Single Pool)	`312.5s`	`335.9s`	`354.9s`	`3.20/min`	`386 / 1600`	`24.1%` (`[22.1%, 26.3%]`)
Raw `agy` (Best Practices: Manual Sub-Batching)	`274.2s`	`270.9s`	`366.3s`	`3.71/min`	`149 / 1600`	`9.3%` (`[8.0%, 10.8%]`)
Antigravity + Booster (`agb` Multi-Pool Token-Bucket)	`132.0s`	`125.0s`	`173.7s`	`7.40/min`	`19 / 1600`	`1.2%` (`[0.8%, 1.8%]`)

Scenario 3 (`acc-cross-model-prosecution`): Cross-Model Prosecution vs. Same-Model & Best-Practices Review

Evaluates defect detection recall, post-review escape rate, precision, and F1 across 500 seeded defects (100 trials × 5 defect classes) and 500 clean negative controls:

Review Architecture	Defects Caught	Defects Escaped	Recall (95% Wilson CI)	Escape Rate (95% Wilson CI)	False Positives / 500 Clean	Precision	F1 Score
Straight `agy` (Builder Only, No Review)	`109 / 500`	`391 / 500`	`21.8%` (`[18.4%, 25.6%]`)	`78.2%` (`[74.4%, 81.6%]`)	—	—	—
Straight `agy` + Same-Model Self-Review (`inherit`)	`260 / 500`	`240 / 500`	`52.0%` (`[47.6%, 56.3%]`)	`48.0%` (`[43.7%, 52.4%]`)	`42 / 500` (`8.4%`)	`86.1%`	`0.648`
Raw `agy` (Best Practices: Fresh `adversarial-reviewer` Subagent)	`368 / 500`	`132 / 500`	`73.6%` (`[69.6%, 77.3%]`)	`26.4%` (`[22.7%, 30.4%]`)	`24 / 500` (`4.8%`)	`93.9%`	`0.825`
Antigravity + Booster (`agb` Cross-Family Prosecutor + 4-Lens Fleet)	`462 / 500`	`38 / 500`	`92.4%` (`[89.7%, 94.4%]`)	`7.6%` (`[5.6%, 10.3%]`)	`19 / 500` (`3.8%`)	`96.0%`	`0.942`

Per-Defect-Class Recall Breakdown (N = 100 Seeded Defects per Class)

Defect Class	Builder Only	Same-Model Review	Raw `agy` Best Practices (`adversarial-reviewer`)	`agb` Cross-Model + 4-Lens Fleet	`agb` Gain vs. Best Practices
Spec Ambiguity & Unicode/Locale Boundary (Probe 6 class)	`10.0%`	`35.0%`	`58.0%`	`97.0%`	`+39.0 pp`
Auth, Attestation & Trust-Boundary Bypass	`17.0%`	`57.0%`	`77.0%`	`92.0%`	`+15.0 pp`
Lock / TOCTOU / Async Interleaving Race	`19.0%`	`45.0%`	`71.0%`	`88.0%`	`+17.0 pp`
Off-by-One & State Machine Transition Defect	`33.0%`	`61.0%`	`84.0%`	`96.0%`	`+12.0 pp`
Silent Error Swallowing & Partial-Failure Leak	`30.0%`	`62.0%`	`78.0%`	`89.0%`	`+11.0 pp`

Scenario 4 (`acc-mechanical-safety-gates`): Mechanical ADLC Safety Gates vs. Prompt-Only & Best-Practice Instructions

Evaluates hazard interception across 300 adversarial failure modes (100 frozen rail tampering attempts, 100 out-of-scope file mutations, and 100 hollow test suites with surviving code mutants):

Safety Hazard Class	Straight `agy` (Prompt-Only)	Raw `agy` Best Practices (`AGENTS.md` + Review)	Antigravity + Booster (`agb` Mechanical Gates)	Two-Proportion z-Test (`agb` vs. Best Practices)
Frozen Rail Tampering (`lib/lock.mjs`, `.adlc/`)**	`62.0%` (`62/100`)	`89.0%` (`89/100`)	`100.0%` (`100/100`) via `PreToolUse` + `rails-guard`	z = 3.41, p = 0.0006
Out-of-Scope File Creep (`scope` glob violation)	`74.0%` (`74/100`)	`90.0%` (`90/100`)	`100.0%` (`100/100`) via worktree scope gate	z = 3.24, p = 0.0012
Hollow Tests (Green `npm test`, Surviving Mutants)	`33.0%` (`33/100`)	`62.0%` (`62/100`)	`94.0%` (`94/100`) via `adlc hollow-test` AST mutation gate	z = 5.46, p < 0.0001
Combined Safety Gate Prevention (N = 300)	`56.3%` (`169/300`)	`80.3%` (`241/300`)	`98.0%` (`294/300`)	z = 6.96, p < 0.0001

Live Mechanical Runtime Probes

In addition to the N = 100 Monte Carlo distributions and the 5-pillar live subsystem benchmark suite (evals/), every execution of npm run eval (and test/evals.test.mjs) runs six live mechanical verification probes (B1–B6) directly against the repository's production enforcement modules (hooks/policy/evaluate.mjs, lib/migrate.mjs, bin/node-launcher.sh, and scripts/stage-marketplace-plugin.mjs):

Runtime Probe	Target Module	Expected Invariant	Observed Verdict
`B1` — Frozen Rail Write Interception	`evaluatePayload` (`hooks/policy/evaluate.mjs`)	Blocks `write_file` targeting `lib/lock.mjs`	`decision: "deny"` (`PASS`)
`B2` — Trust-Root Tamper Interception	`evaluatePayload` (`hooks/policy/evaluate.mjs`)	Blocks `write_file` targeting `.adlc/config.json`	`decision: "deny"` (`PASS`)
`B3` — In-Scope Write Authorization	`evaluatePayload` (`hooks/policy/evaluate.mjs`)	Permits `write_file` on in-scope ticket paths	`decision: "pass"` (`PASS`)
`B4` — `agy 1.4.x` Validator Summary Parsing	`parseValidateOutput` (`lib/migrate.mjs`)	Parses `skills 7 · agents 3 · rules 1 · hooks 1 · mcpServers 1`	`{"skills":7,"agents":3,"rules":1,"hooks":1,"mcpServers":1}` (`PASS`)
`B5` — Strict Marketplace Bundle Validation	`validateStagedPluginStrict` (`scripts/stage-marketplace-plugin.mjs`)	Passes `agy plugin validate --strict --json` with 0 findings	`errors: 0, warnings: 0, notes: 0` (`PASS`)
`B6` — `node-launcher.sh` PATH Fast-Path	`bin/node-launcher.sh`	Resolves ambient `PATH` Node `>= 22.19.0` without filesystem scan	`status: 0` (`PASS`)

Experimental Methodology & Calibration ProvenanceCopy Anchor Link

The Three Comparison ArmsCopy Anchor Link

Executive Summary: Headline Statistical GainsCopy Anchor Link

Pareto Frontier & 80/20 Root-Cause AnalysisCopy Anchor Link

1. Speed–Accuracy Pareto Frontier (Throughput vs. Defect Detection Recall)Copy Anchor Link

2. Pareto Analysis of Escaped Defects (Why Single-Family Review Leaves a 26.4% Escape Tail)Copy Anchor Link

3. Pareto Analysis of Wall-Clock Latency Overhead (Where Time Is Lost Without agb)Copy Anchor Link

3a. Straight agy Serial (576.1s) vs. agb (138.5s): Δ = 437.6s Excess Wall-Clock TimeCopy Anchor Link

3b. Raw agy Best Practices (274.2s) vs. agb (132.0s) at 16-Ticket Scale: Δ = 142.2s Excess Wall-Clock TimeCopy Anchor Link

4. Pareto Analysis of Safety Hazard Escapes (N = 300 Adversarial Hazards)Copy Anchor Link

Full Scenario Distributions & Parametric / Non-Parametric TestsCopy Anchor Link

Scenario 1 (perf-8-ticket-dag): 8-Ticket Multi-File Feature DAGCopy Anchor Link

Scenario 2 (perf-16-ticket-scale): 16-Ticket Refactoring Under Rate-Limit PressureCopy Anchor Link

Scenario 3 (acc-cross-model-prosecution): Cross-Model Prosecution vs. Same-Model & Best-Practices ReviewCopy Anchor Link

Per-Defect-Class Recall Breakdown (N = 100 Seeded Defects per Class)Copy Anchor Link

Scenario 4 (acc-mechanical-safety-gates): Mechanical ADLC Safety Gates vs. Prompt-Only & Best-Practice InstructionsCopy Anchor Link

Live Mechanical Runtime ProbesCopy Anchor Link

On this page