A $20 API key exposed a value-measurement gap.

I was trying to spend less while I was away. The unexplained difference between cost, output, and durable value turned a personal budget experiment into a measurement question.

Part 1 · Why — The Anomaly

The cost anomaly.

At the start of 2026, I was spending close to $700 per month on AI subscriptions. ChatGPT Pro. Claude Max. All the tiers. I used them for everything – coding, writing, thinking through architecture decisions, running experiments. It was just the cost of doing business. I didn't think about it.

Then I went on a break to Italy. I downgraded every subscription to the lowest tier. On the train from Rome to Naples, I decided to try something.

But I had a few things I wanted to tinker with while I was away. So I did something I'd never done before: I loaded $20 USD onto the DeepSeek v4 API and pointed my tooling at it. Twenty dollars. That's less than I'd spend on a single lunch in Rome.

That was weeks ago. I burned through $2.04 in DeepSeek experiment costs — plus personal sessions, under $13 total for weeks of experimentation.

3
Models Tested
347
Instrumented Sessions
$309.17
Total Research Cost
17×
Measured Cost Gap

The cost gap demanded an explanation.

In the time it took me to burn through $12.73, I:

347
Total Sessions
$309.17
All-Model Experiment Cost
$12.73
DeepSeek Spend
$4.64
Claude Sonnet 5 Spend
"This doesn't make any sense. How is this possible? The same tasks. The same outcomes. A fraction of the cost. I had to understand why." – Me, staring at the DeepSeek billing dashboard, on a train from Rome to Naples
The Question this origin became →
Part 2 · How — The Question Scaled

One comparison became an N x M experiment.

The price difference was only the first observation. To understand whether cheaper output also created durable value, I needed to compare behavior under controlled degradation and follow what happened after each session.

The experiments revealed something I didn't expect. When we deliberately broke the instructions — inverted constraints, removed critical requirements, injected alien vocabulary — the models produced materially different recovery and output behavior. I initially thought the cost difference was simply token volume. It wasn't. That led me to start perturbing specifications and measuring how the agents behaved.

I'm calling this Grit: Ground-Truth Integrity. How well does a model maintain correctness when the input is degraded?

The measurement produced two dimensions:

We observe materially different recovery and output behavior across provider families. Differences may be explained by model architecture, post-training, provider-side optimizations, tooling interaction, or some combination. This experiment does not identify the causal mechanism.

One hypothesis is that DeepSeek's GRPO reinforcement learning approach may contribute to its lower reasoning-token overhead, while SFT-trained models may produce more billed reasoning tokens under perturbation. But this remains a hypothesis — the experiment measures outcomes and cost, not training architecture internals.

We observe an interesting pattern: some models produce fewer reasoning tokens while maintaining performance. Whether this is caused by GRPO training architecture, provider-side caching, or some combination is not yet determined.

Later analysis revealed the deeper layer: equal token counts do not equate to identical cost. Claude Sonnet 5's output tokens cost ~5.1× more per unit off-peak ($10.00 vs $1.98 per 1M output tokens, off-peak); DeepSeek's rate doubles to $3.96/M at peak (01:00–04:00 & 06:00–10:00 UTC), narrowing the gap to ~2.5×. And cache behavior splits the models: DeepSeek reuses only 78% of its context, re-reading the codebase every session at 35K tokens, while Luna and Sonnet trust their cache at 97-98% hit rates and send 6K new tokens. Two models produce the same codebase at wildly different token economics.

Scaling the question changed the problem.

A clean-versus-degraded prompt comparison could answer one bounded question, but agentic software work is cumulative. N linked sessions were needed because each session changes the codebase inherited by the next. M measurement angles were needed because tests alone cannot represent maintainability, maintainability cost, long-horizon scalability, one-way and two-way-door routing risk, verification depth, cache economics, recovery, or cost per accepted outcome.

Collection was only half of the multiplication. The same sessions then had to be analyzed across models, conditions, tasks, tiers, commits, and positions in the story: a second N x M burden. More sessions without analysis produce volume, not information; more metrics without consistent event capture produce incomparable claims.

Part 3 · How — The Instrument

The question required instrumentation, not another benchmark.

Instrument — capture events. This is instrumentation that runs async CLI sessions at scale: a queue that workers drain, isolation so sessions cannot delete the lab, resumability after timeouts, and per-session capture of cost, tests, cache behavior, code changes, and perturbation context. The instrument does not judge code. It runs thousands of sessions and records what happened.

Because the outcome of one session is the starting point of the next. Five sessions chain into a story — greenfield → feature → integration → refactor → cross-cutting — each committing onto the last. The output becomes the next codebase. The measured arc shows later sessions costing more; the N² relationship is a modeled extension beyond those endpoints.

Derive — turn events into information. Session traces, tests, static analysis, and independent reviews become measures of verification depth, maintainability, recovery, and cost per accepted outcome. This is the analysis layer that turns the N x M corpus into comparable evidence.

Write policy, then grid. A separate module — the one I'm focused on now — can use measured information to propose routing experiments. DeepSeek through opencode. Sonnet through the Claude CLI. Luna through opencode. The same chained sessions and passing tests produced different observed verification depth: Sonnet writes 73 tests for $2.32 while Luna writes 7 for $0.09. Which toolchain should receive one kind of session is a policy question to test as an arm, not a conclusion to infer from price alone.

