Blog · 2026-07-21 · Vynaris Team
Computer-use and browser agents: cost per completed web task when screenshots dominate the bill
A screenshot-driven browser agent costs $33.59 to $649.88 per 1,000 tasks across six vision models, a 19x spread, prices verified 2026-07-21. Step count, uncacheable screenshots, and failure-driven human takeover decide the bill, not the model.
A screenshot-driven browser agent costs between $33.59 and $649.88 per 1,000 tasks in model fees, a 19x spread across six vision models, prices verified 2026-07-21. But the model you pick is not the expensive decision. The expensive decisions are how many steps each task takes, the fact that screenshots never cache, and whether a cheap model's misclicks dump the task on a human. This is a reproducible cost model, per task, you can re-run with your own numbers.
The finding, before the model
A computer-use agent works one screenshot at a time. It sees the current screen, decides one action, clicks or types, then takes a fresh screenshot and repeats. Every step sends a new image, because the screen changed, plus a text extract of the page. That shape breaks the usual cost playbook. In a document or chat workload the big context block is stable and prompt caching removes 60% to 90% of the input bill. Here the big block is a screenshot that is different on every step, so caching recovers under a third of the bill and the step count sets the price.
We built this from public prices only. No product data. Every token count below is an assumption you can edit, and every price is from a provider's live page, captured 2026-07-21.
The workload (edit these)
One completed web task: log into a dashboard, fill a form, export a report. The agent loops screenshot to action until the task is done.
Assumption Value Note
---------------------------------------------------------------------- -------------------------------------------------------------------- --------------------------------------------------------------------------------------------------
Screenshot resolution 1280x800 px the computer-use reference resolution (WXGA)
Screenshot [visual tokens](https://vynaris.com/glossary/visual-tokens) 1,334 ceil(1280/28) x ceil(800/28) = 46 x 29, Anthropic patch formula
DOM / accessibility extract 2,500 [input tokens](https://vynaris.com/glossary/input-tokens)/step page text plus prior-action note; changes every step
Cacheable prefix 2,500 input tokens system prompt, computer-use tool definition (735 tok), tool overhead (~483 tok), task instructions
Output per step 200 [output tokens](https://vynaris.com/glossary/output-tokens) the action call plus brief reasoning
Steps per task 25 baseline; real tasks run 15 to 40Two facts decide the bill. First, the screenshot plus the DOM extract, 3,834 tokens per step, is new every step and can never be cached: 60.5% of the input on this workload is uncacheable by construction. Only the 2,500-token prefix caches. Second, everything scales with the step count. One 25-step task is 158,350 input tokens and 5,000 output tokens if you cache nothing, and a 40-step task is 60% more of both.
A note on the screenshot number. Claude prices images in 28x28-pixel patches, so a 1280x800 screenshot is ceil(1280/28) x ceil(800/28) = 46 x 29 = 1,334 visual tokens, and because 1280x800 sits under every model's downscale limit, the count is identical on Claude Haiku 4.5 through Claude Opus 4.8. We hold that token count constant across providers so the table below compares price, not tokenizer. OpenAI and Google count image tokens differently, so their real vision-token counts move a few percent either way; the structure of the bill does not.
Cost per 1,000 tasks, six vision models
Same workload, same cost-per-token math, six models that can actually read a screenshot. Uncached, then with the 2,500-token prefix served from cache. Prices verified 2026-07-21.
Model No-cache / 1k tasks Cached / 1k tasks Cache saves
------------------------------------------------------------------------- ------------------- ----------------- -----------
[Gemini 3.1 Flash-Lite](https://vynaris.com/models#gemini-3-1-flash-lite) $47.09 $33.59 28.7%
Claude Haiku 4.5 $183.35 $129.97 29.1%
[gpt-5.6-luna](https://vynaris.com/models#gpt-5-6-luna) $188.35 $134.35 28.7%
[Gemini 3.5 Flash](https://vynaris.com/models#gemini-3-5-flash) $282.52 $201.53 28.7%
[Claude Sonnet 5](https://vynaris.com/models#claude-sonnet-5) $366.70 $259.95 29.1%
Claude Opus 4.8 $916.75 $649.88 29.1%Gemini 3.1 Flash-Lite cached at $33.59 is 19x cheaper than Opus 4.8 cached at $649.88 for the identical loop. Two numbers here matter more than the spread.
Caching saves about 29%, not the 60% to 90% you see on text-heavy workloads. The reason is mechanical: only 39.5% of the input is the cacheable prefix, and the screenshot plus DOM that make up the other 60.5% pay full input-token rate on every one of the 25 steps. We measured the provider-by-provider cache-write policy behind these percentages in prompt caching in production; on this workload no policy helps much, because the bytes that cost the most are the ones that cannot be reused.
The cheapest tier on other workloads is missing here. A text-only model like deepseek-v4-flash sits near $0.14 per million input tokens, roughly a tenth of Flash-Lite, but it cannot see a screenshot, so it cannot drive this agent at all. The price floor for a screenshot loop is set by the cheapest model with vision, not the cheapest model. That is the first ceiling this workload puts on your routing.
Step count is the lever you actually control
Model choice is a 19x lever, but you rarely get to pull it, because most steps need a model that grounds well enough to click the right pixel. The step count is the lever you own. Cost scales almost linearly with it, so a task that takes 40 steps costs 2.6x one that takes 15. Here is Haiku 4.5, cached, at three step counts.
Steps per task Cached / 1k tasks vs 15 steps
-------------- ----------------- -----------
15 $79.13 1.00x
25 $129.97 1.64x
40 $206.24 2.61xEvery step is one screenshot, one DOM read, and one action. Cutting steps means better grounding, fewer retries, and fewer re-reads of a page the agent already saw. A model that finds the right button in 18 steps beats a cheaper model that flails for 35, before you even price the tokens. This is why raw per-token price is a weak predictor of the browser-agent bill: the token count per task is not fixed, it is a function of how well the model sees.
The routing ceiling: cost per resolved task
The single-model numbers above price an attempt. They do not price a result. A computer-use agent fails tasks: it misreads a modal, clicks the wrong row, loops until it gives up. When it fails, a human finishes the job, and that human is the most expensive line on the page. So the honest unit is cost per resolved task, counting both the token bill and the takeover cost of failures.
Cheap vision models ground worse. They take more steps and resolve fewer tasks without help. Frontier vision models ground better, take fewer steps, and hand off less often. Model those two profiles, with a human takeover priced at $1.50 per failed task, a few minutes of an operator's time. Success rates and step counts here are editable assumptions, not measured benchmarks; put your own in.
Strategy Cost / 1k resolved Per task vs all-Opus
------------------------------------------------------ ------------------ -------- -----------
All Gemini 3.1 Flash-Lite (55% unassisted, 40 steps) $728.40 $0.7284 +8%
All Claude Opus 4.8 (90% unassisted, 20 steps) $672.77 $0.6728 0%
Router: Flash-Lite first, escalate to Opus, then human $356.15 $0.3562 -47%The cheapest model per token is the most expensive strategy per resolved task. Running everything on Flash-Lite costs $0.7284 per resolved task, 8% more than running everything on Opus, because its 45% failure rate sends 450 of every 1,000 tasks to a human at $1.50 each. The token savings are real and they are swamped by takeover cost. This is the same shape we found in the RAG support-agent playbook, where human escalation, not the model gap, set the margin. Here the mechanism is different: vision grounding, not answer quality, is what fails.
The model router wins both pure strategies. Try every task on Flash-Lite; escalate the 45% it fails to Opus for a clean second attempt; send the 4.5% that both miss to a human. That resolves 550 tasks on the cheap model, 405 on the frontier model, and 45 by hand, for $356.15 per 1,000, which is 47% below all-Opus and 51% below all-Flash-Lite. Run your own step counts and success rates through the calculator, which takes the per-step input and output counts directly.
The break-even is a success rate, not a price. At a $1.50 takeover cost, Flash-Lite has to resolve at least 71.5% of tasks unassisted to beat all-Opus on cost per resolved task. Below that line the cheap model costs more, above it the cheap model wins outright. Measure your success rate before you pick on sticker price.
Build notes
Screenshot loops have constraints a token model does not capture.
- Latency forces the model up, which is the second ceiling. A user is often watching a browser agent work, and a 6-step-per-second cheap model that misclicks feels worse than a slower model that gets it right the first time. Interactive tasks push you toward models that ground in one pass, which caps how far down you can route regardless of price.
- Keep one screenshot in context, not all of them. If you resend every prior screenshot each step, input grows quadratically and a 40-step task balloons. Send the current screenshot plus a short text log of past actions. Past 200k tokens of accumulated context, Gemini 3.1 Pro re-rates the whole request; we quantified that cliff in the long-context surcharge post.
- Downsample before you send. Anthropic's high-resolution tier can spend up to 4,784 visual tokens on one image. A 1280x800 screenshot costs 1,334, and a 640x400 thumbnail costs far less. If the agent does not need pixel-level fidelity, shrink the image and cut the single largest non-cacheable line.
- The [context window](https://vynaris.com/glossary/context-window) is not the cost; the per-step image is. Budget from the screenshot out, not from the context limit in.
When this workload does not need a router, or a screenshot
The honest tradeoff: the cheapest computer-use agent is often not a computer-use agent. If the site is stable and the DOM is scriptable, a deterministic Playwright or Selenium script with selectors does the same job at zero token cost, and you call a vision model only for the genuinely dynamic step, a captcha-like layout or a screen the selectors cannot find. That hybrid beats every row in the table above, because it removes the screenshot entirely on the 90% of steps that do not need eyes.
Build the full screenshot loop when the target changes often, blocks automation, or has no stable selectors, the cases where a script breaks weekly and a vision model adapts. And skip the router when one model clears your success bar: if Sonnet 5 resolves 95% of your tasks unassisted, a second provider integration and an escalation path is over-engineering. Route on failure rate, not on the size of the model spread.
FAQ
What does a computer-use browser agent cost per task? On this model, $0.03 to $0.65 per task in model fees, which is $33.59 to $649.88 per 1,000 tasks cached across Gemini 3.1 Flash-Lite through Claude Opus 4.8, for a 25-step task sending a 1,334-token screenshot and a 2,500-token DOM extract per step. Prices verified 2026-07-21.
Why does prompt caching barely help a browser agent? Because 60.5% of the input is the screenshot plus the DOM, both of which change every step and cannot be cached. Only the 2,500-token system-and-tool prefix caches, so caching cuts the bill about 29% here versus 60% to 90% on workloads with a large stable context block.
Why can't I use the cheapest model, like deepseek-v4-flash? It has no vision, so it cannot read a screenshot and cannot drive the loop. The price floor for a screenshot agent is the cheapest vision model, Gemini 3.1 Flash-Lite at $33.59 per 1,000 tasks here, not the cheapest text model.
Does routing to a cheap vision model save money? Only above a success threshold. Running all tasks on Gemini 3.1 Flash-Lite costs $0.7284 per resolved task, 8% more than all-Opus, because failures fall to a human at $1.50 each. A router that escalates Flash-Lite failures to Opus costs $0.3562 per resolved task, 47% less than all-Opus. Flash-Lite must resolve 71.5% of tasks unassisted to win on its own.
What is the single biggest cost lever? The step count, followed by whether you need a screenshot at all. Cutting a task from 40 steps to 15 saves 2.6x, and replacing screenshots with DOM selectors on scriptable steps saves more than any model swap.
Sources
- Anthropic pricing (Haiku 4.5, Sonnet 5, Opus 4.8, cache multipliers, computer-use tool 735 tok + 466-499 sys overhead), captured 2026-07-21: https://platform.claude.com/docs/en/about-claude/pricing
- Anthropic vision docs (28x28-patch visual-token formula, resolution tiers), captured 2026-07-21: https://platform.claude.com/docs/en/build-with-claude/vision
- OpenAI API pricing (gpt-5.6-luna), captured 2026-07-21: https://developers.openai.com/api/docs/pricing
- Google Gemini API pricing (3.1 Flash-Lite, 3.5 Flash), captured 2026-07-21: https://ai.google.dev/gemini-api/docs/pricing
- Computer-use agent demand: Coasty (YC S26), "API for computer-use agents," Hacker News 44/26: https://news.ycombinator.com/item?id=48922706; Libretto browser automation 134/55: https://news.ycombinator.com/item?id=47780971
- Cost model script and per-task arithmetic: from the assumptions table above.
Prices change. We re-verify every figure in this post monthly and stamp updates. Numbers here are current as of 2026-07-21.
The lesson from the model: on a screenshot agent the model line is a fraction of the bill, and step count, uncacheable vision, and failure-driven human takeover decide the rest. Vynaris is an OpenAI-compatible gateway that routes each step to the cheapest vision model that can complete it, escalates on your failure signal, and shows the per-task cost. One base URL swap. Get an API key at vynaris.com.