If a weaker model wins, who gets the credit? The truth about AI model benchmarks is less reliable than you think

Author: Robonaissance Research Team

Compiled by: TechFlow

TechFlow Introduction:In the increasingly fierce benchmark race among mainstream large models, the claim that 'Model A scores 8 points higher than Model B' is often oversimplified by the tech industry and capital markets as a difference in intelligence. However, a new empirical study by Google Cloud AI Research and Northwestern University has thoroughly debunked this myth: without changing any model's underlying weights, simply rebuilding the external workflow harness can allow a previously lower-scoring model to easily surpass top models on office and professional tasks.

This finding reveals a long-overlooked harsh reality: the scores and capability performance of large models in real-world scenarios are never determined solely by the underlying model. They are driven by an environment system built from system prompts, memory, skill tools, and orchestration scripts. Benchmark leaderboards are not, in essence, a raw intelligence duel between two bare brains; they are a performance comparison between two people working in offices with different configurations. Understanding this is highly cautionary for an industry ecosystem that blindly chases large-model benchmark scores while neglecting application engineering architecture.

An AI agent was assigned a programming task and appeared extremely diligent.

It meticulously described which code file it intended to open, which terminal command it planned to execute, and which validation check it intended to perform.

However, the real fatal problem was that it stopped at 'talking the talk.' The agent merely listed all tool calls in plain text, like an apprentice with hands in pockets verbally guiding a repair from the side, without actually running a single line of code. Ultimately, the task scored only 60 out of 100.

The researchers then changed only one configuration file in the agent's environment. It was a short tool-calling instruction explicitly telling it not to output any fake plain-text calls again. The underlying model was exactly the same, its neural network weights were untouched, and the test task was unchanged, yet the final score jumped straight to 100 out of 100.

This vivid example comes from a cutting-edge academic paper jointly published on October 9, 2026 by researchers from Google Cloud AI Research and Northwestern University. The test data in the paper are based on the author team's own experimental records and have not yet been fully independently reproduced externally.

This may seem like a minor, slightly humorous episode, but it points to a far-reaching core issue: whenever we see marketing claims that 'one AI model defeated another in testing,' people often picture two pure brains competing on the same stage.

In reality, what is actually being compared are two brains each embedded in specific system instructions, dedicated auxiliary tools, and working habits, with very different levels of engineering optimization behind each system. The final evaluation score always belongs to the organic combination of these three elements, not to the model alone.

Today, this scaffolding optimization around the model can already be automated by another AI. In these real tasks, tuning this outer environment can be enough to completely overturn the original ranking of model superiority. Therefore, when faced with any claim that 'Model A crushes Model B,' the truly discriminating questions should be: What system environment is it running in? How much auxiliary support does it receive?

The Comeback: How a Weaker Model Beat a Stronger Model

The paper's most striking research conclusion is its revelation of a dramatic reshuffling of rankings.

In a benchmark suite of 100 office tasks covering code writing, web search, and document processing, each task was scored on a 100-point scale using hidden test cases, file integrity checks, and an LLM judge. In a standard out-of-the-box default system environment, the Chinese open-source model GLM-5 had an average test score of 64.2; in the exact same standard default environment, Google's Gemini 3.5 Flash scored an average of 72.4. Based on the data from this evaluation standard itself, Gemini was clearly the stronger model, with a lead of about 8 points.

However, after only one round of automated fine-tuning of its surrounding environment configuration, GLM-5's average score jumped directly to 75.7. This was a full 11.5 points higher than its initial score and even 3.3 points higher than Gemini in its native out-of-the-box configuration.

Under a second off-the-shelf test configuration, the same pattern recurred: optimized GLM-5 scored 75.3, overtaking Gemini's 74.5. The paper's authors concluded directly: a relatively weaker model equipped with a better system harness can fully beat stronger models in their native minimal environments.

This statement is entirely true, but its real meaning is more precise and restrained than it may sound. It does not mean that GLM-5's underlying reasoning capability surpasses Gemini's. If Gemini were given exactly the same system-level tuning, its score would also rise, reaching 77.5.

What the experiment truly demonstrates is that, for this type of office task, the native capability gap between the two models is far smaller than the score gap that one round of external systems-engineering tuning can create. A ranking reversal of this magnitude does not even require any surgery on the weights of either model.

Deconstructing the model harness: office components outside the brain

In AI engineering, the system environment surrounding a model is vividly called a 'harness'; in essence, it is far more straightforward than the technical term sounds.

Imagine what an office would provide a new employee on their first day, beyond a smart head: a written job description, a list of rules and regulations, handover notes left by the previous employee, a thick standard operating procedure manual, guides for office software, ready-made scripts for automating tedious mechanical tasks, and a team of colleagues available for collaboration and task division.

