Evaluation Harness Sensitivity: Does Post-Training Make LLM Agents Overfit?

    As evaluation harnesses—the surrounding environment of tools, schemas, and system prompts—increasingly shape how large language model agents perform, a single score can no longer be read as a fixed measure of model capability. This article examines community observations showing that the same model can score very differently depending only on its runtime harness, walks through an "Anchored Standard" experiment that isolates a priming effect at the start of a task, and explains why this sensitivity likely stems from the post-training data distribution rather than answer leakage. It closes with practical guidance for building more robust evaluations, including multi-harness cross-validation, randomness control, priming tests, ablation, and production-aligned configurations.

    1. An Anomalous Evaluation Result

    When we evaluate agents built on large language models, we tend to assume that model capability is relatively fixed and that an evaluation score reflects its “absolute level.” A series of community observations is challenging that intuition: the same model can post a notably different final score simply because the evaluation harness it “sees” at runtime is different.

    A harness is the full runtime environment wrapped around the model that decides what it can see and what it can call. It includes the tool set, the schema descriptions for those tools, the system prompt, and the documentation for extensions such as plugins, skills, and MCP. It does not change the model’s weights, yet it profoundly shapes the model’s input distribution and decision space.

    This raises two questions worth taking seriously:

    1. To what extent does the harness actually determine an agent’s performance?
    2. During the post-training stage, has the model’s official version overfitted to one particular evaluation environment?

    2. Core Evidence: How Tool Configuration Moves the Score

    A representative set of community observations (illustrative numbers, meant to show a trend rather than a firm conclusion) looks roughly like this:

    • Under a standard configuration (exposing the full 25 tools, complex schemas, and a long system prompt), the model scores around 91.
    • Switching to a middle-ground configuration yields around 92—essentially a tie.
    • But switching to a minimal mode—exposing only two tools, “shell execution” and “file reading”—pushes the score straight up to the 99 / 96 range.

    That gap is the key point. It shows that the number of tools and the complexity of their schemas is itself a strong variable. When the set of available actions shrinks from 25 to 2, the model’s decision tree is heavily pruned, the room for picking the wrong tool nearly disappears, and performance is lifted. Viewed the other way, a large share of the points lost under the standard configuration may not reflect “insufficient capability” but rather the selection noise created by too many options and overly messy descriptions.

    Here is a concrete illustration. In minimal mode, the tool definitions the model sees look roughly like this:

    1. {
    2. "tools": [
    3. { "name": "shell", "description": "Execute a command line", "parameters": { "cmd": "string" } },
    4. { "name": "read", "description": "Read a file", "parameters": { "path": "string" } }
    5. ]
    6. }

    In standard mode, the same model faces 25 tools that are semantically similar but differ in their parameters, and it must decide which one to use amid a long system prompt and multiple plugin/skill descriptions. The more complex the input, the more easily the model’s attention is diluted.

    3. What the “Anchored Standard” Experiment Revealed

    The more interesting finding comes from an experimental design known as the “Anchored Standard”:

    1. First round: pretend to be in minimal mode, exposing only the shell and read tools.
    2. After the model completes its first tool call and gets into a working state,
    3. add all 25 tools back in,
    4. and observe the subsequent performance.

    The result: even after the second round restored the full 25 tools, the model still reached scores in the 98 / 99 range.

    There is an elegant logical test here. If “tool count” alone were the driving factor, performance should have dropped back to around 91 once the 25 tools returned in the second round. It did not. This indicates that the deciding factor is not “how many tools are available right now” but the “impression at the start.” Once the model is placed into a minimal-harness-like environment at the very beginning, it quickly locks onto its most familiar working mode and keeps using it throughout.

    This is, in essence, a priming effect in agent behavior: the opening configuration acts as a catalyst, and the mode triggered earliest tends to dominate the entire task.

    4. Why the Sensitivity: A Post-Training Distribution Explanation

    Why is the model so sensitive to a “minimal opening”? A reasonable explanation lies in the post-training data distribution.

    During post-training, the model likely saw vast numbers of interaction traces resembling minimal environments—clean shells, straightforward file reads, and clear task feedback. As a result:

    • When the opening environment looks enough like the minimal harness it knows, the model quickly enters its “most comfortable working mode,” behaving efficiently and stably.
    • But if the model is handed everything from the very first round—25 tools, complex tool schemas, a large block of system prompt, and assorted plugin/skill/MCP descriptions—it is more likely to go off track early. It spends more steps “understanding the environment” and may even misjudge task boundaries.

    Put differently, the model learns not only “how to complete the task” but also, implicitly, “what kind of environment this type of task usually appears in.“ When the runtime environment closely matches the training distribution, it performs as if inspired; once it deviates, performance fluctuates.

    5. Overfitting, or a Capability Difference?

    It is worth separating two things that are easy to confuse:

    • Overfitting to the evaluation set: the model has “seen” the answers to the test questions. This is data leakage—pure, cheating-style high scores.
    • Overfitting to the evaluation distribution / interaction pattern: the model has not seen the specific answers but has formed a strong prior bias toward a certain type of interaction.

    This case is closer to the latter. It is a kind of context-level pattern matching—the model has formed a strong prior for the path “minimal opening → efficient execution.” It is more insidious than data leakage, because it cannot be caught “reciting answers,” yet it makes the score drift away from the model’s true generalization ability in the same way.

    It is worth stressing that this bias is not necessarily a bad thing. If the production harness happens to be minimal in form, then the high score is real. The problem arises only when you use a score from a minimal environment to promise capability in a complex one—that inference does not hold.

    6. Implications for Engineering Choices and Evaluation Design

    For developers and enterprise users, this phenomenon carries several layers of practical significance:

    1. A high score under a single harness is not the same as production robustness. Production harnesses are often closer to the “standard configuration” (many tools, complex prompts, lots of extension descriptions)—precisely the scenarios where models tend to lose points. If you fixate only on the best-looking number during selection, it is easy to overestimate the model.
    2. An evaluation must report “how it was tested.” For the same model, a report that omits tool count, schema complexity, system prompt length, temperature, random seed, and other settings produces a score that can barely be reproduced or compared across evaluations.
    3. Complex does not mean advanced. Piling a batch of tools and plugins onto the model does not necessarily improve capability, and may actually drag down performance through selection noise. Tool design should follow the principle of “enough and no more, semantically clear, with well-defined boundaries.”

    7. How to Design More Robust Evaluations

    To make evaluation conclusions more credible, consider the following practices:

    • Multi-harness cross-validation: cover at least multiple tiers—“minimal / middle-ground / standard”—and report a score range and robustness curve rather than a single point value.
    • Control randomness: fix the temperature and random seed, sample the same configuration multiple times, and take the distribution, so that incidental fluctuations are not mistaken for capability.
    • Priming effect test: deliberately change the opening tool set and prompt structure (as in the anchored experiment) and observe whether the score drifts, to gauge whether the model over-relies on a particular opening mode.
    • Ablation breakdown: change only the tool count, only the schema descriptions, and only the prompt length separately, to pinpoint which variable is actually moving the score.
    • Production-aligned configuration: use the harness closest to real business as the primary evaluation basis, treating the minimal configuration only as a control reference.

    8. Conclusion

    The sensitivity of the evaluation harness is a reminder that an agent’s “score” is never determined by the model alone—it is a joint product of model × environment. A high score under a minimal harness may reflect a strong model prior for a certain interaction pattern, or it may hint at a distribution bias formed during post-training. A genuinely valuable evaluation does not chase the best-looking number; it characterizes the model’s consistency and robustness across different environments.

    For those who use these models, the takeaway is simple: first figure out what your production environment looks like, then decide which set of scores to trust. Evaluating a model should serve real scenarios, not be “anchored” by a carefully constructed opening.