Blog
Updated 6 min read

Why your Chromatic bill exploded in the agent era

Chromatic pricing is per snapshot, and snapshots equal commits times stories times browsers. Agents multiplied commits, so the same coverage costs far more.

Igor LuchenkovIgor LuchenkovBuilding UI Verify
ChromaticPricingVisual testingCostCoding agents
The formula 500 stories times 2 browsers times 2 viewports times commits, with the commits term highlighted, above two bars: pre-agent, about 10 commits, 20,000 billed snapshots per developer per week; agent era, about 30 commits, 60,000.
On this page

Your Chromatic bill exploded because Chromatic bills per snapshot and coding agents multiplied the number of builds you send it: same tests, same browsers, several times the commits. Per-snapshot pricing was a fair deal for a long time. When a human opened a handful of pull requests a week, the bill tracked your team size and it barely moved. Then coding agents made every developer multiples faster, pull request and commit volume went vertical, and the same visual coverage started costing many times more. Nobody added a single test. If your Chromatic bill exploded this year and you cannot point at new tests to explain it, this is why.

Here is the whole thing in one line. A snapshot is one story rendered in one browser at one viewport, and every per-snapshot tool bills for each one on every build; Chromatic's billing docs, checked 2026-10-17, write it as tests times builds times browsers times modes. So your bill is roughly commits times stories times browsers times viewports. Three of those four terms are fixed by your app. The fourth, commits, is the one agents just multiplied.

How does Chromatic's per-snapshot pricing work?

Chromatic, like most hosted visual testing, prices per snapshot (every plan on chromatic.com/pricing is sized in billed snapshots a month, as of 2026-10-17): a fraction of a cent for each story rendered in each browser at each viewport, on each build you send. Run on every commit, every pull request update, and every merge to main, and a single UI change can trigger three full builds. The model is not sneaky and it is not wrong. It was designed for a world where a person is the thing generating builds, and a person is slow. The rate per snapshot is small precisely because the commit count it multiplied against used to be small.

The math: same coverage, triple the bill

Take a mid-size Storybook: 500 stories, 2 browsers, 2 viewports. That is 2,000 snapshots per full build. Now count builds. Pre-agent, one developer might land around 10 UI commits a week. In the agent era, one lead I talked to measured pull request volume up roughly 3x per person, before you even count the agents opening PRs in parallel.

Per developer, per weekPre-agentAgent era
UI commits that trigger a build~10~30
Stories x browsers x viewports500 x 2 x 2500 x 2 x 2
Snapshots rendered and billed20,00060,000
Coverage (what is actually tested)unchangedunchanged
Same tests, same components, same browsers. Only the commit count moved, and it moves the whole bill.

The bills match the math. Put illustrative dollars on it: a suite that ran a team around $1,200 a month at pre-agent commit volume lands near $3,500 once that volume roughly triples, on the exact same tests. Run the arithmetic forward and it does not stop there: say the suite grows to half a million snapshots a quarter, and even a keen enterprise rate of half a cent per snapshot lands you in five figures a year. The coverage never moved to get there. The commit count did.

Why did the agent era break per-snapshot pricing?

Per-snapshot pricing quietly assumed a human bottleneck on the commit term. A person reviews their work, batches changes, opens a pull request when it is ready, and does that a few times a week. That rhythm kept the multiplier small and stable, so the tool could charge per snapshot and stay cheap. Agents removed the bottleneck. They push more often, they open pull requests in parallel, and every push re-renders the suite. The term that used to be a small constant is now the entire shape of the bill.

Our own repo, built by one developer working with coding agents: 40 to 157 Storybook visual-test runs a week since July. Every run uploads the whole Storybook, about 300 stories today.

There is a second, quieter problem. When your pull request volume triples, you are not spending triple the time reviewing visual checks. So most of those extra runs are renders nobody actually looks at. You are paying full price per snapshot for builds that get a glance at best, which is a strange thing to scale linearly with your commit count.

Eight product cards changed on this storefront. The judge checked the change against the PR's stated intent, confirmed only the rating badges moved, and marked it intended, so a reviewer reads one sentence instead of scanning the grid.

How do you get out of the commit multiplier?

Two levers get you out, and they compose. One shrinks the terms you control. The other changes how the commit term is billed.

Cut the snapshot count

Fewer stories means fewer of every term: fewer snapshots per browser, per viewport, per commit. Two patterns do most of the work, dense gallery stories and data-driven states, and they can cut a component's snapshot count up to 10x with the same coverage. This is the cheapest change you can make and it works on any per-snapshot tool, Chromatic included. I wrote the full playbook in How I cut my Chromatic bill 10x.

Stop paying full price for unchanged work

The deeper fix is to stop paying full price for stories that did not change. With skip-unchanged, a 3-line change renders only the stories it actually affects and carries the rest forward, so a busy branch does not re-bill 2,000 full snapshots on every push. That defuses the commit multiplier directly: more commits stop costing a full suite each. On UI Verify it is skip-unchanged, on by default, and a carried-forward story is not billed (snapshot billing). Chromatic's version is TurboSnap, and the same Chromatic billing docs count a snapshot it copies forward at 0.2. The other half is review. If your tool renders a diff and hands it to a human, every extra commit is another image you have to eyeball. An AI judge triages the diffs and tells an intended change from a real regression, and over MCP your agent reviews and accepts, so the review cost stops scaling with commits either. That difference is the whole of UI Verify vs Chromatic.

A real merge to our main branch. The commit touched one component used only by the landing page, so the run rendered its two viewports (2 of 301) and carried the rest forward. The build passed about a minute after upload.
The pricing model was never the problem. Per-snapshot was a fair trade when a human capped your commit rate. The agent era removed that cap, so the fix is to stop billing unchanged work at full price on every commit, not to argue about the rate.

When is Chromatic still the right call?

Chromatic is still the right call when you want accessibility checks in the same run as your visual tests, or you are not commit-bound. Chromatic is very good, and for plenty of teams it is still the right tool. It is made by the maintainers of Storybook, it runs axe accessibility tests alongside the visual ones, its paid plans add Firefox, Safari and Microsoft Edge to Chrome (pricing table; all three pages checked 2026-10-17), and it has a mature review workflow a lot of teams standardize on. In either case the per-snapshot model is fine and Chromatic runs it well. The point of this post is narrow: the assumption that made per-snapshot cheap is the one the agent era changed.

For the record, our own numbers are public and flat. UI Verify includes 10,000 snapshots a month free (50,000 for open-source projects), paid plans start at $89 a month for 30,000 snapshots, and overage is $0.004 per snapshot. The pricing is not the moat, though. Skip-unchanged (Chromatic has its own, TurboSnap) plus an AI judge your agent reviews with over MCP is what attacks the term that actually exploded.

If your bill jumped this year and your test count did not, you are not imagining it, and you are not doing anything wrong. The input changed. Cut the stories you can, stop paying to re-render the ones that did not move, and let review scale with real changes instead of raw commits. The economical visual tests skill will refactor the exploding stories for you, and it is free.

Stop paying per commit

UI Verify is visual testing that does not punish commit volume. Skip-unchanged carries an untouched story forward free instead of billing it in full on every push, and an AI judge labels the diffs so your agents review and accept over MCP. The free tier is 10,000 snapshots a month (50,000 for open-source projects).

Start for free

No credit card required.

ShareXLinkedIn
Related skill

Write economical visual tests

Full visual coverage in the fewest billable snapshots.