An AI harness is essentially the digital twin of this work package. The paper systematically breaks it down into eight core components: Standing Instructions, Guardrails, Memory, Skills, Tool Guidance, Scripts, Helper Agents, and a lightweight plugin that can dynamically intercept and correct agent behavior. Each item is a separate file, and none modifies the underlying model weights. What they change is only what the model is told, what it remembers, and what it is allowed or prompted to do.

This workplace analogy also fits perfectly in another dimension: place the same talented employee in a well-organized, high-efficiency office versus a chaotic management quagmire, and you often end up evaluating two completely different people. No one would regard such a test as a pure measure of the employee's individual ability; yet today, when the industry reads 'Model A scored 72', it almost invariably falls into this one-dimensional misconception.

Adaptive evolution without a standard answer: correcting behavior rather than scoring right or wrong

The most intuitive way to optimize a harness is, naturally, to repeatedly try configuration changes and keep those that improve scores. But this approach requires an existing scoreboard, while in the real world, when agents face entirely new open-ended tasks, there are no preset scoring standards, because no one can provide the only standard answer in advance. The paper's innovative method bypasses this barrier by comparing the agents' behavior patterns rather than simply judging the absolute correctness of results.

The single-step optimization mechanism works roughly as follows: the agent first completes a full task run under the existing harness, and this run serves as the Reference Run. Then, an editing and tuning model reviews the entire execution trajectory and proposes two newly optimized harness configurations: the first targets common agent behavioral weaknesses, such as deficiencies in task planning, tool calling, and context tracking; the second specifically supplements domain knowledge and hard business rules for the particular specialized vertical.

Next, the two revised scaffolding sets are run again on the identical task, and their execution traces are compared in detail against the original baseline sample: did the revision precisely fix the intended flawed behavior, have no effect, or inadvertently break other normal steps? In the final step, the system selects and retains the improvements that have been proven effective in real use, merges them into one final scaffolding set, and uses it to produce the final deliverable. After the task is complete, the system also archives the lessons learned from this run into a case library for future reference in similar tasks.

The official description of this method is candid about what its baseline runs do: they “reveal the behavioral characteristics of the scaffolding, not whether its final deliverable is absolutely correct.” That is the honest core of the method. It cannot a priori determine whether an answer is right or wrong; what it can observe and capture are flaws in the execution behavior itself. The issues it successfully fixes are precisely those visible behavioral defects.

Consider a few typical failure cases that this method successfully fixed: in a complex professional office task, an agent had to synthesize a briefing memo from multiple scattered source files containing schedules, event venues, staff hours, and financial budgets. Its first run scored only 43.1 points. The execution log showed that the agent never cross-checked figures across different files throughout the process, and never reopened the generated file for review after drafting it. The automatically tuned scaffolding forced it to list each input dependency one by one, trace the original source of every number, and run a script at the end to reopen the finished file for verification. The final task score jumped to 77.8 points.

In another legal practice task, an agent had to review and annotate an arbitration procedural order. It initially saved all revisions in the tracked-changes layer of a Word document, so anyone reading the file as plain text could see only the final text with changes accepted, while the annotation trail was completely invisible. A newly injected skill package forced it to write explicit insertion and deletion markers directly in the body text, and the score rose from 44.4 to 94.5 points. In a third case, a research assistant agent fell into an endless retrieval loop and reached the delivery deadline with nothing to show; no deliverable file had been generated. A guardrail plugin that issued a mandatory warning after detecting a specified number of tool-only calls completely solved this procrastination problem.

It is clear that none of these defects resulted from a lack of knowledge in the model. These agents had sufficient knowledge of legal provisions, arithmetic logic, and coding standards; what they truly lacked was simply good professional habits: carefully review your work, write down findings in black and white, make sure readers can clearly see your changes, and decisively press the execute button when necessary. Professional habits are visible in the execution trace, unlike abstract answer correctness. This is why comparing execution traces can identify the root cause of problems even without a standard answer. It also reasonably explains why, on two of the three benchmarks, the relatively weaker model gained more improvement: it had more bad habits to correct.

The cost behind the overtaking: a stronger editor and additional compute usage

It must be noted that the optimized GLM-5 did not win this contest on its own. Its underlying scaffolding was rewritten by Claude Opus 4.8, which is significantly more capable than either competing model. Moreover, before the final deliverable was produced, each task was run multiple times: once as the baseline, once for each of the two candidate solutions, and once for the merged final version. By comparison, the control-group Gemini was run only once under its standard default scaffolding.

