Don't Trust the AI to Add Up Your Notes

An AI can read every number in your notes and still get the total wrong. Not because it lacks a calculator, but because, left to itself, it predicts the next digit instead of computing it. Keep the raw numbers, and recompute the total with a real tool.

This is not a knock on the models, and it is not the old myth that AI cannot do math. Give a modern assistant a calculator or a code tool and it handles arithmetic well — often better than the person prompting it. The problem is narrower and more durable: the ungrounded inline total, the number a model types straight into a sentence without running anything. There, confidence and correctness come apart. Dziri and colleagues, in a NeurIPS 2023 study pointedly titled Faith and Fate, found that for one class of multiplication a model had never seen in training, 82.3% of its correct final answers still carried at least one error in the underlying computation.¹ The answer was a memorized shape, not a calculation. Point that same instinct at the expense column in your notes, and you get a total that reads as authoritative and is quietly wrong.

The number looks right, so we believe it

Most of us treat an AI's arithmetic the way we treat a calculator's: the machine is precise, so the number must be too. A language model prints a clean, confident total with no visible seams. It looks computed. That confidence is the whole problem — the total is generated, not calculated.

The tell is that the AI never shows its hesitation. A person adding five figures in their head slows down, doubles back, mutters. A model does not. It emits TOTAL: 1,204.60 in the same fluent motion it uses to emit a sentence about the weather, because to the model those are the same act: predicting the next plausible token. Plausible is not the same as correct. When the two happen to line up, you get a right answer for the wrong reason — which feels identical to a right answer for the right reason, right up until it doesn't.

Why the inline total can be confidently wrong

A transformer does not add columns; it matches patterns. Dziri and colleagues found that models solve multi-step arithmetic by "reducing multi-step compositional reasoning into linearized subgraph matching, without necessarily developing systematic problem-solving skills."¹ The right-looking answer often has the wrong working — a memorized shape, not a computation.

That study is worth sitting with, because it measured the failure instead of asserting it. On abstract multi-step tasks, the authors report that "Transformers' accuracy decreases to near zero as task complexity increases," and argue theoretically that "the probability of incorrect predictions converges exponentially to ≈ 1" as the problem grows.¹ Small sums slip through; longer ones fall off a cliff.

There is a second, quieter reason this matters for notes specifically. The numbers in a vault are exactly the kind of data a model has not memorized: your July expenses, your reading count, your habit streak. Grade-school arithmetic is hard enough for base models that an entire benchmark, GSM8K, exists as 8,500 word problems built to expose the gap; its own authors note plainly that "our models frequently fail to accurately perform calculations."² Your notes are that benchmark, unlabeled and load-bearing.

This is the same lesson that governs letting an AI summarize a note while you keep the original: the model's output is a derived view, to be checked against a source you still hold. A summary can quietly drop a fact. A total can quietly invent one.

What actually fixes it is a real tool

The fix is old and boring: hand the arithmetic to something that actually computes. When Schick and colleagues let a model call a calculator, accuracy on math benchmarks "more than doubles."³ Modern assistants now route math to a code tool automatically. The discipline that survives every model version is offloading the sum.

The researchers who found the limit are also the ones pointing at the exit — they are allies here, not adversaries. Toolformer's authors open by noting that language models "struggle with basic functionality, such as arithmetic or factual lookup, where much simpler and smaller models excel," and then show that a model given tool access reaches for the calculator on 97.9% of examples across their benchmarks.³ GSM8K's authors go further: they train their reference solutions to defer to a calculator, so that at test time "a calculator will override sampling" whenever the model reaches for a number.² Even the dataset built to test math answers refuses to trust the model to compute them.

Simon Willison, who has spent years wiring tools into models, puts the practitioner version bluntly: "LLMs are notoriously bad at mathematics. This is deeply surprising to many people: supposedly the most sophisticated computer systems we've ever built can't multiply two large numbers together? ... We can fix that with tools."⁴ The word that matters is fix. The limitation is real and the escape hatch is real, and both have been documented for years.

So the honest claim is not "AI can't add." It is: do not trust a total the model typed without running anything. The moment a real tool is in the loop — a code interpreter, a spreadsheet, a one-line command — the failure mode mostly closes. Your job is to make sure a tool is in the loop for anything that matters.

What to do tomorrow

