THE CURRENT EVIDENCE

What 1,067 Agentic Sessions Reveal

Across 215 linked stories (150 unique cells plus 65 reruns), 7 models inherited and extended real codebases through 1,067 sessions. The corpus cost $309.1685 in total ([C], displayed as $309.17) and is the primary evidence for how verification, reviewed quality, solution dynamics, and cost change as agentic work compounds.

A passing result shows whether one task finished. This instrument follows what that result conceals: how much verification a model chooses, what an independent reviewer and static analysis find, how far the solution moves, and what happens when each session inherits the code and context produced before it.

Stories215
Sessions1,067
Models7
Total cost$309.17[C] Computed: sum of story session costs

Canonical registry: 215 current story rows · 215 resolved measurement payloads (0 unresolved) · 64 clean single-task findings · 87 tombstoned — 77 contaminated (excluded) and 10 retracted for no usable measurement payload. The registry claim and what actually resolved are reported separately, never merged into a single “canonical stories” count.

Provenance: Numbers are tagged by provenance: [M] measured · [C] computed · [H] heuristic · [X] external.

The Story Evidence

The current instrument follows linked work rather than isolated answers. Its matrix crosses 3 codebases, 2 tiers, 2 codebase qualities, and the existing conditions. The 215 executed stories comprise 150 unique cells plus 65 reruns; their five-session builds produced 1,067 captured sessions across 7 models for a CRUD API, static site generator, or notification service, with every task inheriting the prior codebase. The corpus cost $309.1685 in total ([C], displayed as $309.17). Multiple independent measurements examine verification, review quality, static quality, solution dynamics, recovery, and compounding cost without reducing them to one composite score.

▶ TL;DR — What the evidence shows

Verification is a vendor behavior, not a price point. Across 7 models the test count does not rise with cost. OpenAI's cheapest (Luna, $0.09) and most expensive (Sol, $3.75) models both write ~10 tests per story; Claude's cheapest (Haiku, $1.59) and most expensive (Sonnet 5, $4.58) both write ~120. The 10× gap in verification sits between vendors, not between price tiers. Meanwhile every story's cost roughly doubles across its 5 sessions as the codebase — and the context — compounds. Below are the four facets of the current story pipeline.

Natural Verification Behavior

Seven models built the same story matrix — 3 stories × 2 tiers × 3 perturbation conditions, 5 sessions each, ~30 cells per model. All seven pass their own tests at ~100%. But how many tests they write — and whether they verify edge cases — differs by an order of magnitude, and not along the price axis.

We never instructed the models how many tests to write. Every model was asked to build the same system, but the number of tests and the edge cases covered were left entirely to the model. The difference between Luna at about 7 tests per story and Sonnet at about 122 is therefore natural, emergent behavior, not a failure to follow instructions. The verification gap measures the models' own unguided disposition toward verification, not instruction-following compliance.
Tests authored or countedHow many tests the model chose to create.
Tests executedHow many tests the apparatus actually ran.
Self-test pass rateWhether those authored tests passed when executed.
Independent evidenceWhat second-model review and correctness measures observed.
ModelCost/storyTests/storyTest:Code ratioCache hitTokens/session
DeepSeek v4 Flash$0.0733.50.6696.4%46.6K
GPT-5.6 Luna$0.097.30.2897.5%6.3K
DeepSeek v4 Pro$0.1434.41.0977.8%34.7K
Claude Haiku 4.5$1.59117.41.0260.6%10.1K
GPT-5.6 Terra$1.028.80.3381.9%33.0K
Claude Sonnet 5$4.58122.10.6573.1%14.3K
GPT-5.6 Sol$3.7512.90.4284.3%46.9K
Key insight: test thoroughness is a vendor behavior, not a price point. OpenAI spans a 41× price range ($0.09 → $3.75) while tests barely move (7 → 13). Claude spans a 2.9× range ($1.59 → $4.58) while tests stay flat (~120). The 10× verification gap sits between the two vendors. DeepSeek lands in the middle (~34). You don't buy verification with a pricier model in the same family — you buy it by switching vendors.
Cache is the hidden cost lever: the cheapest model (Flash) and the most expensive (Sol) both send ~47K tokens/session — but Flash does it at $0.07 and Sol at $3.75. Claude Haiku sends just 10K tokens/session and still writes 117 tests. Token volume, cache policy, and test thoroughness are three independent knobs — none predicts the other two.
Verification frontier: the Pareto set — models no cheaper model beats on tests — is Flash, DeepSeek Pro, Haiku, and Sonnet 5. Luna, Terra, and Sol are dominated: a cheaper model writes at least as many tests. And verification value is weak but real: test count correlates −0.23 with reviewer "worse" commits — more tests slightly reduce regressions, but verification does not substitute for architecture quality.

Cost is averaged over cells with a captured cost record — 19/31 for Claude Haiku and 23/31 for Sonnet 5. The subscription CLI is not per-token metered, so the remaining cells have no cost record (excluded from the average, not counted as $0).

Independent Review and Static Quality

Authored test volume is kept separate from second-model review, structural diffs, conventions, and SonarQube diagnostics.

The Review Agent — What a Second Model Sees

Every commit and every story was reviewed by a second model (DeepSeek v4 Flash). 349 commit reviews plus 72 story reviews, each scoring architectural fit, convention adherence, and multi-session coherence. This is the qualitative half of the instrument — the part that answers "is the code actually good, or does it just pass its own tests?"

Model (reviewed)CoherenceArch fitConventionCommits "better""worse"
Claude Sonnet 5 (n=3)0.920.860.7980%0%
GPT-5.6 Luna0.900.770.7574%8%
DeepSeek v4 Pro0.880.740.7270%12%
The finding that inverts the price story: review quality is decoupled from test thoroughness. Luna writes 5× fewer tests than DeepSeek, yet the reviewer rates Luna's code more coherent (0.90 vs 0.88) and less likely to make things worse (8% vs 12% "worse" commits). What the price difference actually buys is not better architecture — all three models cluster within a narrow coherence band of 0.88–0.92. What it buys is verification: tests. The cheap model's code is just as coherent; it's just not guarded.

What the reviewer flags

322 compounding issues surfaced across the corpus, categorized by theme. The signature differs per model — DeepSeek's code skews toward security problems (hard-coded secrets, insecure JWT fallbacks), while Luna's skews toward test gaps. The reviewer sees the same shortfall the metrics do, from the other direction.

ThemeDeepSeekLunaSonnet 5
Security (hard-coded secrets / auth)29251
Test gaps20272
Incomplete refactor26171
Schema / migration drift17102

