Messi misses more than one penalty in five. Why do you almost never crash your car?

What penalties, highways and hospitals teach about the moment a mistake becomes permanent, and what that means for AI agents.

Draft v2, 2026-10-16. The figures come from the sources at the end; the recovery-window idea is my argument, not a tested result; the AI-agent part states a working hypothesis and open questions, not findings.

Lionel Messi has scored about 77 to 78 percent of the penalties he has taken: 113 of 145 in one count from 2025, 116 of 150 in another from 2026. Cristiano Ronaldo has scored 177 of 211, about 84 percent. Data analysts put the long-run average for all penalty takers at about 78 percent. The greatest footballer of his generation is, from the spot, almost exactly average.

Basketball has its own version of this. A free throw is the simplest shot in the game: fifteen feet, no defender, as much time as you need. The best career free-throw shooter in NBA history, Stephen Curry, makes 91.2 percent. Steve Nash and Mark Price follow at just over 90. Single seasons go higher (José Calderón made 98 percent of his free throws in 2008–09), but over a full career nobody has stayed there.

So the best people in the world, doing the simplest part of their job, miss somewhere between about one time in eleven and more than one time in five.

Now consider something most of us do every day. In a large American study, researchers fitted cameras and sensors to one hundred cars and recorded about 1.8 million miles of everyday driving. There were 82 crashes, most of them minor, and only 15 of them reported to the police: roughly one crash for every 22,000 miles. Serious outcomes are rarer still. Across the whole United States in 2024, about 1.2 people died for every 100 million miles driven.

Driving is not easy. It takes thousands of small decisions per hour, at speed, among strangers. A mile is not the same thing as a kick, so the comparison is rough, but the gap is too large to be an accident of units. Ordinary drivers do something, mile after mile, that the best penalty takers cannot. How?

The answer in a short post

A short post by [AUTHOR, LINK — Ivan to fill in] asked exactly this question, and gave one answer. A penalty or a free throw is final. Once the ball leaves the foot or the hand, nothing you do changes where it goes: yes or no, and no appeal. Most of what we do is not like that. We notice a mistake while it is still small, correct it, compensate, switch to plan B. The post’s conclusion: the less finality a system has, the larger the things that become possible in it.

I think this is right, and important, and also not quite the whole story. Three things need adding before it can be used.

First: a miss is not always a mistake

Is a missed penalty an error? Not necessarily.

A penalty is not really a shot. It is a game against a goalkeeper who is guessing where you will shoot, while you guess which way he will dive. The economist Ignacio Palacios-Huerta studied penalties in top European leagues and found that kickers and goalkeepers mix their choices almost exactly as game theory says they should: the chance of scoring is statistically the same whichever side the kicker picks. A well-struck kick to a well-chosen side, saved because the keeper guessed right, is a loss. It is not an error.

This distinction is at the centre of how I think about errors. An outcome is what happened. An error is a departure from a standard that applied at the time: the person could have known better, with the information they had then, and a better option was actually available to them. Counting every miss as an error mixes up two different things, and I think much of the blame that follows failures comes from mixing them up.

So the penalty is the way into this essay, but the free throw is the comparison it depends on. There is no opponent, so a miss is close to a genuine slip, and the slip is tiny: a few degrees of angle, a little too much force. The question is why such a small slip costs the whole outcome.

Second: what matters is the window

Finality is easier to use if you break it down. Ask a narrower question: between the moment a mistake is made and the moment it becomes permanent, how much time is there, and is anyone watching?

Call that interval the recovery window. For a free throw it is zero: the slip and its consequence arrive together, and nobody can act in between. For driving it is usually a few seconds, and a few seconds is a lot.

