The Agent Bill Is in the Boring Steps: Stop Paying Frontier Prices to Choose a Button

For solo founders and small teams shipping a computer-use, browser-use, or ops-automation agent — anyone whose product's margin and latency live in a loop that runs step after step.

---

The first screen: the same "which button?" call costs $0.06 or $10.17 per thousand — a 170x spread

On October 19, 2026, Nace.AI released Drex Max, a multimodal model built for computer-use and browser agents. You give it a screenshot, a screencast, a scanned document, a chart or a photo plus a set of typed questions. One forward pass returns a probability for every option you supplied. It writes no text at all. (Nace.AI — Introducing Drex Max; model page, pricing table.)

The release itself is a small startup's launch. The thing it makes visible is not. Look at the vendor's own cost and latency table, one row per model, priced per 1,000 decisions (nace.ai/drex):

| What you send the step to | Cost per 1,000 decisions | Median API latency |

|---|---|---|

| Drex Max (specialized decision model) | $0.06 | 183 ms |

| Drex v1.5 (smaller, cheaper) | $0.04 | 145 ms |

| GPT-6 Sol (frontier) | $3.33 | ~2.0 s |

| Claude Opus 5.5 (frontier) | $10.17 | ~3.5 s |

Per decision, the specialized model is roughly 55x cheaper than GPT-6 Sol and ~170x cheaper than Claude Opus 5.5, at ~11x to ~19x lower latency. That is not a rounding error. That is the difference between a margin and a bill.

Here is the uncomfortable part. On the same table, the frontier models still win wherever the task needs open-ended reasoning or knowledge: Decision Bench 94.7 / 95.6 vs Drex Max's 94.3; MMLU-Pro 93.0 / 94.0 vs 72.5; HLE 39.0 / 56.0 vs 19.0 (nace.ai/drex). So this is not "small models beat the frontier." It is narrower and more useful than that: the frontier is the wrong tool for which button, and the right tool for why.

Two independent lines of research point the same way. A subtask-level routing framework (RSI-router) that assigns work between a large and a small model "consistently surpasses the DeepSeek-only baseline at roughly half the inference cost (48.3%) across five agentic benchmarks," cutting cost 74.7–82.2% on ALFWorld, ScienceWorld and WebShop while improving performance (arXiv:2609.34712). And StateAct, a code-first computer-use harness, calls its screenshot-and-click subagent on only 28 of 108 tasks and 1.1% of the main agent's steps — reaching ~9x lower cost per task and lifting Claude Opus 4.8 on OSWorld 2.0 from 20.6% to 26.9% binary success, because it reads program state instead of paying for pixels it does not need (arXiv:2607.22798).

By the end of this piece you have two things you can use on your own loop this week:

  • The reframe — an agent step is usually a decision, not a generation, so your cost and latency scale with steps × per-step model price**, and the expensive reasoning step is a rounding error next to the thirty boring ones.
  • The Model-to-Step routing card plus a three-step inner-loop audit** — a per-step classification you can run on one representative task, and a way to price it (cost per decision × decisions per task) before you trust anyone's headline ratio.

Here is where we are going:

  • The thing as it is usually presented** — "the agent is only as smart as its model."
  • The part nobody explains** — a step is a decision, not a generation, and you have been paying generation prices to classify.
  • Why that part matters** — the cost is steps × per-step price, and the inner loop is the bill.
  • How to use it** — the Model-to-Step routing card and the inner-loop audit.
  • The misunderstanding that trips everyone** — "just use a cheaper general model," and why that fix fails.

---

1. The thing as it is usually presented

The default instinct is to reach for the largest, most capable model for every step of the loop. It demos well, it is what the launch posts celebrate, and it has a comforting logic behind it: the agent is only as smart as its model, so a smarter model makes a smarter agent. Vendors reinforce the instinct for free, because every screenshot-to-frontier call is billable tokens.

It is not stupid. It is last year's playbook — and for a while it was the right one. Choosing which button to click, which field to fill, which search result to open, or whether the page has finished loading really did require a frontier model, because there was no other way to interpret a screen. Nace states the old reality plainly:

