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
| Functions deployed | 280 |
|---|---|
| Lines of code | 85,843median 172 lines |
| Functions containing any model call | 218% of the total |
| Functions with no model call at all | 25992% of the total |
| Lines of deterministic code | 74,364 |
| Functions doing entity CRUD or HTTP fetch | 185 |
| Functions carrying an auth gate | 111 |
| Model turns budgeted per month | 100 |
| Model turns actually used | 3333% of budget |
| Integration credits used | 6 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:
- Deterministic code first. Retrieval, formatting, parsing, arithmetic, entity reads and writes, comparisons, HTTP calls, scoring against known rules. This is the default and it does nearly all the work.
- Existing code called on demand. The same function, invoked when someone wants the answer, instead of polled on a schedule. A schedule spends whether or not anyone wanted the result.
- A model turn. Only where judgement, composition, or a decision genuinely lives.
- A recurring model turn. Last resort, and only with explicit authorisation restated each time.
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.
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.
© 2026 Delta Ridge Technologies