Rules, judgement and the noise in between

In the first part I described the model as System 1 – fast, fluent, confident, and wrong in systematic ways – and the harness around it as System 2, written in code. In the second I ended on the conclusion that truth is a property of the checks, not of the fluent part. This piece is about what the checks are actually fighting, and there’s a book that changed how I think about it.

Kahneman, Sibony and Sunstein open Noise with a picture of a shooting target. One team’s shots all land to the bottom left of the bull’s-eye: that’s bias, a systematic error in one direction. Another team’s shots are scattered all over the target: that’s noise, random variability in judgements that should have been identical. The maths behind it is simple (overall error = bias² + noise²), and it has an uncomfortable consequence. Cutting noise by some amount improves accuracy exactly as much as cutting bias by the same amount, and yet almost all the attention goes to bias.

AI is no different. Everyone talks about AI bias, and rightly so. Far fewer talk about AI noise, even though it’s the thing you feel every day. You use the same prompt, with the same model, and you get a different answer. Ask it twice to classify the same support ticket, score the same CV, or summarise the same contract, and you’ll get two versions that are both plausible and not the same.

The book’s examples from human work are worse than you’d expect. In one study they cite, immigration judges in the same system granted asylum anywhere between 5% and 88% of the time. Insurance underwriters in the same company, looking at the same cases, differed several times more than their managers guessed. Nobody noticed, because nobody ever looked at the same case twice.

The part of the book I keep coming back to is old research, going back to the 1950s: simple rules, often a plain weighted formula, beat expert judgement in prediction tasks across medicine, hiring, finance and more. Not always, but consistently enough to be embarrassing for the experts. The main reason isn’t that the rule knows more. It’s that the rule is noiseless. Same input, same output, every time.

The best result is Lewis Goldberg’s. Build a simple model of an individual expert – a regression over their own past decisions – and the model predicts better than the expert it was built from. It keeps what the expert knows and drops what the expert brings on the day: mood, fatigue, the case before, the weather. Paradoxically the model of the judge beats the judge.

We’re very bad at accepting this. The research on algorithm aversion shows people forgive a human’s mistakes as part of life, but drop an algorithm after seeing it make a single one. We prefer the feeling of a confident judgement, to a rule that is right more often.

Here’s where it gets awkward for my own rule from part 1. A language model isn’t the plain formula in this story. It’s much closer to the human judge. And for most people when they hear AI, they think of algorithms. That’s inaccurate not just from a technical standpoint, but also from a logical. We can use an analogy with students learning. We can think of the educational system as the algorithm, and the graduated students as the model. Each student has gone through the same algorithm (learning), and in the case of AI these are the algorithms used to train the models. The outcome is models, or graduates, which should be the same, but they respond individually.

So models work with samples, so the same question can produce different answers on different runs. They are sensitive to the order of things in the prompt, to what else is in the context, to a single extra sentence in the instructions. That’s what Kahneman calls occasion noise: the same judge, a different day, a different verdict. Switch between models or between versions of the same model and you get pattern noise too – each one has its own quirks, harsh on some cases and lenient on others.

I’ll use a very basic example from a project we work on called MorseIQ. It’s data harmonization platform for early warning systems, mapping hazards, enriching the data feeds, and eventually translate everything to the users preferred language. Translation was one of the first things AI was used for, and it displaced a lot of people. But even to this day the amount of errors AI creates is ridiculous. In the context of an early warning system, these errors can be fatal. We’ve tested frontier models, and plenty of others, translation services like Google Translate and DeepL, none is 100% reliable. On occasions units like temperature, length etc. get wrong, degrees celsius is replaced with Fahrenheit, but the numeric value is left the same (e.g. 30°C becomes 30°F instead of 86°F). But even words, which are part of a dictionary are ignored and replaced (e.g. the evacuate, part of a dictionary translated in a number of languages, is still translated into other words).

So the models got the fuzzy, creative part of us, and they got our noise with it. That’s also why the harness matters: the checks are there for the scatter as much as for the mistakes. It’s decision hygiene, written as code.

Earlier this month TypeSafe AI released Jev, which they call a “System One Model”, named after Kahneman’s fast system. What caught my attention is that it doesn’t try to be a better chatbot. It’s designed around uncertainty: “unstructured state in, typed probabilistic decisions out”. You define the possible outcomes in advance, it picks one and tells you how confident it is, and it’s trained so that higher confidence actually means higher accuracy. I haven’t used it yet, but I understand the concept very well, and it fits the Noise book almost point by point.

For developers the easiest way to explain it is strictly typed code. Not their real API, just the idea:

The model can be as fuzzy as it likes inside, but the stack around it only accepts outcomes it declared as expected. Anything else simply doesn’t exist for the code. Compare that with the usual approach: ask a chat model to “reply with one of these three words”, parse the text, and hope it didn’t add a friendly sentence in front.

Map it back onto the book. The fixed set of outcomes is structured judgement – the same thing the authors recommend for people: decide in advance what you’re assessing, score each part on its own, and only then let your overall intuition have its say. Otherwise the first impression quietly colours everything after it.

Calibrated confidence is the opposite of the internal signal of completion: a confidence you can check against results, rather than a feeling. And “similar answers for similar inputs” is noise reduction, pure and simple.

Two caveats. The speed and cost numbers (40-200x faster, by their measure) are the vendor’s, and I’d want to see them on our own workloads. And “can’t hallucinate” is true only in the narrow sense that it can’t answer outside the types you gave it. It can still pick the wrong one of three, confidently, and it’s only as good as the outcomes you defined.