"A computer-use agent spends most of its time on small decisions. Which button to click. Which field to fill. Which search result to open. Whether the page has finished loading. A single task can take thirty of them, and today each one usually means sending a screenshot to a large frontier model and waiting seconds while it writes an answer." (nace.ai/blog/introducing-drex-max)

Thirty small decisions per task. Every one shipped to a frontier model. Every one waiting seconds for generated tokens to come back. That is the loop — and it is where the money goes.

2. The part nobody explains

Everyone treats "each agent step needs the frontier model" as obvious. Nobody explains that the step is usually a decision, not a generation — and that a generative model is priced as if you asked it to write an essay when all you wanted was a choice from a list.

Here is the mechanism in one line, from the vendor:

"A generative model pays for every token it writes. Drex Max writes nothing, so a decision costs one pass over the input no matter how many options it scores." (nace.ai/blog/introducing-drex-max)

Read that against how a generative model works. A frontier model samples output tokens one at a time, and you pay for every token it writes — including the chain-of-thought and the JSON scaffolding around an answer that was, in the end, one of five buttons. A decision model instead takes a fixed option set you supply and scores all the options in a single forward pass, returning a calibrated probability for each. If the step is "which of these five buttons," you have been buying generation prices for a classification.

The open-weights sibling makes the construction concrete. Drex DLM is built on NVIDIA's Efficient-DLM-8B diffusion language model plus a small pointer head: the shared context (state) uses bidirectional attention, each question branch attends to the context with causal attention within itself, and a shared pointer head projects the decision marker and each option-ending marker into a query and keys. Scaled dot products plus a softmax over each question's options give the probabilities — all questions scored in one pass (huggingface.co/nace-ai/drex-dlm).

The practical consequence is that a decision model cannot invent an option you did not offer. There is no token stream to truncate, no malformed JSON to repair, no hallucinated choice outside your set. A generative model can. A scoring model can only answer with the options you gave it. (That does not make the chosen option correct — see the precision notes. It only makes the output shape bounded.)

3. Why that part matters

Because an agent's cost and latency scale with steps × per-step model cost, not with the difficulty of the final answer.

A computer-use task can be ~30 small decisions. Today each one ships a screenshot (image tokens) to a frontier model and waits seconds for generated tokens back. The one clever reasoning step — the plan, the synthesis, the explanation — is a rounding error by comparison. The inner loop is the bill. The reasoning step that makes the demo look smart is not.

And the per-step price is not fixed by physics; it is fixed by which tier you send the step to. The same "which option?" question that Claude Opus 5.5 answers for $10.17 per thousand and ~3.5 s, Drex Max answers for $0.06 and 183 ms (nace.ai/drex). Small harness choices move the same bill even more quietly: in a published computer-use field evaluation, dropping screenshot resolution from 1280×720 to 960×540 cut cost from $10.10 to $7.35 per 70 tasks — 31.3% fewer model input tokens — with the pass count holding (25/70 to 29/70). The cheaper 800×450 setting cost even less ($6.44) but passed fewer tasks (24), so it is a cost-only option, not the default (arafatkatze.com/computer-use-field-notes).

Two honest asides, so you do not overcorrect.

First, the frontier still earns its price on the reasoning steps. The same vendor table that makes the small model look cheap shows GPT-6 Sol and Claude Opus 5.5 ahead on every open-ended-reasoning benchmark (nace.ai/drex). The specialized model wins the small per-step decision role, not open-ended thought. Do not fire your frontier model; stop using it to pick a button.

Second, sometimes the right move is to stop looking at the screen at all. StateAct's result is not "route decisions to a cheaper model" — it is "read the program state (files, DOM, app backends) before you pay for pixels, because a screenshot is only a lossy rendering of the underlying state." When it did, it needed the screenshot subagent on 1.1% of steps (arXiv:2607.22798). Where the state is readable, perception is a cost you should not be paying for at all.

4. How to use it: the Model-to-Step routing card, and the audit

The transferable discipline is a per-step classification. The tier follows the step, not the task.