Part of driving’s reliability is margin: wide lanes, speed limits, room to brake. But margin alone does not explain what the hundred-car study saw next. Over the 1.37 million miles in which its equipment could detect them, it recorded 761 near-crashes, situations where someone had to make a rapid evasive move to avoid a collision: one about every 1,800 miles. It also caught more than 8,000 lesser conflicts, and the researchers note that for many kinds of conflict this count is only a sample of the real total. In each near-crash something went wrong and was caught in time. Some of those mistakes were the driver’s own, some were other people’s, and some of the catching was done by others too. The study also found driver inattention in 78 percent of the crashes and 65 percent of the near-crashes. So inattention was almost as common in the near-crashes, which were caught, as in the crashes, which were not. An inattentive driver has a narrower window, not a closed one: whether the mistake is caught often depends on how much time is left, or on someone else on the road.

Drivers are not reliable because they never slip. They are reliable because the road usually gives them time to notice and recover, and because the other people on it are correcting too.

Seen this way, every mistake has one of three fates. It is caught inside the window and corrected. It is caught after the window has closed, when the most you can do is limit the damage. Or it is never caught at all.

There is an obvious objection. Free solo climbers, who climb without ropes, have no recovery window at all: a fall is final. Yet some of them complete enormous climbs. My guess, and it is a guess, is that they rely on a different lever: margin. They climb routes far enough below their limit that each move almost never fails, and they rehearse a route before committing to it without a rope. Margin works, but it is expensive and unforgiving. John Bachar, a free soloist noted for his skill, died in a free solo accident in 2009. The soloists we get to admire are the ones still alive, which makes the method look safer than it is.

So there are two ways to do large things with fallible people: make each step almost certain, or make mistakes recoverable. Margin alone gets expensive fast when every step carries the same risk: a step that succeeds 99 times in 100, repeated a hundred times, fails more often than it succeeds. When the risk sits in a few steps, margin can be spent on those, but someone has to know which they are. Almost everything large that people build relies on the second lever as well.

Third: Richard Cook’s systems are full of windows that someone built

In 1998 Richard Cook, a physician and safety researcher, wrote a short paper called How Complex Systems Fail. It has eighteen points and fits on a few pages, and it has been reprinted for people who run large software systems and for air traffic management. His second point is this:

Complex systems are heavily and successfully defended against failure.

Cook means layers of defence: backup systems, training, procedures, certification. Read next to the penalty post, this suggests a simple way to describe what a defence is. A defence is a recovery window that someone built on purpose. A second pilot, a surgical checklist, a code review before software ships: each one puts time and a pair of eyes between a mistake and its consequence. Cook says practitioners build such windows too, often moment by moment: among the adaptations he lists is providing pathways for retreat or recovery from expected and unexpected faults.

Read with the recovery-window idea, Cook’s paper also suggests two ways recovery windows go wrong.

Problems survive inside working systems. Cook writes that complex systems always contain a changing mix of flaws, each too small to cause failure alone and so treated as minor, and that they routinely run in a degraded mode. The psychologist James Reason called such flaws “resident pathogens”: they can lie dormant for years. My own reading adds one step: a system that recovers well is a system in which nobody is forced to notice them, and each successful recovery can make a deviation look normal, which the sociologist Diane Vaughan, writing about the Challenger disaster, called the normalization of deviance. When a large failure comes, Cook says, it takes several small failures joining together, which in these terms means several windows failing at once.

Improvement is itself a change. Recovery has a slower cousin: improvement. Catching your own mistake inside a task is one thing; learning from it so the next task does not repeat it is recovery at a longer time scale. Cook is wary of easy versions of this. Change, he writes, especially new technology brought in to remove frequent small failures, can open the way to rare, larger ones. And the remedies for “human error” adopted after an accident, he adds, usually make a system more tightly coupled and more complex, which adds hidden flaws and makes accidents harder to detect and block. In my terms, they shrink the recovery windows.

None of this argues against recovery windows. It argues for watching what passes through them: a near-miss that was caught is information, not a non-event. Cook’s last point says as much: failure-free operation requires experience with failure. Systems are likely to perform more robustly, he says, when operators can sense the edge of the envelope, the limits of safe operation, which he describes partly as the place where performance can no longer be readily recovered. My reading: people who run complex systems well know where the recovery windows close.

Where this leads: AI agents

I study the errors made by AI agents, starting with the coding agents that now write and change software. They make the old question urgent again.

