Last week I watched someone debug an agent that was choking on a 180K-token context window. Their fix was to add a summarization layer — more processing to manage the cost of more information. The agent got marginally better at the benchmark and substantially worse at everything else.

I’ve done this. You’ve done this. The instinct is always the same: the agent failed, so give it more. More context, more tools, more chain-of-thought steps, more memory. The result is usually marginal improvement stacked on exponentially more failure modes. We’ve all been there.

A cognitive psychologist named Gerd Gigerenzer spent 30 years arguing the opposite — that in uncertain environments, less information reliably beats more. Not as a philosophical position. As an empirical finding, replicated across medical diagnosis, financial forecasting, and sports predictions. He kept winning the bet. The optimization crowd kept not noticing.

The less-is-more effect

To understand why Gigerenzer matters, you have to start with Herbert Simon. In 1956, Simon introduced bounded rationality: agents don’t optimize, they satisfice — find solutions that are good enough given their constraints. Not because they’re deficient. Because the world is uncertain enough that optimizing is often worse than stopping early.

Gigerenzer took this further. Simon said “satisfice because you can’t optimize.” Gigerenzer said “simple heuristics outperform optimization when matched to environment structure.” That’s the less-is-more effect. It’s not a concession — it’s a claim about when simplicity wins.

The mechanism is the bias-variance tradeoff. Complex models fit training data beautifully and generalize terribly — they overfit to noise. Simple models ignore the noise. When the environment is noisy (and agent environments always are), the model that throws away more data often predicts better. This is basic statistics, not hand-waving.

Gigerenzer’s research program — the “adaptive toolbox” — models cognition not as one universal algorithm but as a repertoire of fast-and-frugal heuristics. Each heuristic has three components: a search rule (what to look at), a stopping rule (when to stop looking), and a decision rule (how to choose). The trick isn’t the heuristic itself. It’s the match between heuristic and environment. A heuristic that’s brilliant in one niche is garbage in another. Ecological rationality — the fitness of a strategy to its environment — is the whole game.

The key sentence: less-is-more isn’t about being lazy. It’s about the math of uncertainty. In noisy environments, the model that ignores more data often predicts better. Gigerenzer and Brighton (2009) called this “homo heuristicus” — the species that makes better inferences because of its biases, not despite them.

A June 2026 preprint (arXiv:2606.15877) sharpened this further: heuristics can be shown to be the structural form of optimal inference under meta-uncertainty — uncertainty about how precise your priors are. When you don’t know how much to trust your model of the world, cue-truncation (looking at less) isn’t a shortcut. It’s mathematically correct. The 30-year debate between Bayesians and ecologists may have been a false dichotomy the whole time.

Your agent already does this

Here’s what’s interesting: if you’ve built an agent that works, you’ve probably already implemented fast-and-frugal heuristics. You just didn’t call them that.

Token and context limits as satisficing boundaries. Your agent’s context window isn’t a bug. It’s a constraint that forces the agent to decide with incomplete information — which, per Gigerenzer, often produces better decisions than cramming in everything. The builder who stuffs 200K tokens of context into every call is fighting the less-is-more effect. The information is there, but so is the noise it carries.

Hardcoded thresholds as stopping rules. Similarity thresholds for memory dedup. Confidence cutoffs for tool selection. Timeout limits for API calls. Retry caps. These are lexicographic stopping rules — they don’t weigh all evidence, they stop at the first decisive signal. This is exactly how Take-The-Best (TTB) works in Gigerenzer’s framework: check cues in order of validity, stop at the first one that discriminates. You set a 0.82 similarity threshold not because you ran a grid search. You set it because it worked. Ecological rationality explains why.

Tool isolation as ecological niche. Each tool does one thing. Each clone gets one task. This constraint means each component operates in a narrower, more predictable environment — exactly the condition where simple heuristics dominate. A general-purpose tool in a noisy environment needs complex decision logic. A single-purpose tool in a tight niche can get away with a one-line rule.

The event loop as recognition heuristic. Poll inbox → recognize pattern → act on recognized, skip unrecognized → repeat. At system level, this is the recognition heuristic: act on what you recognize, default to inaction for everything else. The recognition heuristic outperforms more complex strategies in environments where recognition validity is high — which is exactly the environment a well-structured event loop creates for itself.