Therefore, the essence of this upset was GLM-5 augmented by a more powerful editor mentor and several times the additional run cost, competing against bare-metal Gemini without any external assistance. The resources and compute costs consumed by the two sides were entirely unequal, and the experimental results themselves never concealed this fact.

But two strong pieces of empirical evidence block the tendency to simply attribute this result to 'wholesale outsourcing to a stronger model.' First, the researchers specifically designed an ablation control experiment in which models self-edit and optimize the scaffolding, covering five models at different tiers from GLM-5 to Claude Opus 5. The test results showed that every model achieved a comprehensive improvement in self-scores across all benchmarks under this mechanism. This means the method's core logic does not absolutely depend on an external stronger teacher model, although the main experimental data tables still used the strongest model as the editor to pursue the best results.

Second, according to the author team's detailed compute accounting (combining all tokens consumed during tuning and editing with all tokens consumed during actual task execution), within the compute-budget test range they set, the method still outperformed all comparable approaches in performance-score yield per unit of compute cost. This is a rigorous empirical finding within a specific budget range, not proof that it is the best paradigm for all possible compute investments.

Equally important is the warning that modifying the scaffolding does not inherently produce positive gains. In two other published agent enhancement schemes, scores sometimes fell significantly below the unmodified original scaffolding; on coding tasks, the maximum drop reached 6.6 points. In another scheme, 7 of 12 benchmark-and-environment combinations scored below the initial baseline. Even using the paper's own editor, blindly rewriting the scaffolding without closed-loop validation through benchmark runs and a case library could cause the coding score to plummet from 73.4 points to 63.2 points. The system layer around a large model has extremely high leverage, enough to make final performance swing sharply up or down. The reason this experiment was able to push it steadily upward was entirely due to strictly following one rule: validating every change against the agent's actual runtime behavior.

Boundaries and implications of the empirical findings: benchmark scores have never been a bare-model contest

Based on the solid boundaries that existing data can support, we can draw a clear judgment: in office, professional consulting, and legal practice tasks, the scaffolding around large models is sufficiently substantial to completely reshape the relative win-loss rankings among models; at the same time, its adjustment cost is low enough to be dynamically customized for each specific task. This is exactly the full extent of what the paper has rigorously demonstrated.

But it does not prove that these improvements represent an absolute leap in intelligence in a deeper philosophical sense. Evaluation of these tasks relies heavily on large-model judge scoring, and in legal tests the criteria are also quantified checkpoint scoring rather than perfect completion of the entire task. The author team itself acknowledged that, without a fixed factual ground truth, merely comparing behavioral patterns cannot mathematically guarantee absolute correctness, nor can it ensure that a given change will generalize seamlessly to entirely new scenarios. In addition, the test sets are relatively limited in size (each domain contains only 25 to 100 tasks), so random fluctuations in a small number of tasks can move the overall mean. Finally, the data here also do not demonstrate a miracle of sustained snowballing self-evolution; the research team did not conduct ultra-long-horizon task-flow stress tests, nor did they claim to have achieved unlimited self-intelligence leaps.

Nevertheless, despite these objective limitations, the direction of technological evolution it points to is unmistakably clear. If a model's system environment can be automatically optimized and reconfigured by another AI within only a few task runs, then the so-called 'bare model under default scaffolding' no longer constitutes a natural baseline unit for measuring AI capability. It becomes only one ordinary configuration among countless possible ones, and often is not the configuration that anyone would actually adopt in real production practice.

We cannot expect that waiting for a more perfect base large model to emerge will make this layer of engineering scaffolding vanish into thin air. The many failures fixed in this experiment were all tightly intertwined with specific real-world working environments, such as underlying revision marks that readers simply cannot see, or research tasks nearing delivery deadlines that remain unwritten, and every new workplace in the real world brings its own friction. Even the most powerful model evaluated in the paper can still gain several points after its own system environment is tuned. A stronger model may require fewer reminders and corrections, but it still ultimately needs to clock in at a particular office, and the operations manual there must be written in advance by certain people or agents.

The agent that initially could only verbally recite tool instructions on screen was in no way inferior in its internal mental capacity to the agent that later could actually execute them. They were entirely the same brain, merely missing one key reminder in the work rules. The next time you see a benchmark leaderboard on social media declaring that one large model completely outperforms another, please be clear-eyed: that leaderboard records nothing more than two brains submitting answers in two offices with very different configurations, after a certain number of trial-and-error attempts. Before fully understanding who renovated the office behind the scenes and how many retake opportunities each received, the genuine intelligence information you can obtain from that chart is far narrower than it appears.

Source: TechFlow