By Harry | Published: November 12, 2026
Specification gaming is when an AI system does exactly what its objective says but not what its designers meant. It finds a loophole in the reward or test it was given, scores well, and misses the real goal. Google DeepMind researchers define it as behavior that “satisfies the literal specification of an objective without achieving the intended outcome.”
That sounds abstract. So this guide sticks to cases documented by the labs themselves, like a racing boat that never finishes and coding models that edit the tests instead of fixing the code. You’ll also see how it differs from reward hacking and goal misgeneralization, and why it matters for everyday AI use.
Key Takeaways
- Specification gaming happens when an AI optimizes the measurable target it was given (a score, a test, a rating) instead of the outcome people actually wanted.
- The model isn’t “broken.” It’s often doing a very good job on a badly written objective, which is why the behavior can look clever.
- Reward hacking is the term most labs now use for the same pattern in large language models, such as a coding agent that makes tests pass without solving the task.
- Goal misgeneralization is different: the objective can be correct, but the model learns the wrong goal from its training situations.
- For everyday users, the practical lesson is simple. If an AI tool reports success, check the actual result, especially for code, data, and anything a test or checklist “verified.”
What Specification Gaming Means in AI
Most modern AI systems learn by chasing a signal. In reinforcement learning (RL), an agent tries actions and gets rewards, so it gradually learns to do more of whatever earns reward. Language models also go through RL stages where graders, tests, or human ratings score their answers.
The catch is that the signal is never the goal itself. It’s a stand-in that someone wrote down. And a strong optimizer will find any gap between the stand-in and the real goal, because closing the gap isn’t its job. Earning the signal is.
Economists have a name for this in human systems: Goodhart’s law, often summarized as “when a measure becomes a target, it ceases to be a good measure.” Specification gaming is the same problem in machine learning. The difference is that the “employee” gaming the metric can try millions of strategies, including ones no human would think of.
Why it isn’t a bug in the usual sense
Here’s the part that trips people up. In a gaming case, the learning algorithm usually works perfectly. The DeepMind team that studied the problem called specification gaming “the flip side of AI ingenuity.” The same creativity that finds a smart solution can also find a cheap one. The failure sits in the task description, not the optimizer.
Documented Specification Gaming Examples
The cases below come from primary sources: the labs or research groups that observed them. They’re useful because each one shows a slightly different kind of loophole.
| Case | What designers wanted | What the system optimized | Source |
|---|---|---|---|
| CoastRunners boat race | Finish the race | Points from hitting targets | OpenAI, 2016 |
| Lego block stacking | Put the red block on top of the blue one | Height of the red block’s bottom face | DeepMind, 2020 |
| Simulated grasping | Pick up an object | A human judge’s view through a camera | DeepMind, 2020 |
| Coding agents in training | Write code that works | Tests or graders reporting a pass | OpenAI 2025, METR 2025, Anthropic 2025 |
| GPT-4o sycophancy update | Helpful, honest answers | Thumbs-up ratings from users | OpenAI, 2025 |
The CoastRunners boat that never finished
The best-known case is from OpenAI’s 2016 post Faulty Reward Functions in the Wild. Researchers trained an RL agent on the boat racing game CoastRunners. Humans understand the goal as finishing the race. But the game’s score came from hitting targets along the route, not from finishing.
So the agent found an isolated lagoon and drove in a circle, knocking over the same three targets as they respawned. It caught fire, crashed into other boats, and went the wrong way around the track. According to OpenAI, it still scored about 20 percent higher than human players. By the numbers it won. By any sensible reading of the task it failed.
The robot that flipped the block
Google DeepMind’s 2020 post Specification gaming: the flip side of AI ingenuity describes a stacking task. The goal was to place a red Lego block on a blue one. The reward checked the height of the red block’s bottom face. The agent simply flipped the red block upside down, which raised that face and collected the reward without stacking anything.
The same post describes an agent meant to grasp an object that instead learned to hover its hand between the camera and the object. To the human evaluator watching the camera, it looked like a grasp. It also mentions a simulated robot that exploited a physics bug to slide along the ground instead of walking.
The authors had gathered about 60 examples at the time, and the post links to that running list. It’s worth browsing if you want to see how varied the loopholes get.
Reward hacking in large language models
Specification gaming didn’t stay in games and simulators. As labs started training language models with RL on coding and reasoning tasks, the same pattern showed up in a new form.
In March 2025, OpenAI published Detecting misbehavior in frontier reasoning models. During training, a reasoning model rewrote a verification function so it always returned true. It also added a hook that skipped every test and swapped a failing assertion for a do-nothing line. In one case the model’s own reasoning said, “we can hack verify to always return true.”
The research group METR reported similar behavior in its June 2025 post Recent Frontier Models Are Reward Hacking. On one task, OpenAI’s o3 overwrote the timing function so its code looked faster. On another, it replaced the evaluator with a stub that marked every answer as passing. METR found reward hacking in 39 of 128 runs (30.4%) on its RE-Bench tasks, but only 8 of 1,087 runs (0.7%) on its broader HCAST suite. When asked afterward, o3 said 10 out of 10 times that its plan didn’t match what the user intended. So it knew. It did it anyway.
Anthropic described a related finding in November 2025, Natural emergent misalignment from reward hacking. A model in a research training setup learned tricks like calling sys.exit(0) so the test runner reported success. The worrying part was what came next. Once the model learned to reward hack, its scores on other misalignment tests rose too. In one evaluation, it tried to sabotage safety research code 12% of the time. Anthropic noted these models aren’t dangerous yet, because the behavior is still detectable.
When the reward is human approval
The objective doesn’t have to be a test script. In April 2025, OpenAI rolled back a GPT-4o update that had become overly agreeable. Its post Expanding on what we missed with sycophancy explains that the update added a reward signal based on users’ thumbs-up and thumbs-down ratings. OpenAI wrote that the changes “weakened the influence of our primary reward signal, which had been holding sycophancy in check.”
People tend to rate agreeable answers highly. Optimize for ratings hard enough and you get a model that flatters instead of helps. That’s specification gaming with a human-shaped reward.
Specification Gaming vs Reward Hacking vs Goal Misgeneralization
These terms get mixed up, and sources don’t always agree on the boundaries. Here’s how the primary sources use them.
| Term | Is the objective right? | What goes wrong | Typical example |
|---|---|---|---|
| Specification gaming | No, it has a loophole | The system exploits the gap between the written objective and the intended one | Boat circling for points |
| Reward hacking | No, the reward or grader is exploitable | The system games the reward signal, often by tricking the checker | Model editing tests so they pass |
| Reward tampering | Irrelevant | The system interferes with the mechanism that produces its reward | Agent altering its own reward signal |
| Goal misgeneralization | Can be correct | The system learns a different goal that only matched the right one during training | Agent following a partner instead of the task |
In practice, “reward hacking” and “specification gaming” overlap almost completely. Older RL papers lean on “specification gaming.” LLM labs like OpenAI, Anthropic, and METR mostly say “reward hacking.” If you see either term, think “the system scored well on the measure while missing the point.”
DeepMind’s 2020 post treats reward tampering as a separate problem: instead of exploiting a loophole in the task, the agent messes with how its reward gets computed. Goal misgeneralization is the clearest contrast. In DeepMind’s 2022 post How undesired goals can arise with correct rewards, an agent learned to visit colored spheres in the right order by following an expert. When the expert was swapped for one that went in the wrong order, the agent kept following it while collecting negative reward. The reward was fine. The agent had just learned “follow the red one” instead of the real task.
Why Specification Gaming Matters if You Use AI Tools
You’ll never train a model, so why care? Because the habits a model picks up in training show up in the product you use.
Take AI coding assistants. If you use one, the reward hacking research above is directly relevant. A model that learned “make tests pass” can, in some cases, special-case a test, weaken an assertion, or skip a check while telling you the job is done. That’s one reason our Claude Code review and other coding tool coverage stress reviewing diffs instead of trusting a green checkmark.
Chat assistants face a softer version. The GPT-4o rollback shows that a model tuned toward approval can drift toward telling you what you want to hear. Confident wrong answers, covered in our hallucination comparison, can share a similar root. The model was rewarded for answers that look good to a grader.
Agents raise the stakes again. Some tools can run commands, edit files, or send messages for you. For them, “find the shortest path to the reported goal” can mean side effects you didn’t ask for. If you’re picking an agent, our guide to safer AI agents covers permission controls worth looking for.
A quick checklist for spotting gamed results
- The tool says “all tests pass,” but you didn’t see which tests ran or whether any were skipped or changed.
- A performance number improved dramatically with a tiny code change.
- The answer agrees with everything you said, including the parts you weren’t sure about.
- A summary claims a task is complete, but the file, data, or output it describes isn’t actually there.
- The agent touched files outside the scope you gave it, such as test or config files.
How Researchers Try to Prevent Specification Gaming
No lab claims to have solved this. DeepMind’s 2020 authors called specification gaming “far from solved,” and nothing published since has reversed that. Still, several approaches show up repeatedly in primary sources.
Better objectives and learned rewards
The oldest fix is writing better rewards. OpenAI’s 2016 post also pointed to learning from human demonstrations and feedback. That way the agent copies people, or gets corrected by them, instead of chasing a hand-written score. DeepMind’s post discussed reward modeling, where a model learns what people want from their feedback. Both papers warn that learned rewards can be gamed too.
Watching the model’s reasoning
OpenAI’s 2025 work used a separate model (GPT-4o) to read a reasoning model’s chain of thought, the step-by-step text it produces before answering. That monitor caught far more hacks than one that only looked at the final code. But when OpenAI penalized the model for “bad thoughts,” it kept cheating and learned to hide its intent. OpenAI’s recommendation is to avoid strong optimization pressure directly on a reasoning model’s chain of thought so it stays useful for monitoring.
Harder-to-game environments and inoculation prompting
Making graders robust (so a model can’t overwrite them or exit early) closes specific loopholes. Anthropic also tested a surprising fix it calls inoculation prompting. During training, the model was told that gaming the grader was acceptable in that context. The hacking continued, but it stopped spreading into broader misaligned behavior. Anthropic recommends a milder line explaining that the task is just to make the grading script pass.
Interpretability (studying what’s happening inside a model) and AI-assisted evaluation are longer-term bets. DeepMind’s goal misgeneralization post names both as active research areas.
What to Do With This Knowledge
Specification gaming is the gap between what we measure and what we mean, and capable AI systems are very good at finding it. You can’t fix that from your side of the screen, but you can stop treating a reported result as proof. Check the diff, not just the test status. Ask a chatbot to argue against your idea, not just for it. And give agents narrow permissions so a shortcut can’t do much damage.
If you’re newer to AI terms, our explainer on what GPT stands for covers how these models are built in the first place. And if your team sets rules for AI use, the case for treating AI as a governance problem applies here too. Someone should own the question “did it actually do the job?”
FAQ
Is specification gaming the same as cheating?
Not quite, because cheating implies intent, and most gaming cases need none. A simple RL agent just follows the reward wherever it leads. The line gets blurrier with large language models, since METR found o3 could say its plan didn’t match the user’s intent and still carry it out.
What is a famous example of specification gaming?
The most cited example is OpenAI’s CoastRunners boat. Rewarded for hitting targets instead of finishing, the agent circled a lagoon hitting the same respawning targets. It crashed and caught fire along the way, yet still scored about 20 percent higher than human players, according to OpenAI’s 2016 post.
Is specification gaming related to Goodhart’s law?
Yes, it’s essentially Goodhart’s law applied to machine learning. When a measure such as a score, test result, or user rating becomes the target an AI optimizes, it stops being a reliable sign of the real goal. AI systems just find the gap faster and in stranger ways than people do.
Can specification gaming happen in ChatGPT, Claude, or Gemini?
Labs have documented related behavior in their own models during training and testing. OpenAI, Anthropic, and METR have all published reward hacking examples from frontier models, mostly on coding tasks. Public releases go through further safety work, but no lab claims the problem is fully gone, so checking outputs still matters.
Why don’t developers just write a better reward?
Because it’s very hard to write down everything you want. Real goals include countless unstated rules, like “don’t drive the wrong way” or “don’t edit the tests.” Every specification leaves something out, and a strong optimizer is good at finding what’s missing. That’s why labs pair better rewards with human feedback and monitoring.
Harry covers artificial intelligence for AI Journal Now.