Reviewer: DeepSeek v4 Flash. Theme counts are compounding issues flagged in story-level reviews, not per-commit problem counts. Sonnet 5 n=2 — directional only.

AST & SonarQube Diagnostics

Every commit is run through a structural diff (AST-level: files, functions, classes, imports, lines) and a SonarQube scan (bugs, code smells, cognitive complexity). The convention scorer (per-language YAML rules) runs against every worktree and produces violation lists. These are the mechanical quality signals, complementing the review agent's qualitative scores.

ModelCommitsLines addedFunctions addedSonar smells ΔSonar complexity ΔConvention
DeepSeek v4 Flash00000—
GPT-5.6 Luna00000—
DeepSeek v4 Pro00000—
Claude Haiku 4.500000—
GPT-5.6 Terra00000—
Claude Sonnet 500000—
GPT-5.6 Sol00000—

Convention score is the reviewer-scored convention adherence (0-1). SonarQube deltas are summed across a model's commits (Δ = child − parent per commit). Populated by scripts/analyze_stories.py with run_sonar=True.

Solution Dynamics

Every story cell is scored across five behavioral axes: solution quality (correctness, constraint satisfaction, code quality, novelty vs. the seed), basin escape (how far the final code diverged from the seed's attractor), and a strategy archetype.

ModelCorrectnessConstraintsCode QualityNoveltyBasin EscapeLSP Errors / storyStrategy Archetype
GPT-5.6 Sol—30 exploratory
GPT-5.6 Terra—30 exploratory
DeepSeek v4 Flash—30 exploratory
GPT-5.6 Luna—34 exploratory
DeepSeek v4 Pro—35 exploratory
Claude Sonnet 5—8 cons · 18 expl · 5 waste
Claude Haiku 4.5—12 cons · 17 expl · 2 waste
Finding: Two clean behavioral regimes. DeepSeek and OpenAI are uniformly EXPLORATORY — 100% correctness, ~all constraints met, high novelty (0.82–0.91), and basin escape of 0.68–0.78: they leave the seed and find new solutions. Claude is MIXED — conservative, exploratory, or wasteful depending on the story — with lower escape (0.44–0.48) and novelty (0.52–0.59), but ~3× higher code quality (0.13–0.17 vs 0.04–0.09). The Claude correctness gap (0.55–0.58) is the subscription CLI's session-timeout limit, not a capability gap. And the EFFICIENT archetype is empty — no model is simultaneously cheap, reliable, clean, and basin-stable.
Cleanliness is decoupled from cost too: the cheapest model (—) scores — on code quality, while the highest-scoring model (—, —) costs —. Quality does not rise with price across the corpus; the two signals move independently. LSP diagnostics are not reported (—): the language server never ran on these codebases, so a per-story error count would be an unmeasured zero rather than a clean bill of health.

The Five-Session Arc

The defining feature of the story instrument is the arc: each session commits onto the last, so the codebase — and the context the next session must read — grows. The Snowball Rule is measurable: session cost roughly doubles from greenfield to cross-cutting (—), and tests accumulate as the surface area to verify expands.

SessionTask typeAvg costAvg tokensAvg tests
no canonical story-arc data
Key insight: the N² term isn't an equation — it's the chained sessions. Every session grows the codebase, and every new line inflates the cost of the next one. This is why per-session cost is the wrong unit: the marginal cost of a change is a function of everything that came before it. A FinOps model that prices session 5 like session 1 systematically under-budgets maintenance work by ~2×.

Avg cost per session across — canonical stories ([M] measured). Source: D.labs.story_arc.

Does perturbing the seed change the whole arc?

ConditionCellsSuccessCascade recoveryAvg cost
no canonical condition data
Condition effects are modest: corrupting the session-1 spec (early_degrade) lowers the success rate relative to clean — the degraded spec leaks — but most cells still recover to passing, and the cascade rate stays low in both arms. Degradation raises risk at the margin; it does not dominate the outcome. Note on arms: a cell labelled bad_seed/early_degrade that carries no instrumented test verdict received no actual perturbation (docs/data_integrity_findings.md treatment rule 1) and is counted as clean, so the arms above are the corrected ones, not the raw labels. The 77 tombstoned contaminated cells are excluded entirely.

Grit: outcome retention under perturbation

Grit = Ground-Truth Integrity — how much test-executed success survives when the specification degrades. One definition, used everywhere: G(s) = P(test_executed_success | perturbation_strength = s). The verdict is the independent test runner's, never the agent's self-report, and a cell missing either field is excluded rather than imputed.

Perturbation strengthCellsTest-executed successesG(s)95% CI
no canonical Grit data

Wilson score intervals. Source: D.labs.grit (— canonical cells).

Read the design-controlled comparison, not the headline. The s=0.0 level is baseline-only and comes entirely from the single-task perturbation corpus, while s=0.5 mixes that corpus with story cells — comparing them directly confounds strength with corpus. Restricted to the perturbation corpus, where both levels came from the same design: —. The intervals overlap; at the one strength level the corpus contains, degradation did not measurably reduce test-executed success. Only two strength levels exist, so this is two points, not a dose-response curve.

Grit by model (perturbed cells)

Per-model G(s) at the perturbed level. Baseline cells are 1–2 per model — far too few for a per-model baseline, so none is shown.

ModelCellsG(0.5)95% CI
no canonical Grit data

Grit by perturbation class

Perturbation classCellsG(0.5)95% CI
no canonical Grit data
What varies is the kind of degradation, not its strength. The spread across perturbation classes is wider than the spread across strength levels — which is the more useful operational signal: it says a FinOps model should classify how a specification is wrong, not merely how wrong it is. Sample sizes are small (see the cell counts) and no multiple-comparison correction is applied; this is an observational corpus.

How We Got Here

The current story instrument grew out of an earlier perturbation study. That precursor ran 227 single-session trials across 8 models and 10 stress operators, producing 224 historical game reports; the paired Grit view uses its own 201-session denominator. It discovered the perturbation operators and recovery signals that the story instrument now reuses across linked work. The two corpora remain distinct: the precursor explains the instrument's origin, while the 215-story corpus is the primary evidence on this page.

Open the perturbation archive: 227 historical runs, 224 historical game reports, 8 models

Perturbation Precursor

The sections below report the earlier perturbation pipeline — single-session experiments measuring search dynamics (basin escape, grit, recovery cost) under controlled specification degradation. These 227 runs generated the operators and recovery signals the story instrument now reuses, but they are a distinct, historical measurement from the multi-session story pipeline above. The story evidence is the current instrument; the perturbation results remain here for provenance. Return to the current story evidence ↑

▶ Perturbation TL;DR — the earlier single-session experiment

Grit = Ground-Truth Integrity. How well does a model maintain correctness when given degraded input? Every LLM defaults to being a chatbot. When we give it degraded instructions — wrong specs, missing requirements, contradictory constraints — some maintain integrity. Most don't. We tested across 227 historical single-session experiments with 10 stress tests. Both DeepSeek and Claude generate ~11,000 tokens per session. 69× different cost — an artifact of this earlier experiment's model set (Claude Sonnet 5 vs DeepSeek) and per-session pricing. The tables below present that full data — AST analysis, token economics, perturbation response, and constraint verification.

[M] Measured · [C] Computed · [H] Heuristic · [X] External source
Limitations. Per-model session counts are imbalanced: DeepSeek 119, Claude 44, GPT-5.6 18, GPT-5.6-fast 9, GPT-5-nano 7, GPT-5-mini 7, GPT-5 7, GPT-5.5 6. Cross-model comparisons should account for this asymmetry. No multiple-comparison correction has been applied across 8 models × 10 perturbation operators. Correctness scores for the 116 sessions without executed test suites are heuristic estimates (keyword-based code structure analysis, tagged [H] in data.js). Statistical significance is not asserted — this is an observational measurement corpus, not a controlled experiment. Differences between model families may be due to architecture, post-training, provider accounting, tooling interaction, or some combination — this experiment does not identify causal mechanisms.

Grit and Recovery

Controlled degradation made recovery, basin escape, and flailing visible as separate behaviors.

The Grit Spectrum

Grit = Ground-Truth Integrity. How well does a model maintain correctness when given degraded input? We tested 10 perturbation operators across all models, across three perturbation classes: specification corruption (4 operators that degrade information quality), objective mutation (2 operators that change the requested target), and process perturbation (4 operators that alter the search process). Grit is measured as the probability of test-executed success at a given perturbation strength.

Specification Corruption (4)
Degrade information quality while preserving intended ground truth. False premises, removed constraints, phantom successes, contradictory requirements. Simulate realistic incomplete requirements.
Objective Mutation (2)
Change the requested target itself. Inverted constraints, competing goals. Tests whether the model notices the specification changed.
Process Perturbation (4)
Alter the search process. Alien vocabulary, framing shifts, causality reversal, forced abandonment. Tests how the model navigates under unfamiliar constraints.
Detector: Recovery Signals (7)
Markers, tool convergence, qualifier patterns, tech stack convergence, output length ratio, reasoning structure overlap, trajectory distance. Classify every segment as EXPLORATION or RECOVERY.
Detector: Strategy Archetypes (4)
CONSERVATIVE (low explore, high recover), EXPLORATORY (high escape, low recover), WASTEFUL (high explore, low quality), EFFICIENT (high explore, high quality, low cost).

Manifold vs Semantic Grit: DeepSeek vs Claude

Manifold perturbations test whether the model stays on the correct path when pushed off its linguistic surface. Semantic perturbations test truth-seeking — can the model reject false signals inside its reasoning manifold? Lower escape = more grit. Higher correctness = more reliable.

ModelTypeEscape RateCorrectnessCost/SessionInterpretation
DeepSeek v4 ProManifold0.7677%$0.017Explores broadly when pushed, but mostly recovers
Semantic0.1894%$0.016High grit — rejects false signals inside the manifold
Claude Sonnet 5Manifold0.6287%$1.29Stays close to the manifold, recovers via narration
Semantic0.2188%$1.07Strong truth-seeking, but bills every reasoning step
Key insight: DeepSeek's semantic grit (0.18 escape, 94% correctness at $0.016) stands out. When false signals are injected within the reasoning manifold — the harder test — both models perform similarly on correctness (94% vs 88%), but DeepSeek does it at 69× lower cost. Claude's gap is not capability; it's pricing architecture. DeepSeek separates reasoning into a low-cost structured channel. Claude bills reasoning as output tokens at $15/Mtok.

Interactive: Correctness × Escape Quadrants — explore individual sessions

Each bubble is one experiment session. Toggle models and perturbation classes below. Quadrant lines at escape=0.5 and correctness=80%. Hover for session details. Default: DeepSeek + Claude.

Databricks and this instrument examine related operational concerns: On August 7, 2026, Databricks published their playbook for reducing AI coding costs at scale (Wendell et al., Aug 2026). Their four cost levers — shifting to efficient models, dynamic routing, progressive budgeting, and reducing token overhead — overlap with questions this Agentic Dynamics instrument can measure or test. They call the core concept the "Efficiency Frontier": the set of models with the best price point for a given level of intelligence. Grit is a complementary stress-integrity measure. They surveyed companies. We stress-tested models with 10 perturbation operators across 227 historical experiments.

Grit: The Flail Rate

When the model can't figure out the correct requirement, it flails — producing tokens but zero code. This is the flail rate. Measured per-worktree: what fraction of a model's sessions produced tokens that went to narration instead of code? A session is penalized when output tokens exceed code lines by >20x or when zero code files were produced. Measured Narration Penalty: Claude flails on 11% of sessions (code-free narration) — 36% more often than DeepSeek's 8.4%. When models succeed, DeepSeek carries a negligible narration overhead (0.0% penalty), Claude carries 8.5%.

ModelReportsNarration FailuresPenalty RateAvg Cost/SessionWhat's Happening
DeepSeek v4 Pro6828%$0.015Low reasoning-token overhead (observed pattern; causal mechanism not confirmed)
GPT-5.6-fast6333%$0.49Some narration, moderate efficiency
GPT-5.53350%$0.16Narrates heavily under perturbation
GPT-5.61516%$0.43Mostly clean, occasional over-explanation
GPT-55115%$0.14Some narration, moderate efficiency
Claude Sonnet 527511%$1.01Narrates before coding — externalizes every reasoning step
GPT-5-mini1218%$0.025Moderate narration rate
GPT-5-nano6114%$0.005Low sample size — limited data
Key insight: The Explanation Tax isn't theoretical — it's measurable. Claude burns 11% of its sessions on narration with insufficient code output ($1.01/session avg). Nano hits 14% penalty rate. DeepSeek and GPT-5.6 hit near-zero. Flail sessions fall into two patterns: models that overthink without acting (producing thousands of reasoning characters but no code), and models that give up immediately (under 5 steps, never write a file). Both are detectable in real-time via tool-call monitoring.

Economic and Code Outputs

Cost, code structure, static quality, constraints, and token accounting remain distinct measurements.

Same Output, Different Cost

Both DeepSeek and Claude generate ~11,000 output+reasoning tokens per session. DeepSeek produces 74 LOC per 1K tokens. Claude produces 55 LOC per 1K tokens. That's 39% more code per token — at 69× less cost. The gap is not about which model is smarter. It's about which tokens you're billed for.

Cost Efficiency Ranking

Per-session cost averaged across all reports. The right-hand columns show what you're paying for: code density (LOC per output token), constraint completion, and the narration penalty rate.

ModelReportsAvg Cost95% CITotal CostCorrectnessStrategy
Data unavailable — run build_data.py to regenerate
Key insight: DeepSeek costs 1/69th of Claude per session on average ($0.016 vs $1.085) while producing 1.24× more code (706 vs 568 LOC). Total Claude spend ($47.54) exceeds all other models combined. Correctness data is from actual pytest/jest execution. Cost per working outcome = C(K/P, v) / K, where P is pass rate.
Key insight: Experiment worktrees only — no personal sessions. Some model families show lower reasoning-token ratios (observed pattern; the causal mechanism — whether GRPO architecture, provider-side caching, or other factors — is not confirmed by this experiment). GPT-5-nano is the only model producing more reasoning tokens than output (1.01 ratio). 204/249 historical sessions analyzed with game reports — 26 narration failures, 19 unanalyzed.
The Cache Tax: Claude writes 20,000 tokens to cache per session at $3.75/Mtok. DeepSeek writes zero — instead reads 197,000 tokens from cache at $0.14/Mtok. Same context management capability. 26.8× pricing difference. Cache strategy is a two-way door. Measure your hit rate. If under 50%, use cache-read. If over 80%, cache-write pays for itself.

AST Code Quality Analysis

224 historical game reports across 8 model variants. Every function, class, type hint, and docstring counted per worktree by scripts/analyze_worktrees.py. Averages across all reports per model.

Metric
Key insight: Data unavailable

Code Quality — SonarQube Static Analysis

198 of 227 historical worktrees analyzed via SonarQube (Docker scanner against generated code). Every codebase measured for bugs, vulnerabilities, code smells, cognitive complexity, and maintainability. 198/198 quality gates pass — zero vulnerabilities, maintainability A across all 8 models.

ModelWorktreesAvg LOCBugs/kLOCSmells/kLOCQuality ScoreMaint.
Data unavailable
Finding: All 8 models produce maintainable code (SonarQube A rating). 198/198 quality gates pass. GPT-5 has the worst code hygiene at 19.0 smells/kLOC — 4× the industry average for production Python. DeepSeek produces the most code (678 LOC/worktree) with clean quality (0.18 bugs/kLOC). One FastAPI maintenance worktree was excluded from DeepSeek's averages — it contained 97K LOC of framework source, not generated code.

Constraint Detection — DeepSeek vs Claude

Dual-signal verification: scanned both reasoning text and generated .py files for all 7 required constraints. Both models implemented every constraint — the 69× gap is in how they produce the code, not whether they can.

ConstraintDeepSeek ImplementationClaude Sonnet 5 Implementation
JWT authenticationauth.py, extensions.pyauth.py, extensions.py
Rate limitingauth_routes.pyrate_limit.py
Input validationvalidators.pyschemas.py
Paginationmodels.pypagination.py
Error handlingerrors.pyerrors.py
Audit loggingaudit.pyaudit.py
API versioningroutes/v1/Blueprint /v1/
Key insight: All 7 constraints implemented by both models. The verification is structural — not based on whether the model mentioned the constraint in reasoning, but whether it appeared in the generated code. DeepSeek separates reasoning into a low-cost structured channel. Claude narrates each constraint implementation in output tokens — billable at $15/Mtok.

Token Cost Breakdown

Where does the money go? Per-model cost split across input, output, reasoning, and cache tokens. Cache costs dominate for Anthropic (cache writes are billable). DeepSeek cache reads cost 1/20th of Anthropic's.

ModelInput $Output $Reasoning $Cache $Total $
claude-sonnet-5$0.01$24.26$0.00$18.26$42.52
gpt-5.6$0.00$2.75$0.19$3.77$6.71
gpt-5.6-fast$0.00$1.46$0.11$2.40$3.98
gpt-5$0.19$0.48$0.19$0.89$1.75
deepseek-v4-pro$0.13$0.42$0.02$1.15$1.73
gpt-5.5$0.13$0.31$0.03$0.38$0.85
gpt-5-mini$0.03$0.08$0.02$0.18$0.31
gpt-5-nano$0.00$0.01$0.01$0.02$0.03
Key insight: Claude's $18.26 in cache costs (43% of its total spend) comes from 20K avg cache writes per session — Anthropic bills cache writes at premium rates. Every other model has near-zero cache write costs. DeepSeek's 197K avg cache reads cost only $1.15 total because its cache-hit pricing is $0.14/M tok. Cost components are proportionally split from the openCode DB using provider-specific pricing.
Claude cost reconciliation: $47.54 = total spend across all 47 Claude sessions (5 narration-failure + 3 unanalyzed + 39 valid). $42.52 = sum of rounded cost components (input + output + cache) from the 44 sessions with game reports. The $5.02 gap covers 3 sessions without full component data. Narration-failure sessions produce zero testable code but incur compute cost — they are included in the $47.54 total and excluded from the component breakdown. See data.js lines 718–770 for authoritative values.

Perturbation Response and Rollup

Operator response and cross-model summaries close the precursor's primary measured findings.

Perturbation Response

10 calibrated perturbation operators applied across all models. Recovery multipliers measure how perturbation changes cost — below 1.0 means perturbation reduces cost (model explores instead of recovering). Think of these as "state shocks": requirements shift, dependencies break, logs spike. We measure how each model responds when the world changes under it – and what that response costs.

ModelCONSEXPLAvg EscapeRecovery MultPrimary Behavior
DeepSeek v4 Pro79290.250.9×Explores under perturbation
Claude Sonnet 527120.241.1×Recovers via narration
GPT-5380.52—Exploratory under perturbation
GPT-5-mini1110.201.2×Conservative; over-explains to recover
GPT-5-nano420.45—Mixed; high thinking ratio
GPT-5.5120.64—Highest escape scores
GPT-5.61410.161.05×Conservative; resists perturbation
GPT-5.6-fast240.59—Exploratory; high novelty
Key insight: No model classified as WASTEFUL or EFFICIENT — every session that produced code is either CONSERVATIVE (63%) or EXPLORATORY (26%). EXPLORATORY sessions cluster around perturbation operators with escape scores averaging 0.70 vs 0.09 for conservative. Recovery multipliers are computed from cost deltas (perturbed vs baseline) — below 1.0 means perturbation reduces cost (the model explores more efficiently).

Manifold vs Semantic Perturbation Split

ModelManifold EscapeManifold CorrectnessManifold CostSemantic EscapeSemantic CorrectnessSemantic Cost
DeepSeek v4 Pro0.7677%$0.0170.1894%$0.016
Claude Sonnet 50.6287%$1.290.2188%$1.07
Key insight: Both models show high manifold escape (0.62–0.76) — pushing models off their linguistic surface produces divergence. Semantic grit reveals a different pattern: DeepSeek's escape drops to 0.18 (vs Claude's 0.21) while correctness rises to 94% (vs Claude's 88%). The model that explores more on manifold perturbations maintains higher correctness on semantic perturbations — at 69× lower cost.

Cross-Model Rollup

Measured across 224 historical game reports — not single-run data. DeepSeek delivers 1.24× more code per session at 1/69th the cost of Claude. Correctness is measured from real pytest/jest execution.

MetricDeepSeek v4GPT-5.6Claude F5All Models
Per-session cost$0.016$0.257$1.085$0.287
Test pass rate84%97%99%89%
Avg thinking ratio8.7%8.1%0.0%6.8%
Avg LOC/session706323568578
Constraint score48%49%39%47%
These per-session averages from 224 historical game reports are the most robust metric. The 69× gap is the measured average across the full corpus — not the architectural extreme, not a cherry-picked single run.

Scope, Profiles, and Research Notebook

Corpus scope and model profiles precede lower-confidence trajectory hypotheses, preserving their evidentiary boundary.

Current Scope & What's Next

This is v0.5 — an open instrument for Agentic Dynamics. Here's what's validated today and what's on the roadmap.

Covered Today
Python/Flask REST APIs, SQLite-backed CRUD apps, JWT auth flows, rate-limited endpoints, paginated responses, audit-logged systems, API versioning, pytest suites, real-time collaboration frontends. TypeScript/Node.js (initial: 3 variants, 21 cross-model runs). 10 prompt-level perturbation operators (4 manifold, 6 semantic). IEA-baseline EPM projection (1.6%/yr). Cost measurement: tokens, dollars, joules.
Planned (v0.5+)
Rust, Go validation. Structural perturbation operators (broken dependencies, AST corruption, production incident simulation). EPM sensitivity analysis (aggressive/optimistic/volatile scenarios). Human maintenance cost modeling. Pull requests welcome – the instrument was designed for extensibility from day one.
Not in Scope
The instrument does not judge whether narration is wasteful or valuable. It measures the cost. If your team needs auditable reasoning trails for compliance or debugging, the Explanation Tax is insurance – not overhead. The instrument is model-agnostic. DeepSeek was chosen as the anchor case study, not an endorsement.
Test Pass Rate Caveat
Sampled pytest results are environment-sensitive. Approximately 31% of failures resolve with correct dependency installation. The raw pass rate counts everything; the "with correct env" column estimates real code quality. DeepSeek's 69% corrected rate is comparable to Claude and GPT-5.6.
Energy Projection Caveat
The EPM uses a linear IEA-based projection. Real-world energy prices may diverge significantly. v0.5 will add sensitivity analysis with aggressive (2.5%/yr), baseline (1.6%/yr), and optimistic (0.8%/yr) scenarios.
Reproduce This
The instrument is open source. 34 configs, 10 operators, 7 recovery signals. Clone the repo, install the instrument, run a config. View on GitHub. See the methodology.
Model Cards

Detailed Model Profiles

All 8 model variants, 3 architectures. Populated from data.js with hardcoded fallbacks. Data provenance: 249 historical experiment sessions across 224 historical game reports. See methodology.

How Models Work: Tool-Call Profiles

Each model exhibits a distinct tool-usage signature — the set of tools it calls, how many steps it takes, and how many tokens it burns per session. These profiles reveal how models approach coding tasks, not just what they cost.

ModelSessionsAvg StepsAvg TokensTools UsedDominant Pattern
Methodology note: GPT models use apply_patch (legacy opencode tool interface); DeepSeek and Claude use write+edit (current tool interface). Tool counts and step counts are not directly comparable across these interfaces — each interface has different granularity. DeepSeek's 7-tool repertoire and 15-step average reflect the richer tool surface, not necessarily more work.
Key finding: Tool diversity correlates with cost efficiency. DeepSeek uses 7 different tools — including read to verify its own output before committing — enabling higher correctness at lower cost. Claude uses only 4 tools and never reads back its own code. GPT models use a legacy apply_patch interface with different granularity, making step-count comparisons unreliable across tool generations. The dominant tool-call pattern — write-then-verify vs patch-and-move-on — may be a stronger predictor of code quality than token count alone.
Research Notebook — Exploratory Metrics: The following sections (RVS, reasoning drift, recovery curves, think/do coupling, cluster transition, divergence cascades) are research hypotheses under development. They are not yet established measurement constructs and should not be read with the same confidence as measured billing telemetry above. Raw cost, token, and test-pass data carry higher evidentiary weight.

Reasoning Coherence: Volatility Score

RVS measures how semantically coherent a model's reasoning is across consecutive steps. Low RVS = focused, linear thinking. High RVS = scattered concept-hopping. Does coherence predict correctness?

ModelSessionsMean RVSMedian RVSRVS RangeInterpretation
Key finding: Focused reasoning predicts correctness. High-correctness sessions (>0.9) average RVS 0.7877, while low-correctness sessions (<0.7) average 0.8087 — a 2.6% volatility gap. GPT-5-nano is the most coherent model (mean RVS 0.751), outperforming its larger sibling GPT-5.6 (0.804) by 6.6% — suggesting model size does not guarantee reasoning focus. DeepSeek v4 Pro, with 113 sessions, shows stable mid-range coherence (0.795) despite being the most heavily tested model, and its median (0.797) closely tracks the mean — indicating consistent reasoning patterns across perturbation types. Claude Sonnet 5 is excluded from this analysis — its reasoning text is encrypted in session transcripts.
Computation: Trigram Jaccard distance between consecutive reasoning step texts — higher values indicate greater topic/concept shift between steps. 164 sessions with ≥3 reasoning steps. Claude omitted (encrypted reasoning text).

Semantic Drift: Trajectories

Cumulative step-to-step divergence over the session timeline. Models that converge: drift plateaus. Models that wander: drift grows unbounded. The SHAPE — not just the magnitude — reveals reasoning architecture.

ModelSessionsConvergentDivergentBounceTerminal DriftCorrectness (all shapes)
Key finding: Drift trajectory shape does not predict correctness. Convergent sessions average 89.8% correctness, divergent sessions 87.8%, bounce sessions 88.6% — nearly identical (Pearson r=-0.05, p=0.53). Drift reveals how a model thinks — convergent models stabilize on a solution path; divergent models keep exploring. DeepSeek is predominantly divergent (49.5% of sessions — it explores broadly). GPT-5.6 is predominantly convergent (53.8% — it stabilizes quickly). Claude cannot be measured: max 4 exposed reasoning steps.
Computation: Cumulative cosine distance from step 0's embedding to each subsequent step's embedding. Convergent = drift plateaus (gradient <0.01 for last 50% of steps). Divergent = drift grows throughout. Bounce = oscillating. 146 sessions with ≥5 steps each. Claude omitted (insufficient exposed reasoning steps).

Perturbation Recovery: Per-Step Curves

Not a binary "recovered" flag — the step-by-step distance from baseline. The curve SHAPE classifies the recovery dynamic. Divergence slope measures how fast the model drifts away from its unperturbed baseline per reasoning step.

ModelDivergence SlopeStepsPerturbation GapRecovery Pattern
Key finding: DeepSeek has the lowest divergence slope (0.00403 per step) — it stays closest to its baseline solution path. Claude's slope is 3× higher (0.0123) but its gap is near-zero (+0.5%) — not resilience, but saturation. Claude's own baseline sessions already differ from each other by 0.212, so perturbations can't push it further. On DeepSeek, manifold perturbations (vocab swap +6.6%, framing shift +10.2%) produce smaller gaps than semantic perturbations (constraint removal +12.0%, competing goal +10.8%). Surface-level attacks barely register; logical attacks are the real Grit test.
Computation: Linear regression slope of per-step cross-model distances from step 0 to step N in matched position traces. Perturbation gap = (perturbed pair distance - baseline pair distance) / baseline pair distance. Recovery = negative post-cascade divergence delta. 28 model-pair traces across 8 models.

Think-Do Alignment: Coupling Index

For each step: how similar is the model's thinking text to its actual tool call? High coupling = thinking drives action. Low coupling = narration and work are disconnected. The Explanation Tax is partly a coupling problem.

ModelSessionsTDCICorrectnessInterpretation
Key finding: Higher coupling does not predict higher correctness (r=-0.075). The models with the highest TDCI (GPT-5-mini 0.159, GPT-5-nano 0.154) have the lowest correctness (91%, 76%). GPT-5.6 achieves 100% correctness at only 0.061 TDCI — correct actions don't require narrated justification. Claude has the lowest coupling (0.048) — its thinking is most disconnected from its actions. The Explanation Tax is partly a coupling failure: narration that doesn't drive action is expensive opinion, not useful reasoning.
Computation: TF-IDF cosine similarity between thinking-text and tool+observation text per step, averaged per session. 2,988 step-pairs across 209 sessions. Claude has 4 sessions at 0.000 TDCI (empty reasoning blocks).

Reasoning Stability: Cluster Transitions

Semantic clusters per reasoning step — does the model stay in one cluster or hop between approaches? Narrated failure looks like chaotic hopping. But the data says the opposite.

ModelSessionsEntropySwitch RateDominant %Stability Score
Key finding: DeepSeek has nearly 3× the entropy of Claude (0.818 vs 0.291) — it spreads steps evenly across reasoning clusters. But the counterintuitive result: narration_failure sessions show lower entropy (0.42 vs 0.64) and higher dominant ratio (64% vs 50%). Flailing isn't chaotic hopping — it's the model locking into a single cluster and failing to escape. DeepSeek's low stability score (0.209) combined with 89% correctness proves that productive reasoning requires cluster diversity, not lock-in.
Computation: BGE-M3 per-step embeddings clustered via k-means (5 clusters). Entropy = -Σp×log(p) of cluster distribution. Switch rate = cluster changes / total steps. Dominant % = fraction of steps in most common cluster. Stability = dominant_ratio × (1-switch_rate). 5 clusters from 2,215 step embeddings across 8 models.

Divergence Cascades: Point of No Return

The step at which a model's reasoning permanently diverges from its baseline. Earlier cascade = harder to recover. The cascade step is the single best predictor of final correctness.

ModelCascade Step% Early Cascade% RecoveredRecovery DeltaInterpretation
Key finding: Claude diverges earliest (step 1.14 — 86% cascade by step 1) and never recovers (0%). When Claude loses the thread, it's permanent. DeepSeek diverges later (step 1.86 — only 14% early cascade) and self-corrects 86% of the time. The cascade step is the single best predictor of robustness: models that survive past step 2 (GPT-5-mini 2.14, GPT-5-nano 2.00) are measurably more resilient. Claude's early and permanent cascade explains the Grit gap: it's not that Claude writes worse code — it's that once perturbed, it never finds its way back.
Computation: Per-step cross-model distances from matched position traces in lab_cross_model_reasoning.json. Cascade threshold = cumulative divergence exceeds 1.5× mean per-step distance. Recovery = post-cascade divergence delta (negative = recovering). 28 model-pair traces, 8 models, 7 traces each.

Quality, Operators, and Modeled Extensions

Measured static quality remains separate from computed operator effects and externally parameterized energy estimates.

Code Quality Under Perturbation

SonarQube static analysis on 198 sessions answers a novel question: does perturbation degrade code quality? Most benchmarks measure correctness (does it work?). We also measure maintainability, reliability, and security — before and after perturbation stress.

Perturbation ClassPairs AnalyzedAvg Bugs DeltaAvg Smells DeltaAvg Quality ScoreInterpretation
Key finding: Perturbation affects correctness far more than code quality. Models that drop to 70% correctness under perturbation still produce code with maintability ratings of B or better — the code they write is well-structured, it just doesn't solve the right problem. This supports the Grit framework's thesis: perturbation tests truth-seeking (does the model follow degraded instructions or reject them?), not coding skill. The gap between correctness degradation and quality stability is the Grit signal.
Methodology: SonarQube Community Edition via sonar-scanner. Quality score = weighted composite of maintainability (35%), reliability (25%), security (25%), and quality gate (15%), plus density-adjusted bugs/smells/duplication factors (40%). Deltas compare each perturbed session against its matching baseline session (same experiment, same model, unperturbed prompt). 0 delta entries exist because baseline sessions don't have matching baselines — the delta is only computed for perturbed sessions.

Operator Impact

Per-operator, per-model cost and correctness breakdown from perturbation experiments. Cost delta = perturbed cost / baseline cost. Higher deltas mean the operator triggers more recovery behavior — and cost.

ClassModelNPert. CostBaseline CostCost DeltaCorrectnessEscape
Data unavailable
Key insight: Cost delta reveals the economic signature of each perturbation operator. Manifold operators (alien vocab, framing shifts) trigger higher escape rates and recovery costs. Semantic operators test reasoning integrity — lower escape = higher grit. [C] Computed from experiment session data.

Faded cells have fewer than 5 sessions — treat as directional indicators, not precise measurements.

Modeling Extensions: Energy estimates (joules, EPM) depend on assumptions about GPU type, active parameters, and per-token energy constants. Dollar cost and token counts are measured. Energy is a modeled estimate. Architecture constants for closed-model providers are not independently verifiable.

Energy Efficiency Ranking

Models ranked by joules per line of code — the most direct measure of energy productivity. Energy estimates use TokenPowerBench constants (Niu et al., AAAI 2026): 0.08 J/prompt-token, 0.23 J/output-token, 0.47 J/reasoning-token. [C] Computed from token counts × energy-per-token constants. [X] Energy constants externally sourced.

Data unavailable
Key insight: GPT-5.6-fast leads on J/LOC efficiency (4.66 J/LOC) despite high dollar cost — it generates compact, low-token code. DeepSeek v4 Pro delivers 5.8 J/LOC at substantially lower dollar cost. Nano's 23.56 J/LOC reflects its 1.01 reasoning-to-output ratio. Energy efficiency ≠ cost efficiency. The two dimensions are only loosely correlated. Energy estimates are modeled scenarios — dollar costs and token counts are the measured quantities.

Semantic Drift Trajectories

Within-session semantic drift: how far does a model's reasoning drift from its initial position over time? Cumulative cosine distance from step 0 to each successive step, computed from BGE-M3 embeddings of 146 sessions with ≥5 reasoning steps. [C] Computed from ChromaDB per-step reasoning embeddings via BGE-M3. Cosine distance = 1 − cosine similarity between step-0 embedding and step-N embedding.

ModelSessionsConvergentDivergentBounceFlatMean Terminal Drift
DeepSeek v4 Pro9716483300.472
GPT-5.61375100.541
GPT-5.6-fast861100.491
GPT-5-mini1246200.458
GPT-5623100.334
GPT-5-nano604200.296
GPT-5.5411200.406
Claude Sonnet 50Insufficient reasoning steps (max 4 per session)N/A
Key insight: Drift trajectory reveals reasoning architecture, not outcome quality. DeepSeek is predominantly divergent (49.5%) — its reasoning wanders further from the initial position as sessions progress. GPT-5.6 and GPT-5.6-fast are predominantly convergent (53.8% and 75%) — their reasoning stabilizes within a bounded distance. Yet both models achieve high correctness: DeepSeek 88.8% vs GPT-5.6 100%. The drift trajectory shape does NOT predict correctness (Pearson r=-0.05, p=0.53). Drift reveals how a model thinks — whether it explores (divergent) or stabilizes (convergent) — not whether it succeeds. Claude's within-session drift cannot be measured: its reasoning is exposed in at most 4 steps, making trajectory analysis impossible.
Perturbation class matters: Semantic perturbations (132 sessions) produce a balanced mix of divergent/convergent/bounce trajectories. Manifold perturbations (9 sessions) produce predominantly convergent drift (6/9) with zero bounce — linguistic disruption forces models to lock onto a reasoning path and stay there. Mean terminal drift is higher under manifold (0.521) than semantic (0.458) perturbation.
▶ Methodology: Drift Trajectory Classification

Data: 146 sessions with ≥5 reasoning steps, sourced from ChromaDB per-step BGE-M3 embeddings (2215 total step embeddings across 204 sessions). Script: scripts/lab_drift_trajectories.py. Output: experiments/results/lab_drift.json.

Computation: For each session, extract step-0 embedding as the origin. Compute cumulative cosine distance (1 − cosine similarity) from step-0 to each successive step-N. This produces a drift trajectory: [(0, 0.0), (1, d1), (2, d2), ..., (n, dn)].

Classification: Each trajectory is classified by comparing first-half mean drift vs second-half mean drift, linear regression slope, and oscillation amplitude (standard deviation):

  • Convergent: Mean drift shift < −0.04 (shrinking back toward origin) or negative linear slope with terminal drift below 70% of initial jump
  • Divergent: Mean drift shift > 0.06 AND positive linear slope > 0.003 (meaningful growth away from origin)
  • Bounce: Standard deviation > 0.07 with no clear directional trend — high oscillation amplitude
  • Flat: All drift values < 0.1 (never leaves origin neighborhood)

Claude exclusion: Claude Sonnet 5 sessions store at most 4 reasoning steps in ChromaDB (vs DeepSeek's typical 15+). This is not a data gap — it reflects architectural differences in how Claude structures its reasoning output. Within-session drift requires ≥5 steps to classify a trajectory shape.

Cosine distance range: 0.0 (identical) to 1.0 (orthogonal). Typical observed range: 0.14–0.71. Distance metric: 1 − dot(A,B) / (||A|| · ||B||). Embedding model: BGE-M3 via Ollama, 1024-dimensional vectors.

Strategy Distribution

How models respond to perturbation: strategy archetypes classified by escape rate, recovery behavior, and output quality. [C] Computed from 227 historical classified experiment worktrees.

Data unavailable

Key insight: Conservative dominates (62%), consistent with models defaulting to familiar patterns under perturbation. Only 3 sessions (1.3%) classified as wasteful — models rarely produce low-quality output with high exploration. The 24 "unknown" sessions lack sufficient signal for classification (typically narration failures or zero-code outputs). No sessions classified as EFFICIENT — the archetype requires both high exploration AND high quality at low cost, a rare combination.
▶ Data Sources & Design Parameters
Energy Constants [X] External source
TokenPowerBench (Niu et al., AAAI 2026):
— 0.08 J/prompt-token · 0.23 J/output-token · 0.47 J/reasoning-token
EPM Projections [X] External source
Baseline: 1.6%/yr — IEA World Energy Outlook 2024
Aggressive: 2.5%/yr — Aggressive scenario
Model Architecture Estimates [X] External source
Claude Sonnet 5: ~500B active params (conservative estimate)
DeepSeek v4 Pro: ~37B active params (MoE, ~3% active at inference)
Design Parameters [H] Heuristic / design choice
Context inflation rate (β): 0.001 · WOC healthy: 0.85 · WOC critical: 0.7
Composite weights: correctness 35% · constraint 30% · quality 20% · novelty 15%
Strategy thresholds: correctness ≥ 0.7, escape ≥ 0.5, novelty ≥ 0.4
Provider Pricing [M] Measured from API billing
All cost values measured directly from provider API responses via the openCode database. Per-session costs include input tokens, output tokens, reasoning tokens, and cache read/write operations at provider-specific rates.
▶ Validation: Independent Methods

Three independent methods corroborate the primary measurement apparatus. These analyses were run on the same experiment session transcripts using orthogonal approaches — embeddings, graph topology, and per-step divergence tracking. Their convergence with the primary metrics (escape rate, strategy archetype, grit scores) strengthens the instrument's validity.

Semantic Clusters
Embedding-based analysis of session transcripts reveals distinct reasoning clusters by model architecture. Models within the same architecture family (GPT variants) show the closest semantic alignment. DeepSeek's MoE architecture produces structurally distinct reasoning patterns — its nearest cross-family centroid distances are to GPT-5.6 (0.0513) and GPT-5.6-fast (0.0547). Perturbation class (semantic vs manifold) produces measurable cluster shift.
Cross-Model Reasoning Distance
Pairwise centroid distance across 8 models shows model family influences trajectory structure more than scale. GPT-5.6 and GPT-5.6-fast are closest of any pair (centroid distance 0.0062), followed by GPT-5-mini and GPT-5-nano (0.0092). Cross-family distances are 5–12x larger: Claude-to-any-GPT averages ~0.068. DeepSeek's centroid sits at intermediate distances to all other models — distinct from both families. These are observed behavioral patterns, not direct measurements of model internals.
Per-Step Reasoning Divergence
Matching-step comparison (step N vs step N across sessions) shows perturbation produces measurable divergence from baseline reasoning. Cross-class comparisons (mixed semantic/manifold pairs) yield the highest mean distance (0.203). Manifold-only pairs (0.181) and semantic-only pairs (0.191) show tighter clustering within their own class — suggesting that while perturbations shift reasoning, models respond differently depending on perturbation type rather than uniformly.
Basin Topology (Neo4j)
Graph-based attractor basin analysis using Neo4j classifies sessions into distinct topological profiles (wide_shallow, wide_moderate, collapsed, unstable). Of 227 historical runs, 203 were classified into strategy archetypes that aligned with the primary measurement framework. Each model shows a characteristic basin volume under semantic perturbation: GPT-5.6 (1.193, largest), GPT-5-mini (0.991), DeepSeek (0.691), GPT-5 (0.618), Claude Sonnet 5 (0.530), GPT-5.6-fast (0.420), GPT-5.5 (0.360, collapsed), GPT-5-nano (0.234, unstable). The validation check confirmed zero classification differences — the scoring is not an artifact of the algorithm.

These analyses use BGE-M3 embeddings via Ollama, ChromaDB vector storage, and Neo4j graph database. Full methodology and results are in experiments/results/lab_*.json. They serve as independent validation of the primary measurement stack — not replacements for it.

Verdicts and Calibration

Three measured verdicts bound what the instrument authorizes. Each is scoped: it names its evidence class, its denominator/n, and what it does not authorize.

[C] decision over [M] outcomes

cap_2b — randomized non-inferiority verdict

Authorization boundary: the verdict authorizes design review only — it does not arm a control policy. Source: experiments/results/cap_2b/cap_2b_score_20260826T160018Z.json.
Method and limits

Decision rule: CPVO ratio ≤ 1.10 with the success gap within margin, per docs/designs/current/cap_2b_preregistration.md. Descriptive decision over measured outcomes; no causal generalization to other tasks or models.

Escalation E_x — the measured fix multiplier
Cell baseline $0.008949, then the measured Sol and Sonnet escalation-fix costs with their E_x multipliers. ESCALATION E_x / THE MEASURED FIX MULTIPLIER THE FIX COSTS 11–12× THE CELL MEASURED COSTS · COMPUTED RATIOS · N=1 · DESCRIPTIVE — NO CAUSAL CLAIM 01 / BASELINE CELL$0.008949the cell each fix is divided by 02 / SOL FIX$0.102619E_x = 11.4671 03 / SONNET FIX$0.111982E_x = 12.5134 N=1 PER ESCALATION MODEL · DESCRIPTIVE · NO CI · NO CAUSAL CLAIM
Figure E1. The escalation chain — [M] costs ($0.008949 baseline; $0.102619 Sol; $0.111982 Sonnet) and [C] ratios (E_x = 11.4671; 12.5134), n=1 per model, scoped to the measured escalation path.
[M] costs[C] ratiosref: svg-marker-flow.html, svg-pattern-surface.html
Calibration arc — 0/3 → 2/3 → 2b
Three panels: initial 0/3, rerun 2/3 with Wilson interval, then the 2b non-inferiority decision. CALIBRATION ARC / 0→3 · 2÷3 · 2b EACH PANEL NAMES ITS N AND INTERVAL 0/3 INITIAL · 2/3 RERUN (WILSON) · 2b NON-INFERIOR — AUTHORIZES DESIGN REVIEW ONLY 01 / INITIAL0 / 3n=3 02 / RERUN2 / 3Wilson [0.2077, 0.9385] · n=3 · descriptive 03 / DECISION2b NON-INFERIORCPVO ratio [0.6842, 0.9105]authorizes design review only DESCRIPTIVE, NOT STATISTICAL CLEARANCE · THE FINAL LABEL STATES ITS AUTHORIZATION BOUNDARY
Figure E2. The calibration arc — 0/3 initial, 2/3 rerun (Wilson [0.2077, 0.9385], n=3), then the 2b decision. Each panel names its n and interval; the final label states its authorization boundary.
[C] over [M]ref: scroll-sticky-overlay.html, d3-line-arc.html
not measuredEscalate-arm trigger remains untriggered. All six escalate cells passed first attempt — the no-escalation cost ($0.005946) is published, not a premium estimate. See docs/designs/current/cap_session_routing_prospective.md.
not measuredLSP diagnostics. No current canonical LSP series — rendered as not measured, never "0 errors".
no canonical outputLab panels. Several analysis surfaces have no canonical current output; the placeholders render that absence explicitly.

The Field Now Visible

The archived precursor and the current story corpus expose part of a shared field without becoming one dataset. Agentic Dynamics studies how AI agents behave, adapt, interact, recover, and produce outcomes across changing tasks, environments, workflows, and time. Here, observed evidence keeps cost, verification, static and reviewed quality, recovery, and long-horizon compounding separate while identifying signals that may support future control rules.

Observed now: controlled perturbation response, natural verification behavior, independent review, static quality, solution dynamics, and the five-session cost arc. Still open: when to route, retry, escalate, or stop; which confidence signals are reliable enough to drive those decisions; and how short-run savings translate into long-horizon value. Those are control questions for future experiments, not conclusions added to these corpora.
Run the Instrument on Your Data →