Yoda told Luke that size matters not. With all due respect to the little green guy, he never had to pay for a computer-use agent's screenshots.

Here's how I ended up down this rabbit hole. I recently pointed Claude at a web app to do some functional testing, and my usage went way up. My gut said screenshots were the culprit: the agent has to look at the screen before nearly every move, and every look costs tokens. So my tongue-in-cheek pitch for a blog post became "monitor size actually matters for AI-driven testing." But talk is cheap, so I had a small team of AI agents build and run an experiment to prove or disprove it. Let's see what happened.

Spoiler: size matters, just not in the direction you'd guess every time.

The Math You Can Do on a Napkin

Claude doesn't see pixels. It sees patches. Per Anthropic's vision docs, each image is chopped into 28×28-pixel blocks ("visual tokens"), and the cost is:

import math def visual_tokens(width: int, height: int) -> int: # Anthropic vision docs: ceil(w / 28) * ceil(h / 28) return math.ceil(width / 28) * math.ceil(height / 28) for w, h in [(1024, 768), (1280, 800), (1920, 1080), (2560, 1440)]: print(f"{w}x{h}: {visual_tokens(w, h):,} tokens") # 1024x768: 1,036 tokens # 1280x800: 1,334 tokens # 1920x1080: 2,691 tokens # 2560x1440: 4,784 tokens 

(In my runs, each screenshot actually came in 21 tokens over the formula, so 1,057 at 1024x768 and 4,805 at 2560x1440. Close enough for napkin work.)

Two more things from the docs matter here. First, Claude 4.7 and later models sit on a high-resolution tier that tops out at 2,576 px on the long edge and 4,784 visual tokens per image. That means a 2560x1440 screen lands right at the ceiling. Second, the docs say screenshots you return to the computer-use and browser-use tools that exceed those limits are rejected with a validation error rather than quietly downscaled. If your screen is bigger, resizing (and scaling the click coordinates back) is your job.

So a 2560x1440 screenshot costs roughly four and a half times what a 1024x768 one does. Case closed? Not quite. The bill isn't per screenshot. It's per task.

The Experiment

The setup, in brief:

  • Model: claude-opus-5-5 with Anthropic's computer-use toolset, run on Nov 16, 2026.
  • Browser: Chrome in kiosk mode at exactly 1024x768, 1280x800, 1920x1080, and 2560x1440, at a device pixel ratio of 1, with a fresh profile every run.
  • Context policy: only the last 3 screenshots stay in history (older ones become a text placeholder), with prompt caching off.
  • Thinking: "adaptive, low." It can't be turned off on this model, and the API rejects sampling settings like temperature, so I couldn't pin those either.
  • Volume: 10 runs per viewport per flow, with the hypotheses written down before the full runs.

And two deliberately boring test flows:

  1. TodoMVC behind a demo login. Everything fits on screen at every size, so no scrolling.
  2. Bootstrap 5.3.9's checkout example. The form runs below the fold on smaller screens, so the agent has to scroll to finish it.

Every one of the 80 main runs succeeded, with zero retries or misclicks.

Flow 1: No Scrolling, No Mercy

When the page fits on every screen, the agent does about the same work at every size, and you just pay for bigger pictures.

Viewport Tokens/screenshot Median input tokens Mean API calls Median cost/run
1024x768 1,057 37,701 5.0 $0.184
1280x800 1,355 41,127 4.8 $0.199
1920x1080 2,712 57,425 5.0 $0.271
2560x1440 4,805 82,477 5.0 $0.382

2560x1440 used 2.19x the input tokens of 1024x768, or about 2.1x the cost per run. That's a 119% token premium for the privilege of a big monitor. Hot dang.

One honest wrinkle: 1280x800 doesn't clearly cost more than 1024x768. Two of its ten runs batched the last steps into 4 calls instead of 5, and that saved more tokens than the bigger screenshots added. On a page like this, a little run-to-run behavior can outweigh one step up in screen size.

Flow 2: Where the Big Screen Earns Its Keep

On the checkout form, the smaller screens scrolled in every run. At 2560x1440, the whole form fit, and the agent never scrolled once.

