There's a lot of talk about what agents can do. There's almost no honest talk about what they cost to run. Everyone's happy to show you the demo. Nobody wants to show you the bill.
We run a real fleet of autonomous agents — on our own hardware, doing real work, every day. So we have a pretty clear picture of where the money actually goes. And the honest answer is: the expensive part isn't what you'd guess.
The trap: everyone thinks it's the tokens
The natural assumption is that running agents is expensive because of the model calls. Every time an agent thinks, it's spending tokens, and tokens cost money. So the instinct is to shop for the cheapest model, squeeze the context, and treat inference as the thing to optimize.
That's not where the money goes. Not even close.
The diagnosis: the cost is the rails, not the models
When you actually run agents for real, the cost breaks down into a few categories — and the model inference is the smallest one:
- The infrastructure. The hardware, the storage, the network, the power. This is a fixed cost you pay whether the agent does anything or not.
- The plumbing. The integration layer — the code that lets an agent talk to your systems, the guardrails, the monitoring, the stored procedures. This is where the real engineering effort goes, and it's the part that has to be maintained forever.
- The human time. The person who watches the watchman. The one who reviews what the agent did, catches the edge cases, and fixes the things that break. This is the most expensive line item, and it's the one nobody budgets for.
- The model calls. The actual inference. And here's the thing — this is the cheapest part, because it's the one you can tune. You can pick a smaller model for routine work, a bigger one for the hard stuff, and route accordingly.
The pattern is the same every time: the value and the cost both live in the rails, not the models. The model is a commodity. The plumbing around it is where the money is — and where the value is.
The fix: spend where it pays off
Once you see the cost structure clearly, the strategy writes itself:
- Don't over-optimize the tokens. The model call is the cheap part. Spending hours shaving a few cents off inference while ignoring the maintenance burden is optimizing the wrong thing.
- Invest in the plumbing. The guardrails, the monitoring, the stored procedures — this is what makes an agent trustworthy, and it's what you're actually paying for.
- Budget for the human. The person who reviews the agent's work isn't overhead. They're the safety net that makes the whole thing safe enough to run. Skimping there is how agents go wrong.
The guardrail: price the outcome, not the compute
Here's the part that matters for anyone who's thinking about buying or selling agent services. If you price agents by the compute — by the tokens, by the hours — you're pricing the wrong thing. The value isn't the model call. It's the outcome: the work done, the guardrails that kept it safe, the discipline that made it trustworthy.
That's why agent services are priced the way they are. Not because the compute is expensive — it isn't. Because the rails are expensive, and the rails are where the value lives. When you buy an agent, you're not buying tokens. You're buying the system that makes the agent worth trusting.
The takeaway
The economics of running agents are backwards from what most people assume. The model is the cheap part. The infrastructure, the plumbing, and the human oversight are the expensive parts — and they're exactly the parts that make an agent worth running at all.
So the next time someone asks what an agent "costs," the honest answer isn't a price per token. It's a question: what are the rails around it? Because that's where the money is — and where the value is.
← Back to Field Notes