When I say some part of my workflow is expensive or cheap, I almost never mean money. I mean tokens. That translation happened quietly over the last year, and it’s worth spelling out, because compute really has become payroll for people who work the way I do, except the salaries went flat. That changes which resources you manage.
The subscription arbitrage
The flat salary is the frontier labs’ subscription plans, and the leverage in them is genuinely absurd. People who parse their local session logs have documented single months of $5,600 in API-equivalent tokens on a $200 plan, and long-run tallies like ten billion tokens over eight months: north of $15,000 at API rates, on $800 of subscription fees. The tallies I’ve seen from heavy multi-agent users run anywhere from $3,000 to $14,000 a month in API-equivalent spend on a $100–200 membership.
The labs can afford this for two reasons, and both matter to how I build. Heavy prompt caching is the first: a well-run agent session is mostly cached prefix, which is also why turn-injection instead of polling pays twice. The second is that subscriptions keep you inside the lab’s own client, where they control the harness, the caching discipline, and the context management end to end. A subscription user in the native harness is far cheaper to serve than raw API traffic, and that alignment of incentives is part of why goldengoose is built on the provider CLIs and their subscriptions rather than metered API billing: the arbitrage was designed to be taken.
The consequence is the interesting part. When the marginal dollar cost of a token is effectively zero up to your limits, dollars stop being the thing you optimize. The binding constraints move, and there are three of them.
The three real currencies
Tokens: not because they cost money, but because they occupy context, and every one of them is helping or hurting. A wasteful workflow at flat price is still wasteful; it just pays in degraded attention instead of invoices.
Turns: the unit the subscription actually meters, through usage limits, and the unit that quality actually rides on. An agent that burns turns asking “is it done yet?” is spending the scarcest thing twice: its limit allowance and its own coherence.
Wall-clock time: how long agents sit waiting on infrastructure before anything useful comes out the other end. This one was always there, but agents made it visible by making everything else fast.
Running a team well means knowing which currency each decision spends. And, just like with money, knowing where to be deliberately extravagant.
Where I overspend on purpose
Research, every time. It’s the highest-leverage token expenditure in my entire pipeline, for a compounding reason: everything downstream depends on it. If the research pass misreads the codebase, the planner builds on a flawed understanding, the implementers build on a flawed plan, the reviewer judges against flawed criteria, and no amount of downstream excellence recovers what the first step got wrong. Errors at the top of the chain are the only ones that multiply. So my RPI skills pin research and planning to the deepest model presets, and when a feature touches unfamiliar territory I’ll happily spend an implementer’s worth of tokens on reconnaissance that produces nothing but a markdown file. Cheapest insurance I buy.
Review is the other extravagance. My reviewers run at high or xhigh reasoning, and the logic mirrors the research argument from the opposite end of the pipeline: the verifier is the gate, and the quality of everything that ships is bounded by the quality of the judgment at the gate. A reviewer reads the whole branch cold and has to notice what the author-context structurally can’t; that’s reasoning-heavy work by its nature, and skimping on it converts every saved token into a shipped bug.
Between those two bookends, I’m deliberately stingy. Implementation mostly runs the latest GPT models at medium reasoning, and medium is a choice, not a compromise: at that setting they default to thinking briefly, but escalate their own reasoning when a problem resists. It’s depth on demand instead of depth always-on. That’s exactly the right shape for execution, because by the time a phase reaches an implementer, the planning already removed the ambiguity that deep thinking would otherwise be spent resolving. Paying for always-on reasoning to execute an unambiguous spec is buying insight nobody ordered. Execution wants tightly scoped phases, lean contexts, and a model that saves its thinking for the moments something actually goes sideways.
The wall-clock tax
The third currency is the one that surprised me by becoming visible at all. When agents write the code, human typing speed stops masking anything, and the slowest remaining step stands fully exposed: waiting for infrastructure. Compile times, test suites, CI: how long you make an agent stand at the end of the assembly line before something useful comes out.
Rust sits at the painful end of this, and I keep paying anyway with open eyes. A build that takes fifteen seconds in Go takes four minutes in Rust on my projects, and at agent cadence that difference is not cosmetic: it’s the difference between shipping fifty commits a day on a project and shipping twenty. I’ve written about why the price is worth it where the software is load-bearing: the borrow checker, memory safety, the strange fact that proving a program correct is easier for agents in Rust than anywhere else. The process manager keeps the token cost of waiting near zero, since agents end their turn and get woken with results. But injection can’t compress the four minutes themselves. Wall-clock is the one currency my architecture can’t refund, only route around, which is exactly why the tools tier is Go, and why “how long is the compile” is now a first-class input to my language choices.
So: compute is payroll, but it’s payroll with flat salaries and three meters running. I spend tokens like a researcher, guard turns like an accountant, and treat wall-clock like the only bill that never gets discounted. Dollars are the one thing in this whole system I’ve stopped thinking about, which, if you’d told me two years ago, is the part I’d have believed last.