Agent costs
An agent pays for what it looks at.
Every screenshot is image tokens, and a full screen is not a small one. Most of what a loop sends is a picture answering a question that never needed one. The figures below are ours, published in full beside the code. The design that produces the cheaper column is what we build.
What a look costs
The bill is set by how much screen is sent.
Models bill visual tokens by area. Current models accept a long edge large enough that a 1080p screenshot is not scaled down before billing, so a full screen is charged as a full screen.
| What is sent | Visual tokens | At $5 per million input |
|---|---|---|
| 1920×1080, the whole screen | 2,691 | $0.0135 |
| 1456×819, a standard-tier view | 1,560 | $0.0078 |
| 960×540, half scale, readable for layout | 700 | $0.0035 |
| 400×200, one dialog, cropped | 120 | $0.0006 |
| 200×100, one field or button | 32 | $0.0002 |
Prices as of August 2026 and for one model. Check the current rate and multiply by the token counts, which do not move. Other vendors bill differently, but the shape holds: a full screen costs one to two orders of magnitude more than a crop.
The same job, driven two ways
Twenty minutes watching an installer.
Nothing about the task changes between these two rows. The difference is in what the loop was built to ask.
| How it is driven | Image tokens | Cost |
|---|---|---|
| A full-screen look every 20 seconds | 161,460 | $0.81 |
| Waits, six full looks and twenty crops | 18,546 | $0.09 |
About ninety percent less, and the waiting is free.
In the order they save
The saving that costs more
Cropping controls what a look costs. It does not control whether the right thing was looked at.
Every rule above is about the price of a look. None is about coverage, and the two are easy to confuse on an invoice. A loop can follow all three, report a low figure, and have inspected almost nothing.
We ran the review of this site that way and it was wrong. Eleven cropped looks came to $0.035, seventy-six percent under the same work at full screen. They covered three of twenty-three pages, top of the viewport only, about three percent of the rendered area. Reading every page at full height cost $0.187 and found five defects, one of which had been live on ten pages since launch.
A fault in a page footer is invisible to a look at the top of that page at any price. Under-looking does not appear as a gap in the record. It appears as a saving.
| How the same site was reviewed | Cost | What it covered |
|---|---|---|
| Eleven cropped looks | $0.035 | 3% of rendered area |
| Every page at full height | $0.187 | All five defects |
Our own measurements, 24 August 2026, on this website.
Where the rules still hold
This is why acceptance is measured on the operator's equipment rather than quoted from ours. A number with no coverage attached is not yet evidence.
The larger half of the bill
Most of the bill is the conversation, not the pictures.
Everything above prices a look. In a loop that runs for hours, looks are not where the money goes. Each request carries the whole working context again: every result the tools returned, every page already read, every picture already taken. That is billed on every turn that follows, and it grows for as long as the session does.
The review of this site took just over an hour of working time, covered twenty-three pages and found five defects. Of roughly 99 million tokens, the pictures the agent actually looked at were about 45,000, which is less than a twentieth of one percent. Sixty percent was re-reading the conversation.
| Reviewing this site | Tokens | Share of cost |
|---|---|---|
| Carrying the context forward | 96,017,090 | 60% |
| Committing context to cache | 2,817,511 | 35% |
| What the agent wrote | 142,226 | 4% |
Measured 24 August 2026 on this website, at $15 per million input and $75 per million output, with cached context read at a tenth of the input rate and committed at twice it. Token counts do not move; check the rate for the vendor and model in use.
Caching is what makes this affordable at all. This review with no caching would have cost about six times as much. It does not remove the problem, because the cached rate still applies to the whole context on every turn.
What actually reduces it
A quote built from look prices will understate the bill for any job that runs longer than a few minutes.
The expensive mistake
A picture sent as text costs twenty-one times more and cannot be read.
A 1080p JPEG is about 169 KB. Handed to a model as an image it is roughly 2,700 visual tokens. Handed over as a base64 string it is about 56,000 text tokens, for characters no model can interpret as a picture.
It is the costliest error a tool like AMI can make, and it is invisible until the invoice arrives. Our tools return image content, and a test pins that behavior so it cannot regress quietly.
Why the waiting is free
The wait is answered by the capture service, not the model. It decodes at quarter scale in grayscale, cropped to the region in question, and counts pixels that differ past a threshold set in full-resolution terms. No image is produced and nothing is billed. It also distinguishes the two ways a wait can end: a timeout after real comparisons means the screen did not change, while a timeout with nothing compared means the eye could not look, and the two must never be reported as the same answer.
The other half of the bill
Local models carry the volume. Frontier models are an escalation.
Cropping controls what a look costs. The second question is who is asked. Most of what a loop wants to know is narrow and repetitive, runs thousands of times, and a small model on local hardware answers it at a marginal cost of nothing.
What a small model is not good at is coherence: holding a long plan together, or recovering from something genuinely unexpected. Our own comparison put it bluntly. Local hardware wins on speed by a wide margin and loses on coherence. So the frontier model is not the default worker; it is what the loop escalates to.
Where the line sits
A dedicated small model for internal classifiers and judges also keeps that traffic off the path of whatever is serving the foreground turn, so the two never contend.
What we do about it.
The cost shape is set by the tool surface, and the tool surface is part of the integration rather than something tuned afterwards. We size the regions, decide which questions return answers instead of pictures, put the boundary between the local tier and the escalation where the task needs it, and hand over the numbers for the actual workload.
If a job turns out to be an expensive way to do something an API would do cheaply, that is a finding worth giving in week one.
Where these figures come from
All of it is published, with the method, in the agentkvm repository under "What a look costs". Nothing on this page has to be taken on trust, and the token counts stay true after the prices move.