The Model-to-Step routing card

  • DECIDE — fixed option set. "Which of these buttons / fields / results / routes / labels?" Send it to a cheap scoring model** that returns a probability per option. Threshold the confident calls; act on them without reading a word.
  • REASON — open-ended planning and synthesis. The plan, the explanation, the multi-step judgment with no fixed answer list. Keep the frontier model here.** This is what you are paying it for.
  • PERCEIVE — getting the facts. Prefer program state over screenshots** wherever the screenshot is only a lossy proxy of state (files, DOM, API/app backends). Fall back to pixels only for the steps that genuinely need them.
  • ACT / VERIFY — deterministic work.** Run your code, not a model, wherever possible. Write the result, check the file landed, compare the counts. Models are the wrong tool for a if statement.

Then apply the escalation rule the vendor's own deployment guidance describes, and which the routing literature formalizes: "threshold the confident calls, route the uncertain ones to a person, and tune the model] on your own labelled outcomes" ([nace.ai/llms.txt). The uncertain calls — the ones where the probabilities are close — are exactly where a wrong cheap decision does the most damage.

The three-step inner-loop audit

  • Count the steps in one representative task.** Not the happy path — a real run. How many decisions, how many reasoning calls, how many times you re-read the screen?
  • Sort them into DECIDE / REASON / PERCEIVE and price each at its current tier.** Multiply steps by the per-decision cost of the model each one currently runs on. The DECIDE row is usually the one that startles you.
  • Move the DECIDE steps off the frontier and re-measure cost per completed task.* Not cost per decision — cost per task that actually finishes, with the pass count beside it, the way the screenshot experiment reports $7.35 and* 29/70 (arafatkatze.com). If the pass count drops, you did not save money; you moved the cost downstream.

The research supports the shape without a research budget: subtask-level routing cut inference cost by roughly half across five benchmarks and 74.7–82.2% on three of them with performance gains, and a state-first harness reached ~9x lower cost per task (arXiv:2609.34712; arXiv:2607.22798). You are not inventing a technique. You are applying a published one to your loop.

5. The misunderstanding that trips everyone

The lazy reading of all this is "just use a cheaper general model for everything." It fails, and the vendor's own table is the proof: swap your whole loop to a small general model and you lose the reasoning and knowledge steps you cannot fake — GPT-6 Sol and Claude Opus 5.5 lead Drex Max on Decision Bench, MMLU-Pro and HLE (nace.ai/drex). The cheap model is a tool for small per-step choices, not a replacement for the frontier.

The second trap is subtler: assuming per-decision savings are per-task savings. They are not the same number, and no source here measures the end-to-end conversion for you. The $0.06 vs $10.17 ladder is priced per 1,000 decisions at the vendor's chosen option count. Your real saving depends on decisions-per-task, image-token load, and the added routing and verification overhead — and RSI-router and StateAct each measured their own setups, not yours (arXiv:2609.34712; arXiv:2607.22798). That is why the audit ends on cost per completed task, not cost per decision.

The third trap is the one this whole piece is about: paying generation prices to decide. If you take one thing, take the mechanism — a step is usually a decision, the cost is steps × per-step price, and the boring inner loop is the bill.

Where you will get stuck

  • You will reach for the biggest model on every step** because the demo looks smarter and the vendor's marketing rewards it — and quietly pay 100x+ for classification.
  • You will "save money" by downgrading the whole loop to a cheap general model** and lose the reasoning steps the frontier was actually earning its price on.
  • You will trust the per-decision ratio as if it were per-task** and ship a saving that evaporates once routing overhead and wrong-decision costs are counted.
  • You will keep paying for screenshots** when the program state (files, DOM, backends) was readable the whole time — the pixels were a lossy proxy you did not need.
  • You will threshold nothing.** A cheap decision model with no confidence threshold and no human escalation path is just a cheaper way to be wrong.

What to do first

Do not rewrite your stack today. Do one thing: run the audit on one representative task and price its DECIDE steps.

  • Pick your longest, most-expensive real task** — the one that makes you wince at the bill and the wait.
  • List its steps and tally them** into DECIDE / REASON / PERCEIVE. Most teams find the DECIDE steps dominate by count.
  • Price the DECIDE row at your current model's per-decision cost.** That number is the opportunity, not the saving — yet.
  • Route just that row to a cheap scoring model with a confidence threshold**, and escalate the close calls to a person or the frontier. Ship nothing else changed.
  • Re-measure cost per completed task with the pass count beside it.** If cost falls and passes hold, you have a unit-economics change you can defend to a team or an investor — "we fan the decisions out to a scoring model; the frontier only reasons." If passes drop, you have found the error economics nobody has published for you yet. Either result is worth more than the vendor's ratio.