Viewport Tokens/screenshot Median input tokens Mean API calls Median cost/run
1024x768* 1,057 20,395 3.0 $0.103
1280x800* 1,355 22,183 3.1 $0.111
1920x1080 2,712 30,361 3.1 $0.149
2560x1440 4,805 23,693 2.0 $0.115

* Rerun with Chrome's payment-autofill popup turned off. More on that in a second.

Here 2560x1440 used only about 1.16x the input tokens of 1024x768 (about 1.12x the cost), and about 1.07x the tokens of 1280x800. Fewer steps shrank the big-screen token premium from roughly +119% to roughly +16%.

Why? Every API call resends the conversation, which on this flow meant roughly 5,000 tokens of non-image context per call, plus the screenshots it's carrying. Skip a scroll, skip a screenshot, skip a call, and the savings add up fast. Meanwhile, 1920x1080 is the cautionary middle child: it needed about as many calls as 1280x800 and paid for bigger screenshots, so it came out the most expensive of the bunch.

The Popup That Ate My Ratio

I would be remiss if I didn't mention how this almost went sideways. In the first pass, the big screen came out cheaper than 1024x768. Great headline. Also wrong.

When a card field got focus, Chrome showed a payment-autofill popup. At 1024x768, the agent dismissed it with Escape 9 times across 10 runs, re-scrolled, and took another screenshot, which cost it an extra call almost every time (3.9 calls on average and a median of 28,850 tokens, versus 3.0 and 20,395 with the popup off). So I had the agents run a follow-up at 1024x768 and 1280x800 with the popup disabled, as a separate comparison after the main results. The extra call at 1024x768 vanished entirely.

The lesson: one incidental browser popup moved the cost of a task by roughly 40%. Your test environment is part of your token bill.

Fine Print (Trust, but Verify)

This passes the smell test, but know the limits:

  • It's small. Two simple pages, one model, one browser at DPR 1.
  • The context policy matters. I kept only the last 3 screenshots. Keep the full history and the big-screen penalty grows, because every old screenshot rides along on every call.
  • The confidence intervals are tight because the runs were nearly deterministic (all ten 2560 runs on the checkout form cost exactly 23,693 tokens). They measure run-to-run noise, not how well this generalizes.
  • Not everything was rerun. 2560x1440 and 1920x1080 weren't rerun with the popup off. 2560 never pressed Escape, so I'm comfortable comparing it. But 1920 averaged about one Escape press per run, so its number may be slightly inflated.
  • One scoring rule changed after the pilot, before the full runs, and it's documented. The original rule would have flagged 4 successful runs as refusals just because of how the agent formatted its final message.
  • Thinking was "adaptive, low," not off. It showed up in 3 runs at 1920x1080, at 43 to 51 tokens each.
  • The absolute dollars are small: about $0.10 to $0.38 per run, at list price ($4/$20 per million input/output tokens) including a 1.1x US-inference multiplier. The ratios are the story, and they compound at scale.

So What Should You Do?

  1. Start at a modest viewport. 1024x768 and 1280x800 were the two cheapest sizes in both flows here. Don't hand your agent a 4K canvas just because your own monitor is one.
  2. Size the viewport to the task. If a bigger screen removes scrolling on your key pages, it can nearly pay for itself. If it doesn't, you're just buying bigger pictures.
  3. Count calls, not pixels. Cost tracked the number of steps more than resolution. Watch your loop's call count first.
  4. Clean up your test environment. Kill autofill popups, cookie banners, and anything else that makes the agent stop and swat at the screen.
  5. Mind the ceiling. At 2560 px wide you're at the high-resolution tier's limit. Anything bigger has to be resized in your code, or the API will reject it.
  6. Trim screenshot history. Every old screenshot you keep gets paid for again on every call.

Is monitor size a cost lever? Yes, just not a one-way one. Houston, we have a tradeoff.

I'm curious what you've seen. If you're running computer-use agents for testing, what viewport did you land on, and did anything (popups, banners, infinite scroll) quietly blow up your token bill?