How AI Counts Things

and Why It Gets Them Wrong the Way You Do

Ask a person how many dots are in a quick flash of a picture and something interesting happens. If there are just a few, they’ll tell you exactly how many without seeming to count. But if there are thirty, they’ll give you an estimate.

Interestingly, the estimate is often a little off in a particular way: people round. They say “about twenty-five” or “thirty-ish,” landing on the round numbers rather than a specific value, like 27. But give someone time to count, and they switch tactics. Sometimes scanning along rows or breaking the picture into chunks. We use strategies to count accurately, keeping a mental tally of which items we’ve counted.

But even careful counters can come up short. In an image with lots of objects, a few get lost at the seams between the chunks or are simply overlooked.

One of the dot pictures we showed the models. Try it yourself: glance, don’t count, and write down your first number. Then count.

Over the last two days we asked how vision-capable AI models do the same task. Surprisingly, they behave very similarly to humans. Shown the same kinds of pictures and asked the same question, LLMs reach for the same strategies people use and miscount the same way people do.

We’re describing how these models behave. We’re not claiming that a model is identical to a human brain. However, the behavioral match is striking. Given that the LLMs behavior emerges from training, not from specific programming, it is noteworthy that it converged on behaviors so similar to our own.

(Explainer for those of you who prefer videos)

What the models do at a glance

Our first experiment (full paper and data here) was the simple version: generate pictures with an exact number of dots, show them to three models from different companies, and ask “how many objects are in this image?” We read every answer rather than letting a script extract it, because thinking models often narrate before committing to a number, and a script can grab the wrong value. (The whole dataset is published, because counting it is prone to error…)

The pattern that came back is eerily similar to the human one, in all three models. Small numbers are easy and often exact. Above about four, the models estimate (sometimes wildly!), and the estimates spread wider as the true count climbs. And they round like we do. Fives and tens are popular.

They largely get stuck on preferred values and jump between them. xAI’s Grok, did this dramatically: its single most common answer stayed “twenty-five” for true counts all the way from twenty-five to thirty-five. Like, it really insisted there were twenty-five. If it were a human, I imagine it saying “There are twenty-five fucking dots in that picture! Are you blind?”

The others, Google’s Gemini and Meta’s Llama, did it more gently, with shorter steps, but they did it too. That’s why we captured a shit-ton of data. If you don’t look carefully, you’ll miss it. But run enough trials and it’s obvious.

All three models, every true count from twenty-five to forty. If they were counting honestly, the most common answer would climb the diagonal. Instead each one’s answer sticks on preferred values and steps between them, a staircase. Grok holds twenty-five the longest; Gemini and Llama take shorter steps.

Rounding is not an AI quirk. It is exactly what humans do in this task, and it has a name in the human literature, anchoring-and-adjustment, going back to Tversky and Kahneman in 1974. A recent study by Solstad and colleagues (2026) recorded people doing the very same thing and caught them talking their way through it, saying things like “I can’t get away from my start-guess at thirty-four.” The models land on the comfortable numbers for the same behavioral reason a person does, whatever is going on underneath.

What happens when you let the model think

Newer models can run in a “reasoning” mode, where they work through a problem in steps before answering. They also have a faster mode where they just respond. That distinction turns out to map onto something psychologists have argued about human number sense for years.

The standard story, anchored in work like Peter Gordon’s 2004 study of the Pirahã, an Amazonian people whose language lacks exact words for numbers above two, is that humans have two layers. There is an old, fast, approximate sense of quantity that even people without counting words share, and there is a deliberate, learned, language-based procedure for counting one by one. The first layer estimates. The second layer counts.

When we ran the models in their fast, no-reasoning mode, we got the first layer: the quick glance, the round-number anchoring, the fuzzy estimate. When we turned reasoning on, the behavior changed. The models stopped rounding and started doing what a person does when told to count carefully. They split the picture into regions, tallied each region, and added the tallies. We could watch them do it by reading their reasoning transcripts.

The cleanest demonstration came from running one model both ways on the same pictures. In its fast mode, Grok answered “twenty-five” for every image containing from twenty-four to thirty-one objects. It refused to count the actual number. Switch the same model to reasoning and that flat line starts to move. It does not move all the way. Grok is stubborn: even while reasoning, it still leans on preferred values, and at the low end it bizarrely locks on twenty-two. So reasoning does not simply switch the rounding off. It loosens it, and the model starts following the true count instead of ignoring it, while still showing its old habit underneath. Same model, same pictures, the only thing changed being whether it was allowed to think. (This second study, with its figures, is in the same repository.)