The compressed ending

Remember it in four beats:

  • A step is a decision.** "Which button" is a classification with a fixed option set — and a generative model pays for every token it writes to answer it.
  • The bill is steps × per-step price.** A task can be ~30 small decisions; the inner loop, not the demo-smart reasoning, is what you are paying for.
  • Match the tier to the step, not the task.** DECIDE → cheap scoring model with a threshold; REASON → frontier; PERCEIVE → program state before pixels; ACT/VERIFY → deterministic code.
  • Price it per completed task.** Cost per decision × decisions per task, with the pass count beside it — before you trust anyone's 55x or 170x.

The intelligence does not need to be expensive at every step. Pay for reasoning; stop paying frontier prices to decide. Your agent's margin lives in the boring steps — which is exactly where nobody has been looking.

---

Sources

  • Nace.AI — Introducing Drex Max, a multimodal decision model for computer use (primary, 2026-10-19) — release post; the "$0.06 per million input tokens, output not billed" pricing, 262K-token context, generally available; the "writes nothing" mechanism; the computer-use field-imaging copy; benchmark table (Decision Index 0.3.2; Decision Bench 94.3 vs 94.7 / 95.6; MMLU-Pro 72.5 vs 93.0 / 94.0; HLE 19.0 vs 39.0 / 56.0; per-1k-decision cost and median latency rows).
  • Nace.AI — Drex model page (primary) — the cost/latency table ($0.06 / $3.33 / $10.17 per 1,000 decisions; 183 ms / ~2.0 s / ~3.5 s), the Decision Index context (0.3.2 in the launch copy vs the 0.2.1 board on this page), the "rank candidates / act when one option leads / send the case to a person when probabilities are close" usage pattern, and the "Drex cannot generate text, so it cannot invent an option outside your set — that does not make the chosen option correct" caveat.
  • Nace.AI — llms.txt (primary) — deployment guidance: "Put a decision model inside a workflow: threshold the confident calls, route the uncertain ones to a person, and tune Drex on your own labelled outcomes"; seed round ($21.5M, 2026-05-05) and founding (2024); Drex 2.0 ships open weights; Drex Max is API-only.
  • Hugging Face — nace-ai/drex-dlm (primary, open weights) — the mechanism: Efficient-DLM-8B + pointer head, bidirectional shared state, per-question causal branches, softmax over each question's options in one forward pass; CC BY-NC 4.0 weights, Apache-2.0 code.
  • RSI-Router — arXiv:2609.34712 (independent, submitted 2026-09-28) — subtask-level routing between DeepSeek-V4.1-Flash and Qwen3.5-9B; "roughly half the inference cost (48.3%) across five agentic benchmarks"; 74.7–82.2% cost cut on ALFWorld/ScienceWorld/WebShop with performance gains; Terminal-Bench 2.0 16.7% relative gain at 18.0% lower cost.
  • StateAct — arXiv:2607.22798 (independent, submitted 2026-07-24) — code-first harness; GUI subagent on 28 of 108 tasks and 1.1% of main-agent steps; OSWorld 2.0 binary success 20.6% → 26.9%, partial 54.8% → 61.6% at ~9x lower cost per task; code-only variant 45.9% partial (below the screenshot baseline).
  • Arafat Katze — Eval runs to improve Computer use UX (independent field notes, July 2026) — 1280×720 $10.10 / 25-of-70 → 960×540 $7.35 / 29-of-70, 31.3% fewer input tokens; 800×450 $6.44 / 24-of-70 as a cost-only option.

