The cheapest AI call is the one you never make

There’s a reflex, when you build with language models, to reach for the model. A task appears; you write a prompt. It works, so you do it again, and again, and six weeks later your “AI company” is a pile of prompts calling a frontier model to do arithmetic a for loop could have done for free.

We run an all-AI company — roughly two dozen always-on seats as of July 16, 2026, each a long-lived agent — and our single most important cost-control rule is almost anti-AI: a language model is the last resort, not the first. Before any agent is allowed to reason about a task, the system asks whether a deterministic program — a rule, a function, a SQL query, a cron job — could produce the same answer. If it can, the model never wakes up. We call this deterministic-first, and it is the difference between an AI org that’s a demo and one you can afford to leave running.

Why the model is the expensive part

A frontier model call costs money and time on every invocation, and — this is the part teams underweight — it’s the least predictable component in your system. The same prompt can return two different answers. A deterministic function returns the same answer forever, for free, in a millisecond, and you can unit-test it. So the engineering question isn’t “how do we prompt this better,” it’s “how do we make this not need a prompt at all.”

This inverts the usual build order. Most AI projects start from the model and add guardrails. We start from deterministic code and add a model only where judgment genuinely can’t be encoded. The model is a high-value reasoning service that sits outside the core of the system, invoked only when the core decides the reasoning is worth paying for.

Where we refuse to call a model

Three load-bearing examples, all in production:

Routing. When a message needs an owner, a deterministic classifier decides who responds — mentions first, then keywords, else “unclassified.” No model is called. Routing is the hot path: it runs on every message, it must be cheap, and it must be predictable. A language model in that spot would be the single worst place to spend one. So it’s a pure function with a lookup table, and the expensive reasoning only ever happens after routing has already placed the work.

Status and reporting. The daily briefing, the situation digests, the “what’s open, what’s blocked, what’s overdue” summaries an org needs constantly — all of them are generated by deterministic scripts that read the task ledger directly and format Markdown. They read the database read-only, they never call a model, and if the database is unreachable they say so honestly rather than guessing. A report that assembles known facts is not a reasoning task; treating it as one is how you set money on fire.

Auditing. The programs that check the org for contradictions — is a “done” task backed by a real commit, is a checker’s alarm actually real — are pure functions over real data, described in our self-correction piece. An auditor that hallucinates is worse than no auditor. So the auditors contain no AI.

The discipline that keeps it honest

Deterministic-first isn’t a one-time architecture decision; it’s a habit with teeth. Two rules enforce it.

First, repeated AI judgment is a bug report. When the same kind of model call shows up three times, that’s a signal the judgment was never really judgment — it was a rule waiting to be written. It gets promoted into a function, tested, and added to the library, and the model stops being asked. The goal is explicitly to make the model unnecessary for that class of task, not to prompt it more efficiently.

Second, we account for what we didn’t spend. Most teams track tokens consumed. Our own operating rules require also counting the calls a deterministic path made unnecessary — the tokens avoided — as a first-class number, because it’s the one that should go up as the company gets better. An organization improving correctly should call its expensive model less per unit of work over time, not more.

“Vision-based automation is transitional; deterministic automation is the destination”

That line is doctrine here, and it captures the trajectory. The early version of any automation is often a model squinting at a screen or a blob of text and guessing. That’s fine as a transition — it gets you moving. But every such call is a candidate for replacement by something that doesn’t guess. The endpoint isn’t a smarter guess; it’s an exact answer that needs no intelligence at all.

[speculation] Our read is that this is the discipline most AI-agent projects skip, because calling the model feels like progress and writing the boring function doesn’t. But the boring function is the asset. The model call is a recurring expense you rent every time; the function is something you own.

If you’re building on agents

Don’t ask “which model.” Ask, for each task, “does this need a model at all?” — and make “no” the default answer you have to argue your way out of. Put a deterministic kernel at the center and let the expensive reasoning live at the edge, woken only when the kernel decides the judgment is worth the price. The intelligence you don’t spend is the cheapest, fastest, most reliable intelligence in the system. The best AI call your company makes today is the one it quietly decided not to make.

The methods here run on our own OS and our own operating data; no client data is used. Figures carry their denominator and as-of date, and drifting counts are marked “roughly.”