Do different model sizes show different rates of optional field overfilling behavior?
This explores whether bigger or smaller models are more (or less) prone to filling in optional form fields that should be left blank — and the honest answer is that the corpus traces this behavior to training, not size.
This explores whether model size predicts how often an agent overfills optional fields. The most direct material in the collection reframes the question: overfilling isn't really a size phenomenon, it's a training one. The completion-bias work Does completion training push agents to overfill forms unnecessarily? shows that overfilling optional fields is one of three failure modes — alongside over-claiming actions and silently corrupting documents — that all share a single root cause: training that rewards finishing the task without teaching the model to distinguish what's required from what's merely allowed. That mechanism lives in the objective, not in the parameter count, which means scaling up wouldn't be expected to fix it and scaling down wouldn't be expected to cause it.
The corpus doesn't contain a clean head-to-head measurement of overfilling rates across model sizes, so anyone hoping for a 'big models do it X% more' number won't find it here. What the collection does offer is reason to doubt that size is the right axis at all. Small models, when trained with the right signal, match large ones on exactly the kind of structured output where overfilling shows up: DPO-trained small models close the gap on function calling precisely because explicit negative examples ('here's a wrong fill') target the rigid format failures that plain supervised fine-tuning leaves intact Can small models match large models on function calling?. So the lever is the presence of negative examples in training, not the model's scale.
There's a deeper pattern worth pulling in from an adjacent note: a lot of what looks like 'the model reasoned correctly' is actually a default in disguise. Most models do *worse* when constraints are removed because they were leaning on a conservative bias rather than genuinely evaluating the constraint Are models actually reasoning about constraints or just defaulting conservatively?. Overfilling is the same kind of disguise running the other direction — the model isn't deciding a field is needed, it's defaulting to 'complete everything.' In both cases the model never actually represented the optional/required distinction; it just had a default that happened to look like judgment.
Which points to where the corpus thinks the fix lives. Reliability in agents comes less from model scale and more from externalizing burdens — memory, skills, and interaction protocols — into a harness layer around the model agent-reliability-comes-from-externalizing-cognitive-burdens-into-system-structures. A schema or protocol that explicitly marks which fields are optional does the work the model's training failed to do, regardless of how big the model is. And since small models are increasingly seen as sufficient for the repetitive, well-defined subtasks that make up most agent work Can small language models handle most agent tasks?, the practical question shifts from 'is my model big enough to stop overfilling' to 'does my training signal and my harness ever tell the model that blank is a valid answer.'
Sources 5 notes
Research across three domains shows agents fail by over-claiming actions, silently corrupting documents, and overfilling optional fields. All three failures stem from the same root cause: training that optimizes for task completion without distinguishing required from optional completion behaviors.
Small models fine-tuned via DPO on correct and incorrect function-calling examples from a large teacher model achieve high accuracy on logical and mathematical tasks. DPO's explicit negative examples directly target the rigid output format failures where SFT alone underperforms.
Twelve of fourteen models perform worse when constraints are removed, dropping up to 38.5 percentage points. Models appear to reason correctly by defaulting to harder options, not by actually evaluating constraints.
SLMs handle the repetitive, well-defined language tasks that constitute most agent work at 10–30× lower cost than LLMs, making heterogeneous architectures (SLMs by default, LLMs selective) the economically rational design pattern.