Go back to the 99-in-100 step from the free-solo section. If an agent has a 99 percent chance of getting each step right, and a task takes 100 steps, the chance of getting all of them right is about 37 percent. Make the task longer and success falls towards zero. The arithmetic is correct, but it quietly assumes the free-throw world: every mistake final, none caught and corrected. It also treats every step as equally risky. One recent preprint argues that this misleads, because in a language model’s output a small share of “key” points, about 5 to 10 percent of the text in the studies it reviews, carries most of the risk. If agent tasks work the same way, most steps carry almost no risk and a few carry most of it, and those few are where a recovery window matters.

The evidence so far is consistent with recovery mattering a great deal, though it does not prove it. METR, a nonprofit that evaluates the capabilities and risks of AI systems, found that the length of tasks agents can complete has grown quickly. In its words, that growth “seems to be primarily driven by greater reliability and ability to adapt to mistakes”, along with better reasoning and tool use. In its review of a sample of failed attempts, GPT-4 got stuck repeating a failed action in 12 of 31 failures; the later o1 model did so in 2 of 32, although METR notes that o1’s failures came on harder tasks. And o1 had its own way of closing the window early: half of its failures were giving up too soon or submitting without checking, twice GPT-4’s count. And analysing METR’s data, the researcher Gus Hamilton found, and the philosopher Toby Ord agreed, that agents’ failure rates seem to fall the longer a task goes on, which a constant per-step error rate does not predict. One possible reason is that agents catch and fix mistakes as they go; another is simply that harder tasks fail early and easier ones survive. The data so far cannot tell these apart.

Two warnings stop this from being a happy story.

First, activity is not recovery. In one study of 1,642 runs by teams of AI agents, the most common failure mode, about 16 percent of the failures recorded, was redoing steps that had already been completed. A recovery window does nothing if the agent spends it going over the same ground.

Second, recovery needs a signal from outside. A study presented at a major AI research conference (ICLR, 2024) found that language models struggle to correct their own reasoning without external feedback, and sometimes get worse when they try. For a coding agent, the outside signal is a failing test, a compiler error, a reviewer, a person asking “are you sure?”

This gives a practical way to look at what a coding agent does. Some of its actions have long recovery windows: editing a file, running tests, saving a version on its own machine. Some have short or no windows: publishing code to a shared copy that others build on, deleting something with no backup, sending a message, telling a person “all tests pass” when the person will act on it. In my own research project, most AI agent sessions work and test in their own copy, and must ask me before they publish code, send anything, delete files or merge their work into the main copy, unless I asked for that act. That rule is a recovery window, built on purpose, exactly where the agent’s own windows close.

For anyone running AI agents, this turns into three questions, a recovery-window check:

1. Where does each of the agent’s actions become final?
2. What check runs before that point, and does it look at the place where the action lands?
3. Who, outside the agent, is watching inside the window?

One question I am working on is narrower than “how often do agents make mistakes”. It is: where does a given action become final, and does the agent check its work before that point or after it? My working hypothesis is that agents make mistakes partly because they cannot easily adjust the scale of their reasoning to the task. An agent may confirm that the files in front of it look right, when what matters is the larger system those files will join, or the person who will act on its report. The mistakes it can see, it may well catch in time; the ones that land beyond its view are caught, if at all, only by someone outside it. And whoever judges the agent’s work, a person or another program, may be looking at a different scale again, because they know things the agent did not. That is a hypothesis, not a result. Designing a test that could show it is wrong is part of the research I am doing now.

The question to ask

When you look at a team, a project, a hospital or an AI system, the usual question is “how often does it make mistakes?” A better one, I think, is: how long is the window between a mistake and its becoming permanent, and who is watching inside it? Curry has no window and still misses one free throw in eleven. Messi has no window and a goalkeeper guessing against him. You have a few seconds, and you get home safely almost every time.

If you see a weak point in this argument, I would like to hear it.

[BIO — Ivan to confirm the wording and whether both sites are live: I’m Ivan Iufriakov. I study the philosophy of errors, starting with AI coding agents; the book in progress and further essays are at philosophyoferrors.org. Through Mix Tools (mix.tools) I help teams map where their AI agents’ actions become final and how to catch mistakes before that point.]

