An agent business that runs on 33 model turns a month

Everyone selling agents has the same quiet problem: the model is the cost. Here is a working business that inverts the ratio. 92% of what it does is code. The model is the exception, not the engine.

280 deployed functions. 259 of them contain no model call at all. The whole operation, storefront, monitors, audits and all, has spent 33 model turns this month.

Self-measured 2026-11-19 from the deployed function sources. Method below so you can check the arithmetic.

The numbers

280
deployed functions
92%
pure deterministic
85,843
lines of code
33
model turns used this month
Functions deployed280
Lines of code85,843median 172 lines
Functions containing any model call218% of the total
Functions with no model call at all25992% of the total
Lines of deterministic code74,364
Functions doing entity CRUD or HTTP fetch185
Functions carrying an auth gate111
Model turns budgeted per month100
Model turns actually used3333% of budget
Integration credits used6 of 2,000

Why the ratio is the whole point

An agent that reaches for the model on every step has a cost that scales with usage. An agent that reaches for the model only when judgement is genuinely required has a cost that scales with decisions, which is a far smaller number. The difference compounds: the first architecture gets more expensive the more useful it becomes, and the second one mostly doesn't.

This is not a claim that the model is unnecessary. Twenty-one functions here call one, and they are the ones doing things a rule cannot express. The claim is narrower and more useful: everything that can be a rule should be a rule, and most of what agents do can be a rule.

How the split was enforced

Not by discipline. By a written hierarchy that every piece of work has to descend from the top:

The rule that does the most work is the third rung's test: before spending a model turn, ask whether a function could do this job. If the answer is a lookup, a measurement, or a rule, it can.

How to check this yourself

The measurement is four lines of Python over the deployed sources. Nothing here is a benchmark harness or a vendor claim. It is a count, and you can re-run it.

import os, re
LLM = re.compile(r'InvokeLLM|invokeLLM|openai|anthropic|gpt-[34o]|claude'
                 r'|chat/completions|generativelanguage|model\s*:', re.I)
files = [f for f in os.listdir('.') if f.endswith(('.ts', '.js'))]
with_model = [f for f in files
              if LLM.search(open(f, encoding='utf-8', errors='ignore').read())]
print(len(files), 'functions')
print(len(with_model), 'contain a model call')
print(len(files) - len(with_model), 'are pure deterministic')

A function counts as containing a model call if its source matches any of those patterns. That is a generous test: it catches a provider name mentioned in a comment. The real deterministic share is therefore at least 92%, not at most.

What this is not. It is not a product, and it is not for sale. It is a self-measurement of one system by the person who built it, published because the claim is checkable and because the method is more useful than the number. If you run agents at a scale where the model bill is a line item you have to defend, the architecture above is the part worth copying, and it is free.

The honest caveat

A low model-turn count is not the same as a good business. This system has run on 33 model turns a month and earned $0. Being cheap to operate and being worth operating are different problems, and the second one is harder. What the ratio buys is runway: a system that costs almost nothing to run can be wrong for a long time without dying, which is the only real advantage someone without funding has over someone with it.

Measured 2026-11-19. Delta Ridge Technologies, Arkansas. The store this runs is at /printables, the tool shelf at /api, and the machine-readable manifest at agent-manifest.json.
© 2026 Delta Ridge Technologies