Half your AI bill is a decision tree you replaced with a reasoning loop

I keep watching enterprises bolt a reasoning model onto a task a decision tree did for free. The roadmap said AI-first, so a validation that used to run in four milliseconds for nothing now costs twelve dollars a call — and, some fraction of the time, makes something up. The demo looked like the future. The bill looked like a mistake.

The pattern underneath

The failure isn't using AI. It's a category error, made twice, in opposite directions — with nobody drawing the line between them.

The first direction is treating a deterministic problem like it needs a mind. If the answer is knowable when you ship — a threshold, a routing rule, a tax lookup — you don't pay a GPU cluster to rediscover it fifty times at runtime. A switch statement already knew it, for practically zero, and it never hallucinates.

The other direction is the one the skeptics miss. A decision tree shatters the moment reality turns human. Your past-due logic expects a clean date; the client replies that the wire cleared through their Frankfurt subsidiary but there's a bank holiday, and by the way apply the volume discount in Section 4.2 of the addendum. You can't hardcode a branch for the infinite universe of a sentence. That is where a reasoning loop earns its cost — reading the ambiguity, not executing a rule you never wrote.

Because here's what you're actually paying for. Not the answer. The hidden monologue — the plan, the re-read, the self-correction — the model consulting its own weights and re-ingesting the same context twenty times to decide a single step. Run that where a rule would have done, and you've traded a flat cost for an exponential one.

So the real question was never "AI or not." It reads three ways, and they are the same question. Is the answer knowable in advance, or does it have to be inferred? Do you write the steps, or state the goal and let something find the path? Is the logic fixed when you ship, or generated while it runs? Knowable, written, fixed — that's a switch statement, and it always will be. Inferred, stated, generated — that's the seam where the loop belongs, and only there.

The best systems aren't agentic or deterministic. They're hybrid: hardcoded logic for the ninety percent that's predictable — the fetch, the math, the compliance guard — and the model fenced into the ten percent where structure breaks down. The trouble is that line doesn't come in a framework. Drawing it means knowing, concretely, where your workflow stops being knowable — and that isn't a slide, it's a build.

For twenty-four years I've written the switch statement and paid the token bill on the loop that should have been one. That's the seat I work — not adding AI, but drawing the line where it finally earns its keep. Deterministic where the answer is knowable and cheap. Probabilistic where it's the only thing that survives the mess.