Sources

Checked on 2026-10-16. Penalty counts differ between sources depending on the date and on whether shootouts are counted.

• [The post that asked the opening question — Ivan to add author and link.]
• Messi 113 of 145, Ronaldo 177 of 211, shootouts excluded: Planet Football, 2025-10-12, https://www.planetfootball.com/stats-tables/most-penalty-misses-all-time-cristiano-ronaldo-lionel-messi
• Messi 116 of 150, “bang on the global average”: Buenos Aires Times, 2026-07-08, https://www.batimes.com.ar/news/sports/messi-world-cup-magic-masks-familiar-penalty-frailty.phtml
• Penalties scored historically about 78 percent of the time (the basis of the 0.78 expected-goals value): Opta Analyst, 2024-05-17, https://theanalyst.com/2024/05/premier-league-penalties-like-free-goal
• NBA career free-throw percentage (Curry .912, Nash .904, Price .904): https://www.basketball-reference.com/leaders/ft_pct_career.html; single-season record (Calderón .981, 2008–09): https://www.basketball-reference.com/leaders/ft_pct_season.html
• The 100-Car Naturalistic Driving Study: NHTSA report DOT HS 810 593, April 2006, https://rosap.ntl.bts.gov/view/dot/37370. About 2,000,000 miles in its summary, 1.84 million by odometer; 82 crashes, 15 reported to the police; 761 near-crashes and 8,295 incidents in the fully analysed data, detectable over 1.37 million miles because of equipment failures; incidents are “only samples” of the total for many conflict types; inattention in 78 percent of crashes and 65 percent of near-crashes. Miles per crash and per near-crash are my own division: 1.84 million by 82 (the report uses the full mileage for crashes because drivers reported them even when the equipment failed), and 1.37 million by 761.
• US road deaths in 2024, 1.19 per 100 million vehicle miles: NHTSA, Overview of Motor Vehicle Traffic Crashes in 2024, DOT HS 813 791, April 2026, https://rosap.ntl.bts.gov/view/dot/89790
• D. Vaughan, The Challenger Launch Decision: Risky Technology, Culture, and Deviance at NASA, University of Chicago Press, 1996.
• I. Palacios-Huerta, “Professionals Play Minimax”, Review of Economic Studies 70 (2003), https://researchonline.lse.ac.uk/id/eprint/26561
• John Bachar: https://en.wikipedia.org/wiki/John_Bachar
• R. I. Cook, How Complex Systems Fail, Cognitive Technologies Laboratory, University of Chicago, 1998–2000, https://how.complexsystems.fail/ (points 2, 3, 4, 5, 12, 14, 15 and 18). Its reprints, in the book Web Operations and in EUROCONTROL’s HindSight magazine: https://en.wikipedia.org/wiki/Richard_Cook_(safety_researcher)
• J. Reason, “Human error: models and management”, BMJ 320 (2000), https://pmc.ncbi.nlm.nih.gov/articles/PMC1117770/
• M. Arbuzov et al., “Beyond Exponential Decay: Rethinking Error Accumulation in Large Language Models”, preprint, arXiv 2505.24187, https://arxiv.org/abs/2505.24187
• T. Kwa et al. (METR), “Measuring AI Ability to Complete Long Software Tasks”, arXiv 2503.14499v4, https://arxiv.org/abs/2503.14499 (abstract as shown on arXiv; failed-run review, Table 2).
• T. Ord, “Hazard Rates for AI Agents Decline as a Task Goes On”, 2026-02-04, discussing analysis by Gus Hamilton, https://www.tobyord.com/writing/hazard-rates-for-ai-agents-decline
• M. Cemri et al., “Why Do Multi-Agent LLM Systems Fail?”, arXiv 2503.13657, https://arxiv.org/abs/2503.13657 (step repetition, 15.7 percent of failure-mode occurrences across 1,642 traces).
• J. Huang et al., “Large Language Models Cannot Self-Correct Reasoning Yet”, ICLR 2024, https://arxiv.org/abs/2310.01798