Do three things. Keep the raw numbers in a plain-text file you control, so a recompute is always possible. Verify any load-bearing total with a real tool — a spreadsheet formula, a one-line command, a code interpreter. And when you ask the AI, ask it to write the formula, not to hand you the answer.

• Keep the raw numbers, not just the summary. A derived total is disposable; the source column is not. If the numbers live in an open Markdown file on your own device, every recompute is one command away — no export, no lock-in.
• Recompute anything that matters. For a five-row expense table, a plain-text file makes the trustworthy sum trivial and instant:

# expenses.md
# | date       | vendor  | category | amount |
# |------------|---------|----------|--------|
# | 2026-07-01 | Rail    | transit  | 84.20  |
# | 2026-07-03 | Grocer  | food     | 61.00  |
# | 2026-07-08 | Clinic  | health   | 128.75 |
# | 2026-07-12 | Cafe    | food     | 43.10  |
# | 2026-07-15 | Airline | transit  | 219.99 |

awk -F'|' 'NR>2 && NF>=5 {gsub(/ /,"",$5); s+=$5} END {printf "TOTAL = %.2f\n", s}' expenses.md
# -> TOTAL = 537.04   (real 0m0.004s)

A spreadsheet's =SUM() does the same job for anyone who would rather not touch a terminal. The point is not the tool; it is that the number came from a computation you can rerun, not from a sentence a model guessed.

• Ask the AI for the formula, not the figure. "Write the spreadsheet formula that averages this column" is a task models are good at — it is language, not arithmetic. "What's the average?" asks the model to be the calculator, which is the one thing it isn't.
• Treat the inline total as a claim, not a receipt. If a model tells you your reading list has 47 books or your quarter cost $12,400, read that as a hypothesis to check, the way you would check which note is actually current before you act on it.

Frequently asked questions

These are the questions people actually type when a chatbot miscounts their own data, answered directly. The short version runs through all of them: the model's inline arithmetic is a guess, a real tool turns it into a computation, and the raw numbers in a file you own are what make that computation cheap to run again.

Can I trust an AI to add up the numbers in my notes?

Trust the workflow, not the model's mental math. If the AI runs a code tool or you recompute with a spreadsheet or a one-line command, the total is reliable. If it typed the number straight into a sentence with nothing running underneath, treat it as an estimate to verify — it can be confidently, invisibly wrong.

Why is ChatGPT so bad at math?

Because a language model predicts the next token rather than computing a result. Dziri and colleagues showed transformers handle arithmetic by matching memorized patterns, and that accuracy "decreases to near zero as task complexity increases."¹ For short, common sums it often lands; for longer or unfamiliar ones it drifts, and it never signals which is which.

Does a code interpreter actually fix the problem?

Largely, yes, and that is the important part. Once a model offloads arithmetic to real code, it stops guessing digits and starts computing them. Schick and colleagues found calculator access "more than doubles" math-benchmark accuracy, and modern assistants route math to a code tool automatically.³ The failure is specific to ungrounded inline arithmetic, not to AI as such.

How do I get an AI to count or average my notes correctly?

Ask it to produce the method, not the answer. Request the exact spreadsheet formula, a short script, or the command to run over your file, then execute that yourself. You get a reproducible computation instead of a one-off guess, and you can rerun it whenever the underlying numbers change.

Why does an AI give a confident but wrong total?

Because confidence and correctness are produced by the same fluent process. A model emits a total in the same motion it emits any sentence, with no internal check that the digits add up. When a memorized pattern happens to fit, the answer is right for the wrong reason — which looks exactly like being right for the right reason.

Should I paste my numbers into the AI or keep them in a file?

Keep them in a file you own; paste a copy when you want help. A plain-text source means you can always recompute independently, and the AI's output stays a disposable view rather than your only record. Ownership of the raw numbers is what makes every later verification cheap, a separate matter from what a long paste costs you.⁵

The last point connects to why a big paste has a price of its own: cost and correctness are different problems, and the raw file is the answer to both.

A model that can read every figure in your vault and still misjudge the sum is not broken; it is being asked to do the one thing it was never built to do. Keep the numbers where you can recount them, and let the machine do what it is good at — the words.

Because your notes stay in an open Markdown file on your own device, recomputing a total yourself is always one command away — that is the quiet advantage of writing in mnmnote.com.