- Claude is priced fairly for reasoning. The expense comes from re-invoking it on every step of a repetitive job: CRM updates, report pulls, ticket routing, portal logins.
- On the same multi-step task, a compiled agent finished in 1m 21s at $0.063 versus 7m 58s at $6.26 for a model-per-step run on Claude (Opus 4.7): roughly 6x faster and 1 percent the cost at scale.
- Agency, a model deciding the next action, is worth the most the first time you do a task and less on later repeats.
- Airtop compiles the repetitive steps once, and keeps AI reasoning for the judgment calls that are genuinely novel each run.
- You don't have to give up Claude Code. Assign the repeat jobs to Airtop.
Most teams misdiagnose a high Claude bill. Claude isn't overpriced for reasoning. The problem is calling a reasoning model for every step of a job it already solved: CRM updates, report pulls, ticket routing, portal logins. Those are different problems, and only one is about how the work is run.
Claude is good at judgment: deciding whether a lead is real, matching messy data to a schema, flagging a record for review. That work is worth paying for. Asking Claude to re-decide a sequence it already solved the first time is a different kind of spend.
Where the cost comes from
Anthropic prices Claude for what it is: a capable reasoning model. Per token, that's a fair trade for genuine judgment. The trouble starts when an agent treats every already-solved step as a fresh reasoning problem worth a full model call.
That's a problem in how many agents get built, not a complaint about Claude's pricing. A model-per-step loop pays for reasoning on tasks that don't need reasoning anymore, because the agent already worked out the steps the first time it ran.
A model call for every repeat
A typical model-per-step agent works like this: send the current state to the model, ask it to reason, get back an action, execute it, repeat. Every already-solved step triggers a new round trip to the model.
That adds up fast. Code-first agents need fewer reasoning steps to complete the same task, and model-per-step agents carry roughly 3.87x the token overhead by comparison, according to Airtop's analysis showing code-first agents need fewer reasoning steps. None of that overhead buys better judgment. It buys the same judgment, priced out again.
Agency has diminishing returns after the first run
Agency, a model's ability to decide its own next action, is genuinely useful the first time an agent encounters a task. It has to work out the login flow, the button layout, the page structure. That's real reasoning work.
Run the same task a hundred times, and the agent keeps making decisions it already made the first time. Airtop's research on this is direct: the value of agency is highest the first time and lowest the hundredth time. Computer-use models also show 20 to 60 percent run-to-run variance on identical tasks, per that same breakdown. Teams pay premium reasoning prices for a process that isn't even consistent.
The benchmark: same task, wildly different cost
Airtop ran the same multi-step task two ways: once as a compiled agent, once as a model-per-step run on Claude Code (Opus 4.7). A compiled agent finished in 1m 21s at $0.063. The model-per-step version took 7 minutes 58 seconds and cost $6.26.
Same task, two execution strategies, different bills.
Per run, $6.26 versus $0.063 might look like rounding error to a team testing a demo. Run that task a thousand times a month, across a thousand leads or a thousand accounts, and the gap becomes the line item finance asks about. The performance gap between a model-per-step agent and a compiled one holds across benchmarks: roughly 6x faster, and at scale, close to 1 percent the cost.
Claude didn't get more expensive. Architectures keep re-paying for the same reasoning on every run, at every step, indefinitely.
What Airtop compiles, and what should remain a reasoning call
Some steps in a workflow are genuinely variable every time. Is this a real lead or a duplicate? Did the source change since last week? Should this record get flagged for review?
Those are judgment calls. Airtop keeps them as AI reasoning, because the answer depends on the specific input in front of the model, and no two runs look quite the same. That is not the same thing as asking a human to sort work into Claude versus Airtop.
Logging in, pulling a known report, writing a row to a CRM, routing a ticket through a fixed sequence: none of that is a judgment call after the first run. Fixed sequences don't need a reasoning model re-deciding them every time. Airtop compiles those steps.
Some of this work does not need a browser at all. If structured data is available through an API, check when an API would have been cheaper before reaching for any agent. When it isn't, because the target is a legacy portal or a site with no API, Airtop runs it in a real browser instead of a screenshot loop.
How teams cut the bill without cutting Claude out
The architectural fix Airtop uses is straightforward: reason once, at build time, then compile the result. A model works out the ambiguity, the login flow, the page structure, the extraction logic, once. That gets compiled into code that runs like software from then on, calling a model only where the work is genuinely variable.
This is what "deterministic AI" means in practice: same input, same output, at runtime, with no prompt re-evaluated on every single run. Airtop's Agent Builder is built around this pattern: compile the repetitive steps and keep the model for what's genuinely variable.
The same problem shows up in everyday GTM automation, where enrichment and monitoring tasks repeat thousands of times a month, as Airtop covers in its look at what GTM engineers do. Every repeat is a chance to overpay for reasoning already done once.
None of this requires abandoning Claude Code. Assign the repeat jobs to Airtop. Claude can still plan, orchestrate, and make the judgment calls. Airtop compiles the repeats into a deterministic agent and runs them.
Keep Claude Code if that's where you work. Assign the repeats to Airtop so the per-run cost drops from dollars to cents. If you'd rather skip the setup entirely, you can also hand the whole workflow to Mark.
FAQs
Why does a Claude bill blow up on repetitive work?
Claude isn't more expensive for one kind of task than another, per token. The cost balloons because many agents call Claude once per step instead of once per task. A ten-step workflow becomes ten separate reasoning calls, each priced like fresh judgment even when the steps match last week's run.
Is Claude itself overpriced, or is it how agents use Claude?
It's the calling pattern, not the model. Claude is priced fairly for reasoning, and that reasoning is genuinely valuable for judgment calls, like deciding whether a lead is real. The expense shows up when an agent treats repetitive, already-solved steps as new reasoning problems on every run.
What's the difference between a model call and a compiled step?
A model call sends current state to Claude and asks it to decide the next action, every time, at runtime. A compiled step is a fixed sequence Airtop already worked out once at build time, and that now runs like software, with no model re-evaluating the decision on each execution.
How much cheaper can the same workflow get without dropping Claude?
On the benchmark Airtop published, a compiled agent finished in 1m 21s at $0.063 versus 7m 58s and $6.26 for the same task run model-per-step on Claude Code (Opus 4.7). At scale, that gap holds at roughly 6x faster and close to 1 percent the cost.
Can I keep using Claude Code and still cut the bill?
Yes. Keep Claude Code. Assign the repeat jobs to Airtop. Claude still handles planning and judgment. It stops paying for the same decision on every run.
What kinds of steps stay a reasoning call?
Anything where the answer depends on the specific input that run: whether a lead is a duplicate, whether a source still matches your schema, whether a record needs a human review flag. Airtop keeps those as reasoning calls. Claude is the right tool for that judgment.
Does this approach require rebuilding my whole automation stack?
No. The fix is at the level of a single workflow, not a full stack rebuild. Airtop compiles the repetitive steps and keeps judgment as a reasoning call. Existing tools like n8n, Make, or Zapier can keep orchestrating around the compiled agent.
Is a browser even the right tool for every one of these tasks?
Not always. Some data is available through an API, and checking when an API would have been cheaper than a browser in the first place is worth doing before building any agent. When the target is a legacy portal or a site with no API, a browser, ideally a compiled one, is the right call.
Try Airtop For Free
Spin up your first agent in five minutes and see the same task run compiled instead of model-per-step. Try it for free.
