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.
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 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.
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.
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.
| Model | Cost/story | Tests/story | Test:Code ratio | Cache hit | Tokens/session |
|---|---|---|---|---|---|
| DeepSeek v4 Flash | $0.07 | 33.5 | 0.66 | 96.4% | 46.6K |
| GPT-5.6 Luna | $0.09 | 7.3 | 0.28 | 97.5% | 6.3K |
| DeepSeek v4 Pro | $0.14 | 34.4 | 1.09 | 77.8% | 34.7K |
| Claude Haiku 4.5 | $1.59 | 117.4 | 1.02 | 60.6% | 10.1K |
| GPT-5.6 Terra | $1.02 | 8.8 | 0.33 | 81.9% | 33.0K |
| Claude Sonnet 5 | $4.58 | 122.1 | 0.65 | 73.1% | 14.3K |
| GPT-5.6 Sol | $3.75 | 12.9 | 0.42 | 84.3% | 46.9K |
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).
Authored test volume is kept separate from second-model review, structural diffs, conventions, and SonarQube diagnostics.
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) | Coherence | Arch fit | Convention | Commits "better" | "worse" |
|---|---|---|---|---|---|
| Claude Sonnet 5 (n=3) | 0.92 | 0.86 | 0.79 | 80% | 0% |
| GPT-5.6 Luna | 0.90 | 0.77 | 0.75 | 74% | 8% |
| DeepSeek v4 Pro | 0.88 | 0.74 | 0.72 | 70% | 12% |
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.
| Theme | DeepSeek | Luna | Sonnet 5 |
|---|---|---|---|
| Security (hard-coded secrets / auth) | 29 | 25 | 1 |
| Test gaps | 20 | 27 | 2 |
| Incomplete refactor | 26 | 17 | 1 |
| Schema / migration drift | 17 | 10 | 2 |
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.
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.
| Model | Commits | Lines added | Functions added | Sonar smells Δ | Sonar complexity Δ | Convention |
|---|---|---|---|---|---|---|
| DeepSeek v4 Flash | 0 | 0 | 0 | 0 | 0 | — |
| GPT-5.6 Luna | 0 | 0 | 0 | 0 | 0 | — |
| DeepSeek v4 Pro | 0 | 0 | 0 | 0 | 0 | — |
| Claude Haiku 4.5 | 0 | 0 | 0 | 0 | 0 | — |
| GPT-5.6 Terra | 0 | 0 | 0 | 0 | 0 | — |
| Claude Sonnet 5 | 0 | 0 | 0 | 0 | 0 | — |
| GPT-5.6 Sol | 0 | 0 | 0 | 0 | 0 | — |
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.
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.
| Model | Correctness | Constraints | Code Quality | Novelty | Basin Escape | LSP Errors / story | Strategy 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 |
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.
| Session | Task type | Avg cost | Avg tokens | Avg tests |
|---|---|---|---|---|
| no canonical story-arc data | ||||
Avg cost per session across — canonical stories ([M] measured). Source: D.labs.story_arc.
| Condition | Cells | Success | Cascade recovery | Avg cost |
|---|---|---|---|---|
| no canonical condition data | ||||
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 = 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 strength | Cells | Test-executed successes | G(s) | 95% CI |
|---|---|---|---|---|
| no canonical Grit data | ||||
Wilson score intervals. Source: D.labs.grit (— canonical 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.
| Model | Cells | G(0.5) | 95% CI |
|---|---|---|---|
| no canonical Grit data | |||
| Perturbation class | Cells | G(0.5) | 95% CI |
|---|---|---|---|
| no canonical Grit data | |||
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.
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 ↑
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.
Controlled degradation made recovery, basin escape, and flailing visible as separate behaviors.
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.
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.
| Model | Type | Escape Rate | Correctness | Cost/Session | Interpretation |
|---|---|---|---|---|---|
| DeepSeek v4 Pro | Manifold | 0.76 | 77% | $0.017 | Explores broadly when pushed, but mostly recovers |
| Semantic | 0.18 | 94% | $0.016 | High grit — rejects false signals inside the manifold | |
| Claude Sonnet 5 | Manifold | 0.62 | 87% | $1.29 | Stays close to the manifold, recovers via narration |
| Semantic | 0.21 | 88% | $1.07 | Strong truth-seeking, but bills every reasoning step |
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.
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%.
| Model | Reports | Narration Failures | Penalty Rate | Avg Cost/Session | What's Happening |
|---|---|---|---|---|---|
| DeepSeek v4 Pro | 68 | 2 | 8% | $0.015 | Low reasoning-token overhead (observed pattern; causal mechanism not confirmed) |
| GPT-5.6-fast | 6 | 3 | 33% | $0.49 | Some narration, moderate efficiency |
| GPT-5.5 | 3 | 3 | 50% | $0.16 | Narrates heavily under perturbation |
| GPT-5.6 | 15 | 1 | 6% | $0.43 | Mostly clean, occasional over-explanation |
| GPT-5 | 5 | 1 | 15% | $0.14 | Some narration, moderate efficiency |
| Claude Sonnet 5 | 27 | 5 | 11% | $1.01 | Narrates before coding — externalizes every reasoning step |
| GPT-5-mini | 12 | 1 | 8% | $0.025 | Moderate narration rate |
| GPT-5-nano | 6 | 1 | 14% | $0.005 | Low sample size — limited data |
Cost, code structure, static quality, constraints, and token accounting remain distinct measurements.
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.
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.
| Model | Reports | Avg Cost | 95% CI | Total Cost | Correctness | Strategy |
|---|---|---|---|---|---|---|
| Data unavailable — run build_data.py to regenerate | ||||||
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 |
|---|
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.
| Model | Worktrees | Avg LOC | Bugs/kLOC | Smells/kLOC | Quality Score | Maint. |
|---|---|---|---|---|---|---|
| Data unavailable | ||||||
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.
| Constraint | DeepSeek Implementation | Claude Sonnet 5 Implementation |
|---|---|---|
| JWT authentication | auth.py, extensions.py | auth.py, extensions.py |
| Rate limiting | auth_routes.py | rate_limit.py |
| Input validation | validators.py | schemas.py |
| Pagination | models.py | pagination.py |
| Error handling | errors.py | errors.py |
| Audit logging | audit.py | audit.py |
| API versioning | routes/v1/ | Blueprint /v1/ |
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.
| Model | Input $ | 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 |
Operator response and cross-model summaries close the precursor's primary measured findings.
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.
| Model | CONS | EXPL | Avg Escape | Recovery Mult | Primary Behavior |
|---|---|---|---|---|---|
| DeepSeek v4 Pro | 79 | 29 | 0.25 | 0.9× | Explores under perturbation |
| Claude Sonnet 5 | 27 | 12 | 0.24 | 1.1× | Recovers via narration |
| GPT-5 | 3 | 8 | 0.52 | — | Exploratory under perturbation |
| GPT-5-mini | 11 | 1 | 0.20 | 1.2× | Conservative; over-explains to recover |
| GPT-5-nano | 4 | 2 | 0.45 | — | Mixed; high thinking ratio |
| GPT-5.5 | 1 | 2 | 0.64 | — | Highest escape scores |
| GPT-5.6 | 14 | 1 | 0.16 | 1.05× | Conservative; resists perturbation |
| GPT-5.6-fast | 2 | 4 | 0.59 | — | Exploratory; high novelty |
| Model | Manifold Escape | Manifold Correctness | Manifold Cost | Semantic Escape | Semantic Correctness | Semantic Cost |
|---|---|---|---|---|---|---|
| DeepSeek v4 Pro | 0.76 | 77% | $0.017 | 0.18 | 94% | $0.016 |
| Claude Sonnet 5 | 0.62 | 87% | $1.29 | 0.21 | 88% | $1.07 |
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.
| Metric | DeepSeek v4 | GPT-5.6 | Claude F5 | All Models |
|---|---|---|---|---|
| Per-session cost | $0.016 | $0.257 | $1.085 | $0.287 |
| Test pass rate | 84% | 97% | 99% | 89% |
| Avg thinking ratio | 8.7% | 8.1% | 0.0% | 6.8% |
| Avg LOC/session | 706 | 323 | 568 | 578 |
| Constraint score | 48% | 49% | 39% | 47% |
Corpus scope and model profiles precede lower-confidence trajectory hypotheses, preserving their evidentiary boundary.
This is v0.5 — an open instrument for Agentic Dynamics. Here's what's validated today and what's on the roadmap.
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.
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.
| Model | Sessions | Avg Steps | Avg Tokens | Tools Used | Dominant Pattern |
|---|
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.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.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?
| Model | Sessions | Mean RVS | Median RVS | RVS Range | Interpretation |
|---|
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.
| Model | Sessions | Convergent | Divergent | Bounce | Terminal Drift | Correctness (all shapes) |
|---|
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.
| Model | Divergence Slope | Steps | Perturbation Gap | Recovery Pattern |
|---|
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.
| Model | Sessions | TDCI | Correctness | Interpretation |
|---|
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.
| Model | Sessions | Entropy | Switch Rate | Dominant % | Stability Score |
|---|
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.
| Model | Cascade Step | % Early Cascade | % Recovered | Recovery Delta | Interpretation |
|---|
Measured static quality remains separate from computed operator effects and externally parameterized energy estimates.
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 Class | Pairs Analyzed | Avg Bugs Delta | Avg Smells Delta | Avg Quality Score | Interpretation |
|---|
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.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.
| Class | Model | N | Pert. Cost | Baseline Cost | Cost Delta | Correctness | Escape |
|---|---|---|---|---|---|---|---|
| Data unavailable | |||||||
Faded cells have fewer than 5 sessions — treat as directional indicators, not precise measurements.
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.
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.
| Model | Sessions | Convergent | Divergent | Bounce | Flat | Mean Terminal Drift |
|---|---|---|---|---|---|---|
| DeepSeek v4 Pro | 97 | 16 | 48 | 33 | 0 | 0.472 |
| GPT-5.6 | 13 | 7 | 5 | 1 | 0 | 0.541 |
| GPT-5.6-fast | 8 | 6 | 1 | 1 | 0 | 0.491 |
| GPT-5-mini | 12 | 4 | 6 | 2 | 0 | 0.458 |
| GPT-5 | 6 | 2 | 3 | 1 | 0 | 0.334 |
| GPT-5-nano | 6 | 0 | 4 | 2 | 0 | 0.296 |
| GPT-5.5 | 4 | 1 | 1 | 2 | 0 | 0.406 |
| Claude Sonnet 5 | 0 | Insufficient reasoning steps (max 4 per session) | N/A | |||
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):
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.
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
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.
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.
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.
experiments/results/cap_2b/cap_2b_score_20260826T160018Z.json.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.
docs/designs/current/cap_session_routing_prospective.md.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.