Here is the blunt version. If you want an agent to behave like a real user, the single most capable model is the wrong tool, and making it worse is part of the job. Not broken, not random: worse in a specific, controlled way that matches the person you are simulating. The frontier model is where you start. A believably limited human is where you have to end up.
1. Your model is too good to be a user
A real person is bounded. They know some things and not others, they forget, they get tired, they misread a label and give up when something feels hard. A frontier model has none of those bounds by default. Condition it on a persona and it will still act at a skill ceiling the real person never had. If you are using the simulation to find where users struggle, this is fatal: the simulated user does not struggle where the real one does.
Left at full strength, a model does not answer like a person. It answers like an unusually well-informed, unusually careful, unusually consistent person, which is to say not like most people at all. And more capable does not even mean more useful: a stand-in that is smarter than your real users simply hides the friction they would actually hit.
2. "Dumber" is not one dial
Lowering the temperature or swapping in a smaller model misses what makes a person a person. Human limitation has at least four independent axes, and a faithful simulation has to move each one on purpose. Each axis has its own mechanism and recreates a different, recognizable human trait.
One model, four independent axes of limitation
Conceptual framework. Each dial moves separately; a faithful persona is a specific setting across all four, not a single "make it worse" slider.
| Dial | Frontier default | Turn it down by | The human trait it recreates |
|---|---|---|---|
| Knowledge | Broad, near-complete | Ablate domain facts, restrict retrieval and context | "I have never seen this before" |
| Skill | Executes cleanly | Remove tools, block certain reasoning steps | Fumbling, taking the wrong approach |
| Consistency | Stable across turns | Cap memory, allow contradiction and drift | Changing one's mind, forgetting a decision |
| Effort | Grinds to completion | Limit steps and tokens, reward stopping early | Skimming, satisficing, giving up |
The effort axis is the one people forget. Real users do not optimize, they satisfice: they stop at the first option that is good enough, skim instead of read, and quit when a task drags. A model grinds every task to an optimum, which is the opposite. A small model at high temperature, meanwhile, moves all four dials at once in an uncontrolled way. That is not a person, it is a noisy version of a smart one. The goal is a specific, shaped reduction, one axis at a time, that you can dial in and defend.
3. Three ways to make a model dumber, and only one is right
This is the part people get wrong. "Make it worse" has several implementations, and most of them produce something that looks human-ish and is not.
Three ways down, and what each actually produces
| Approach | What you actually get | Faithful? |
|---|---|---|
| Turn up randomness (high temperature, tiny model) | Noise sprayed evenly across every decision | No: unreliable, not human |
| Prompt a caricature ("act like a confused beginner") | Exaggerated, stereotyped mistakes on cue | No: plausible but systematically off |
| Match the real failure distribution | The specific misconceptions and give-up points of that population | Yes: this is the target |
Human error is structured. A beginner does not make random mistakes; they make beginner mistakes, in a direction. A model that fails randomly has added noise. A model told to "act confused" has added a stereotype, which is worse, because it looks convincing while being wrong in a consistent way. The target is degradation that reproduces the same wrong turns, the same misconceptions, and the same moments of giving up as the real person. That is the harder and more useful thing to build.
4. A worked example: three simulated users
Give three simulated users the same job: cancel a subscription in an app they have never used, where the option is buried three menus deep.
- Full-capability model. Finds the hidden setting in seconds and cancels cleanly. It never gets lost, so it tells you nothing about how hard the flow really is.
- Randomly degraded model. Taps around at random, opens screens no real person would, and fails in ways that have no pattern. Its trouble does not point at any real design problem.
- Faithfully bounded model. Looks for "Cancel" under Account, misses the menu that is labeled something else, hesitates at the retention offer, and gives up at the exact screen where real users give up. Its struggle is a measurement: it points at the step that actually needs fixing.
Only the third one is useful. The first is too capable to find anything; the second finds problems that are not there.
5. This is not just one kind of product
The same mismatch shows up wherever a product has to serve people with different knowledge and habits.
- A support chatbot tested only against an all-knowing simulated user will never see the customer who does not know the name of the feature they are asking about.
- A health tool evaluated by a simulated patient who reads every instruction carefully will miss the person who skims, panics, and clicks the wrong thing.
- A shopping assistant judged by a simulated shopper with perfect price memory will not surface the confusion of someone comparing three tabs from memory.
In each case the useful signal lives in the limitation. Turn the model's competence down to the right level and the failures it hits are the failures your real users will hit. Leave it at the ceiling and the product looks better in simulation than it will ever be in the world.
6. How you would actually turn capability down
Capability control is not one technique. It is a stack of them, applied per dial and per persona, and the research is in knowing which one moves which axis without spilling into the others.
- Knowledge ablation and context control. Withhold domain facts, restrict what the agent may retrieve, and start it from only what the person would plausibly know.
- Tool and action restriction. Take away the shortcuts. A user who cannot run a shortcut has to work the way a user without one does.
- Memory and consistency limits. Cap what carries across turns so the agent can forget, repeat itself, and change its mind.
- Training on human traces. Fit the model to real people's attempts, including their errors, so it learns the shape of the mistakes rather than a description of them.
- Elicitation control. Actively steer the model to a target competence and hold it there, the inverse of the usual push to elicit maximum capability.
7. What would make a bounded agent credible
A dumbed-down agent is a claim, and claims need evidence. The bar is not "does it seem less capable." It is whether the reduction reproduces the target population: the same patterns of behavior and error you would find across real people, not merely something that sounds believable. Three tests matter most.
- Failure-distribution match. Does the agent fail where the person fails, with the same misconceptions and give-up points, not just less often on average?
- Counterfactual sensitivity. When you move a dial, does behavior change in the expected direction and only in that direction?
- Stability. Does the constraint hold over a long interaction, or does the underlying competence leak back in after a few turns?
This slots directly into the validity ladder from our human-simulation position paper: grounding the persona, showing it adheres, and checking the distribution before any decision rests on it.
It is to build a controllable one. A single capable model should be able to sit at many different human competence levels on demand, and to defend each of them under measurement. That control is the deliverable, and "dumber" is only one direction it has to move.
8. The bet
The instinct in AI is that more capability is always better. User simulation is where that instinct breaks. The frontier model is where you start. A person, bounded and fallible and specific, is where you have to end up, and the road between them is worth a paper, not just a prompt. If we want simulated users we can trust, we will have to get as good at turning capability down, precisely and provably, as the field has become at turning it up.
Evidence note. This is a position piece describing an open research direction at MatrAIx, not a report of a completed study. Figures 1 and 2 are conceptual frameworks proposed by the authors. It builds on our human-simulation position paper.