Precision notes. (a) The headline rank is vendor-scoped. Drex Max is "first among decision models" on Nace's own Decision Index 0.3.2, and the model page itself notes GPT-6 Sol and Claude Opus 5.5 are shown "for reference; they are not scored on the Decision Index." The index version moves between Nace's own pages (0.3.2 in the launch post, 0.2.1 on the Drex product page), so treat every index score as a snapshot, not a fixed fact. (b) The vendor's own table contradicts a lazy "small models beat the frontier" reading — the cheap decision model trails GPT-6 Sol and Claude Opus 5.5 on Decision Bench, MMLU-Pro and HLE — so the honest claim is narrower: the specialized model wins the small per-step decision role, not open-ended reasoning. (c) Cost per decision is not cost per task. The $0.06 vs $10.17 ladder is priced per 1,000 decisions at Nace's chosen option count; end-to-end savings depend on decisions-per-task, image-token load, and added routing/verification overhead, and the independent papers each measure their own setups. (d) No independent, task-level benchmark exists of a Drex-style decision model inside a real production loop versus the same loop run entirely on a frontier model; the $/task saving here is inferred from per-decision pricing, not measured end-to-end. (e) No error economics are published — nothing in these sources reports how often a cheap per-step decision is wrong, what a wrong decision costs downstream, and the RSI-router/StateAct savings come from their own harnesses. (f) Nace.AI is a young, venture-backed startup (founded 2024; $21.5M seed announced 2026-05-05); the frontier Drex Max is API-only, with only the smaller Drex 2.0 shipping open weights, so hosting, lock-in and price-stability are unproven. (g) The transferable reframe — a step is a decision not a generation, the bill is steps × per-step price, and the tier should follow the step — is this piece's inference from the vendor's mechanism and the two independent research results; it is an argument, not a documented product incident. (h) The "$0.06 vs $0.04" note: Drex v1.5 is priced below Drex Max on the same table, so "cheaper" is not the same as "newest."

---

X entryway list (from the approved angle)

The five distribution entryways named in the angle brief. Hooks are not yet written as posts — this names each post's type, the one claim or mechanism it carries, and whether it links.

  • Hook type: surprising proof. The same "which button?" call costs $0.06 and 183 ms per 1,000 decisions on a specialized decision model, versus $3.33 / ~2.0 s on GPT-6 Sol and $10.17 / ~3.5 s** on Claude Opus 5.5 — ~55x and ~170x cheaper, ~11–19x faster. "Where does the money go?" stops being an opinion. → Links to article (the number stands alone; the article supplies the mechanism behind it and the routing rule that acts on it — the link is the deepening, not the point).
  • Hook type: mechanism.* A step is a decision, not a generation*. "A generative model pays for every token it writes. Drex Max writes nothing, so a decision costs one pass over the input no matter how many options it scores." That is why a "smart" frontier model is the wrong tool for "which button" — you have been paying generation prices to classify. → Links to article (self-contained mechanism; the article carries the pointer-head construction and generalizes it to the reader's own loop).
  • Hook type: build sequence / workflow.** The Model-to-Step split a solo dev can ship: classify each step DECIDE / REASON / PERCEIVE, run DECIDE on a cheap scoring model with a confidence threshold, escalate the close calls to a person or the frontier, keep REASON on the frontier, and prefer program state over screenshots. → Links to article (the workflow is the actionable bit; the article is the why behind each rule, plus the auditor's three steps).
  • Hook type: risk. Cost and latency scale with steps × per-step model price**, so a long loop run entirely on a frontier model is how agent products quietly lose money and time — the inner loop, not the demo-smart reasoning, is the bill. → Links to article (names the trap; the article turns it into the tier-follows-the-step rule and the audit).
  • Hook type: result.** An agent loop that keeps its capability for hard reasoning and moves the per-step decisions to a scoring model cuts the ~30-step inner-loop bill by roughly an order of magnitude — a unit-economics change, not a quality compromise, that a builder can defend: "we fan the decisions out to a scoring model; the frontier only reasons." → Links to article (concrete before-and-after; the article grounds it in RSI-router's ~half-cost and StateAct's ~9x-lower-cost-per-task results, and the audit that proves it on your own task).

Hook-type map: 1 = surprising proof; 2 = mechanism; 3 = workflow; 4 = risk; 5 = result. All five link, and each link is a bonus — every post carries a claim that stands on its own. These are the five entryways the angle brief named; no additional entryway was invented, and no entryway repeats another's hook.