⚠

Campaign — change one variable and repeat. Running sessions at scale is itself a measurement problem. The queue got wiped twice because the sessions I was running deleted the lab. SonarQube processes one analysis at a time, so I stood up four. Sessions time out mid-story and must resume without losing attribution. None of this is the finding; all of it is required to make repeated comparisons possible.

The payoff is information, not session volume. Over 2,000 sessions — 1,067 story-building runs across 215 cells and seven models, plus 911 independent reviews — made cost and verification differences visible on the same linked work. That evidence can support a proposed policy; only a controlled grid can establish whether the policy improves value.

"The outcome of one session is the starting point of the next. Measure it before deciding how to route it."

The question crossed four disciplines.

The measurement problem did not fit inside a single discipline. Economics, physics, energy markets, and software systems each exposed a different part of the same cumulative process.

Economics. Cost curves distinguish marginal from total cost. The N² term in the modeled cumulative equation reads as a production function: codebase growth can become a second-order cost driver rather than a sequence of independent prompt charges.

Physics. A GPU drawing 700W while running converts energy into computation. That makes Watt-per-useful-token and the Energy Price Multiplier physical inputs to long-horizon hypotheses, not substitutes for directly measured session cost.

Energy markets. External projections estimate 220% growth in AI power demand and data-center consumption of 6.7–12% of US generation. These are external structural inputs to a model, not outcomes measured by this experiment.

Software engineering and system architecture. Production experience supplied the operational constraints: switching C₀ can be a two-way door, while architecture choices that determine β may persist across the codebase. Those distinctions become hypotheses that the instrument can test.

Career context. Work with CFO and CTO decisions clarified the difference between evidence that describes a benchmark and evidence strong enough to change a policy. The ten rules are possible control rules; where they have not been run as arms, they remain proposals.

⚠

The disciplines constrain one another. Physics bounds the energy input, economics describes compounding cost, software architecture explains inherited state, and operational leadership asks which decision the evidence can actually support. Together they turn separate observations into a testable research program.

Part 4 · What — The Field

The result was not a cheaper-model verdict.

The work began as an AI FinOps question: I started out trying to show that DeepSeek was more efficient by running the same tasks, measuring the costs, and publishing the numbers. The linked sessions showed why that answer was incomplete. Agentic Dynamics is the resulting field of inquiry, not a product: it is the empirical study of how AI agents behave, adapt, interact, recover, and produce outcomes across changing tasks, environments, workflows, and time. This instrument currently studies immediate cost, verification, maintainability, recovery, and five-session progression in coding-agent workflows; routing and long-horizon economics remain open research questions.

Immediate cost. The DeepSeek and Claude gap was not only price per session; it changed how long a fixed budget could sustain work. A useful policy must maximize accepted outcomes before the budget runs out, rather than choose the cheapest model for every prompt.

Durable verification. What I didn't expect when I first published the instrument was that the deeper distinction was not simply token count. Luna writes 7 tests per story for $0.09. Sonnet 5 writes 73 for $2.32. Both codebases pass their tests. Only one has the broader observed safety net. That is the durable-value gap the instrument was built to measure.

Maintainability and recovery. A passing result does not reveal what the next agent inherits, how expensive the code is to maintain, or whether degraded input leaks into later work. Linked sessions make those questions observable without collapsing them into a single score.

One-way and two-way-door routing. Switching C₀ can be reversible. Committing to an architecture that determines β and v may not be. Routing is therefore a possible policy arm: classify the task, apply a measured verification gate, and test whether the proposed route improves durable value.

Long-horizon economics. Under linear context-growth assumptions, cumulative context cost contains an N² term (modeled extension, not independently tested). The β·v·N² term is a hypothesis for long-run cost — model the curve before architectural commitments.

Cost per accepted outcome. CostPerOutcome is not cost per prompt or cost per session. It asks for the durable value of an accepted outcome divided by what it cost to produce and sustain it.

Energy economics. EPM(t), the Energy Price Multiplier, brings external energy-market assumptions into long-horizon modeling. The 4Ms framework from Google Cloud formalizes this dimension, and the IEA projects 1.8× growth by 2050. Those external projections inform scenarios; this corpus did not measure them.

⚠

The comparison opened a broader question. I thought I was comparing two models. The evidence instead pointed to a field that connects individual sessions with cumulative outcome-delivery costs over multi-decade horizons, while keeping measured observations separate from modeled extensions.

The field starts where benchmarks stop.

Benchmarks can compare models on bounded tasks. They do not by themselves explain, under a team's assumptions, what cumulative costs would be in 2035 or whether the resulting software remains verifiable and maintainable.

A one-task score can still be useful, including a 2% difference on HumanEval. The missing question is whether switching models saves or costs money over three years once team size, velocity, inherited codebase growth, verification depth, and energy exposure enter the analysis.

The discovery defines a research program: measure the events, derive the information, test the policy, and repeat.

"The instrument didn't come from theory. It came from seeing $12.73 and $700 produce an unexplained difference — and needing to understand why."

The immediate record answers "what did we spend last month?" The modeled question asks "what will we spend over the next 3 years?" Under modeled assumptions, the N² term describes how inherited codebase growth can affect cumulative cost; it remains one hypothesis to test, not a measured forecast.

Follow the Discovery →
Inspect the Evidence →