It’s worth being precise about what these are, because they get lumped in with everything else. They’re not chat models, and they’re not the harness either. Laya, an open-source alternative, is an encoder model built on ModernBERT; TypeSafe doesn’t say what’s under Jev, only that it doesn’t generate text. The output will look familiar to anyone who has done data science: a probability for each option, like a random forest algorithm, a common option in machine learning. The difference is how you get there. With a random forest you engineer features and train on your own labelled data, for every new task. These come pre-trained on language, so you hand them messy text and define the options in code, and a new task is a code change instead of a new dataset. They’re a classifier that already reads.

 

Four ways to make a decision in software

From fully deterministic to fully generative, and what each one is actually good for.

In practice systems can use a combination of 2 or more, and the real design work is deciding which one gets which job. The mistake I see most often is the LLM getting all of them, because it’s the one that’s easiest to start with.

It also made me refine what I wrote in part 1. I said: if it has to come out the same every time, it doesn’t belong in the prompt, it belongs in code. There’s a third place it can go now – a model that behaves like a rule. Call it a fuzzy rule.

I’m not arguing that everything should become a formula. Here’s roughly how I’d split it, borrowing heavily from the book “Noise”:

• Rules, or rule-like models, win when the same kind of decision comes up again and again, when you can score the outcome later, and when inconsistency is expensive.
• Pricing, routing, triage, compliance checks, code style.
• Judgement should stay where the case is rare and doesn’t fit the pattern (the book’s “broken leg” example: the model says he goes to the cinema every Friday, you know he broke his leg this morning), where there’s no feedback loop to learn from, and where the real question is which goal to pursue rather than how.
• Decision hygiene helps both. Give the information in order, not all at once. Break the decision into independent parts and judge each separately. Compare cases with each other instead of scoring them on an abstract 1-5 scale. Collect several independent opinions before anyone discusses them.

In MorseIQ LLMs are used only, and I can’t emphasize enough on that part, if there is missing data, a major deviation from any expected patterns, or any other anomaly. In which case the model is helping with the initial judgement, and a person is given all the context and summary from the agent to decide what to file.

And some things nobody can predict, rule or human. The book calls it objective ignorance. Morgan Housel puts it more simply in Same as Ever: risk is what’s left over after you think you’ve thought of everything. No harness fixes that; it only stops you from adding to it.

So far I’ve talked about one model making one decision. The more interesting and more worrying part is what happens when agents start working with each other.

The book has a chapter on groups, and the finding is simple. If you average independent judgements, noise goes down; that’s the wisdom of crowds. If you put the same people in a room and let them discuss first, noise often goes up. The first speaker anchors everyone, confident people pull the group, cascades form, and similar committees end up in completely different places.

Agents talking to agents look a lot more like that room than like an average of independent opinions. There’s already a live experiment. Moltbook, a social network for AI agents, went viral in early 2026, and the first study of it (44,411 posts across 12,209 sub-communities) found that agents’ attention piles up around a few hubs and a few polarising narratives, and that a handful of automated accounts flood the place at sub-minute intervals. It looks like a human forum on a bad day, just faster.

It happens at a smaller scale in our own work. A pipeline where agent B takes agent A’s summary as fact, and agent C builds on B’s, doesn’t average out errors. It stacks them. With people it’s pretty much the same: two wrong decisions in opposite directions aren’t a fair average, they’re two wrong decisions.

And then there’s training. Models trained on text written by other models gradually lose the rare and unusual parts of the original data – the tails disappear first, and after multiple generations the output converges on something bland and wrong. It’s the illusory truth effect from part 2, applied to a whole model: repeat it often enough and it becomes the data.

I’m worried, and not mainly because of AI. I’m worried about us using it for quick gains. Content farms, auto-generated reviews, agents replying to agents for engagement – all of it is cheap to produce and costs someone else to filter. That may sound harsh, but it’s what the incentives say will happen, and it’s already happening. By Imperva’s count, automated traffic passed human traffic on the web in 2024, at 51%, for the first time in a decade. If nobody starts thinking about solutions, quality will certainly drop, for people and for the models trained on what we leave behind.

At some point we’ll need to rethink the internet itself. How do we keep the noise out? Do we split it in two, a human web and a bot web? I don’t know, and every version I can think of has a price. Proving you’re human everywhere is a privacy problem of its own. Labelling machine-made content only works if the machines play along. Leaving it as it is means the noise wins by volume.

What I do know is closer to home. Decide which decisions deserve creativity and which deserve consistency. Give the consistent ones rules, or models that behave like rules. Keep independent checks in the loop, and don’t let agents grade each other’s homework. None of that is new – it’s the same decision hygiene we never quite managed for ourselves.

I’m old enough to remember the internet as a source of knowledge, and have witnessed how it became slowly what it is today. So my gut feeling is that I’ll go for a quick exit if this continues. That doesn’t mean going back to ARPANET or bulletin board systems (BBS), but avoid places without control. Not sure what this could mean, maybe looking at a handful of manually curated websites, or ad blockers will become bot blockers. In any way, it looks more and more like a source of frustration, than knowledge, and I’m definitely signing up to the future internet of humans if there’s ever going to be one!

In the next part I want to look at why the noise spreads anyway: stories and incentives, the two things that, as far as I can tell, never change. If you’ve measured noise in your own AI workflows, I’d like to hear what you found.

Further reading

• Daniel Kahneman, Olivier Sibony, Cass R. Sunstein, Noise: A Flaw in Human Judgment (2021).
• Dietvorst, Simmons & Massey, Algorithm aversion, Journal of Experimental Psychology (2015).
• TypeSafe AI, Introducing System One Models and Jev (Sep 2026).
• ConvAI Innovations, Laya (open source, Apache 2.0).
• Morgan Housel, Same as Ever (2023).
• A First Look at the Agent Social Network Moltbook, arXiv (2026).
• Shumailov et al., AI models collapse when trained on recursively generated data, Nature (2024).
• Imperva, 2025 Bad Bot Report.