The same model, Grok, on the same pictures, with reasoning off (grey) and on (blue). Off, the answer is flat on twenty-five no matter the true count. On, it starts to follow the count, though it still leans on preferred values and sits a little low. The dashed line is a perfect count.

The mistake is the human mistake

The reasoning models do not count perfectly. Most of them come up a few short. And the way they come up short is the tell.

When Grok counts a picture of twenty-six dots, it writes out something like “top region four, upper-middle five, middle six, lower-middle five, bottom three,” adds those up correctly to twenty-three, and commits to twenty-three. The arithmetic is right. The total is three low. The dots were not lost in the addition; they were lost in the regions, at the boundaries between the chunks the model drew for itself. This is exactly the failure Solstad and colleagues document in people: human counters split a crowded display into parts and lose items at the part boundaries, which is why human estimates of crowded scenes run systematically short. Two different kinds of system, asked the same question, pick the same strategy and fail in the same place.

Four reasoning models, each given the same six counts forty times. Each row is one true count; the bars show the spread of answers. GPT-5.5 (far left) gives a single exact bar every time. The others spread out, low and variable. Qwen’s red labels mark answers that ran clear off the chart, some as high as a hundred.

OpenAI’s GPT-5.5 was perfectly accurate. It returned the exact right answer on every trial. While it’s the best, it’s the least human result in the set. People do not produce flawless, identical counts of crowded dots. We get a hard picture a little wrong.

A small experiment that says a lot

If the undercounting really comes from the model losing dots at the seams between its self-drawn regions, then handing it cleaner seams should help. So we took the same dot pictures and colored the dots into distinct groups, red here, blue there, green in the corner. Same picture, same positions, just color added.

The same twenty-six dots as the first picture, in the same spots, now colored into groups. Nothing moved. The only thing that changed is that the chunks are handed to the model instead of left for it to invent.

For the model that had been undercounting, color fixed it. Grok started counting by color group, “red six, blue six, green eight,” and its answers jumped from around twenty-three up to the true twenty-six, across five different layouts. We had handed it a partition instead of making it invent one, and the lost dots came back. The model that was already counting accurately didn’t change, because it had nothing to recover. This is the same thing that happens when you give a person an easier way to organize a count. The effect showed up in a second model too, so it is not a one-model fluke.

Five different arrangements of twenty-six dots. Grey dots are the plain version, red dots are the same arrangement colored into groups. The green line is the true count. Every layout: grey sits short, color pulls it back to twenty-six.

So what

None of this proves a machine has a number sense in the way you do. We were careful, throughout, to separate the behavior we measured from the mechanism we can’t see, and there are deflationary explanations on the table that we take seriously, including the possibility that a model trained on enormous amounts of human text has simply learned to produce text that looks like human counting. We can’t definitively rule that out.

But set the mechanism question aside and look at what we actually observed. Asked to count, two very different kinds of system reach for the same two strategies, estimate or enumerate. They round on the same types of common numbers. They switch from one strategy to the other under the same conditions. And when they count a hard picture, they make the same mistake, in the same place, for what looks like the same reason, and the same simple fix helps both. That’s a lot of similarities. And we’re talking about a multi-modal test. Not just generating text but looking at an image and counting objects.

That is a parallel worth stating plainly, and it is the kind of thing that’s easy to miss if you’re only ever asking whether the machine got the right answer. The more revealing question is how it got its answer, and there the resemblance to us is compelling.

---

Data, code, and both full papers: github.com/tedinoue/cogpsych-llm.

References

· Gordon, P. (2004). Numerical cognition without words: Evidence from Amazonia. Science, 306(5695), 496–499. https://doi.org/10.1126/science.1094492

· Solstad, T., Kaspersen, E., Romijn, E. I., & Hodgen, J. (2026). Decision-level processes in rapid numerosity estimation. Cognition, 273, 106511. https://doi.org/10.1016/j.cognition.2026.106511

· Tversky, A., & Kahneman, D. (1974). Judgment under uncertainty: Heuristics and biases. Science, 185(4157), 1124–1131. https://doi.org/10.1126/science.185.4157.1124