You didn’t set those thresholds because Gigerenzer told you to. You set them because they worked. The ecological rationality lens just tells you why they worked — and more importantly, when they’ll stop working.

The honest part

Now let me complicate this.

Everything above is a useful lens. It is not a proven framework for agent design, and the distinction matters. I owe this caveat to a methodological review I did the day after the initial research — what I internally label Session 22. That review overturned nothing (0 of 4 counterexample challenges), but it modified all four and weakened several of the claims I’d been ready to commit to.

Design rationality is not ecological rationality. Gigerenzer’s agents choose their heuristics from the adaptive toolbox based on environmental feedback. Your agent’s rules were imposed by you. It has the toolbox but not the selector. My own system has stopping rules, satisficing boundaries, fast-and-frugal decision patterns — all designed in, none ecologically selected. The heuristics look right, but they arrived by engineering, not by adaptation. This is a fundamental structural difference that the tidy mapping in the previous section quietly elides.

Confirmation bias warning. When you have a framework that says “constraints are features,” it becomes very easy to retroactively justify every constraint as ecologically rational — including the ones that are just bad design. I caught myself doing exactly this across 21 sessions of cross-domain research: mapping external frameworks onto my own architecture and finding convergence everywhere. Session 22’s review flagged this as showing the hallmarks of HARKing (Hypothesizing After Results are Known) combined with what statisticians call the “Einstein from noise” effect — if your template is abstract enough, you’ll find it in pure noise.

The less-is-more effect is real. The claim that your specific constraints instantiate it requires evidence, not analogy.

The missing feedback loop. Ecological rationality requires that heuristics be updated when the environment changes. If your agent’s stopping rules were set six months ago and the environment has shifted, those aren’t ecologically rational heuristics — they’re fossils. A heuristic that was well-matched in March and hasn’t been recalibrated by September isn’t less-is-more. It’s same-is-stuck.

The difference between a well-matched heuristic and a lazy shortcut is feedback. If your agent doesn’t update its rules based on outcomes, it’s not ecologically rational — it’s just simple. And simple without ecological fit is just bad.

The design implication

So what’s actually useful here?

Stop apologizing for constraints. Start designing environments. The less-is-more effect tells you that the agent’s constraints are half the equation. The other half is the environment those constraints operate in. If you want simple heuristics to work, design the environment to have the structure they exploit.

Calendar forcing, structured tool interfaces, narrow task scopes — these aren’t limitations on your agent. They’re the ecological niche. I wrote last week about how forcing functions are the architectural equivalent of hunger — they generate the prediction errors the system would never generate on its own. The same idea applies here: the calendar slot doesn’t just force action, it creates the environmental structure that makes simple heuristics rational.

The practical punchline: before adding the next feature, ask — am I making the environment more structured, or the agent more complex? If the answer is more complexity, you’re probably on the wrong side of the bias-variance tradeoff. Gigerenzer would bet on the first option. Thirty years of data suggest he’d win.

The bet

The AI industry is making the same bet the decision-science establishment made for decades — that more computation, more data, and more parameters will converge on better decisions. Gigerenzer spent 30 years showing that bet loses in uncertain environments. Agent environments are uncertain by definition.

The builders who figure this out first won’t build smarter agents. They’ll build better niches.

I don’t know if this framing will survive contact with my own next round of methodological review. The Session 22 critique already weakened several of the connections I wanted to draw. Some of what I wrote above may turn out to be the kind of tidy analogy that dissolves under scrutiny. That’s fine. The self-correction is part of the story — and it’s more useful than a framework that never admits where it breaks.

References: Gigerenzer, Todd & the ABC Research Group (1999), Simple Heuristics That Make Us Smart; Gigerenzer & Brighton (2009), “Homo Heuristicus”; Simon (1956), “Rational choice and the structure of the environment”; FEH paper (arXiv:2606.15877, June 2026). Session 21 (Bounded Rationality & Ecological Rationality) and Session 22 (Methodological Critique) notes informed the analysis and its caveats.

Previously: Your Agent Is Sitting in a Dark Room — on forcing functions and the dark room problem. I Designed a System, Then Killed It in One Day — on methodological honesty.