AI4AI at Test-Time: Strong-to-Weak Capability Transfer via Harnesses

Cheng Qian, Wenting Zhao, Liangwei Yang, Heng Wang, Jielin Qiu, Heng Ji, Silvio Savarese, Huan Wang, Shelby Heinecke

Stronger models can automatically build inference-time harnesses to improve weaker models without parameter updates.

Can a strong "builder" model improve a weaker target model's performance at inference time by iteratively constructing a scaffold (harness) for it?

Small models often fail on complex tasks not just due to limited internal capability, but because the task presentation imposes excessive cognitive load. The authors propose "strong-to-weak scaffolding," where a strong builder model constructs an inference-time harness—including routing, deterministic solvers, and format enforcement—to shape how a weaker target model reasons. This approach is highly effective: the best automated scaffold nearly doubles the performance of a weak target model, often matching or exceeding the gains of using a larger, unscaffolded model.

Paper Primer

The method treats scaffold construction as an optimization problem where a builder model iteratively refines an executable entry point using a small validation set. The builder's core move is to offload fragile reasoning into deterministic code and structured task-routing: it identifies reusable task logic and converts it into a persistent harness that the target model executes at test time.

Strong-to-weak scaffolding provides large, robust performance gains for weaker models.

Across 57 runs, the mean macro-accuracy of the target model (GPT-5.4-mini) improved from 0.488 to 0.763. +0.275 absolute gain; the best individual scaffold reached 0.912 (+0.423).

Builder reasoning effort is a monotonic lever for scaffold quality.

Increasing the builder's deliberation time consistently improved the final scaffold's accuracy, with no evidence of over-engineering even at the highest effort tiers. Spearman $\rho = 0.77$ correlation between effort tier and per-run accuracy.

Why use this approach instead of standard model distillation?

Standard distillation requires updating the target model's parameters, which is computationally expensive and requires training data. Scaffolding improves performance at inference time without retraining, making it a flexible complement for agentic systems.

Does the harness platform (the coding environment) dictate the success of the scaffold?

No. The builder model's identity and reasoning effort are the primary drivers of quality; the platform is a second-order factor that only provides an advantage when the builder has sufficient reasoning budget to exploit its specific affordances.

Scaffolding acts as a "competence-recovery" mechanism: it helps most when the target model has latent ability that it fails to deploy reliably. When a target model is already near-ceiling, additional scaffolding can interfere with correct behavior.

For developers, this suggests that "harness engineering" can be automated: rather than manually designing prompts, one can task a stronger model with building a reusable, deterministic scaffold to unlock the latent potential of smaller, cheaper models.

Introduction

Introducing inference‑time scaffolding to transfer capability from strong to weak models.

Most distillation work focuses on updating the weak model’s parameters during training, assuming that capability gaps can only be closed by additional learning.

A strong builder model designs an inference‑time scaffold that guides a fixed weak target model, so the target can solve tasks without any weight updates.

The builder consumes only 5 % of the data as a validation set, repeatedly improving its harness over several rounds before the final scaffold is frozen and applied to the hidden test set.

Across four Theory‑of‑Mind benchmarks, this test‑time transfer nearly doubles the weak model’s macro‑average accuracy—from 0.49 to 0.91—demonstrating a large, robust effect.

Analysis shows that the improvement stems less from prompting the target to reason longer and more from offloading unstable reasoning into deterministic code, routing examples to specialized sub‑procedures, and enforcing a strict answer format.

Builder reasoning effort correlates monotonically with scaffold quality, platform variations (different builder back‑ends) have modest impact, and the weakest targets gain the most relative improvement.

We contribute (1) a formal definition of strong‑to‑weak scaffolding as an inference‑time capability‑transfer paradigm, (2) a comprehensive empirical study of its effect size, stability, validation efficiency, and causal mechanisms, and (3) actionable design principles—deterministic offloading, benchmark‑aware routing, format control, and targeted decomposition—that consistently yield strong gains.

The key shift is moving from training‑time distillation to inference‑time scaffolding as a practical route for strengthening weak models.

Related Work

We situate our scaffold approach among prior work on distillation, prompting, tool use, harness engineering, and Theory‑of‑Mind.

Capability transfer and distillation studies how a larger or stronger model can teach a smaller, cheaper model. Classical knowledge distillation matches softened teacher outputs, while recent methods add rationales, step‑by‑step traces, or on‑policy feedback to guide the student. Instruction tuning and RLHF similarly reshape model policy via supervised or preference signals, but they still modify the weak target’s parameters rather than its inference environment.

Inference‑time reasoning, prompting, and decomposition improve reasoning without fine‑tuning. Chain‑of‑thought elicits intermediate steps, self‑consistency aggregates multiple reasoning paths, and least‑to‑most breaks hard problems into easier subproblems. Iterative refinement, Tree‑of‑Thoughts, and Graph‑of‑Thoughts treat reasoning as a search over structured intermediate states, yet they all operate on a single model at test time.

Tool use, programmatic reasoning, and deterministic offloading view reasoning failures as execution failures. Toolformer learns when to call external APIs, ReAct interleaves language reasoning with tool actions, and PAL/Program‑of‑Thoughts translate problems into executable code. Faithful chain‑of‑thought separates symbolic reasoning from deterministic solvers, demonstrating that moving fragile cognitive work to external, checkable components can boost reliability.

Harness engineering and automated scaffold construction treat prompts, tools, memory, routing, and validation as optimizable system components. DSPy compiles declarative LM pipelines, SWE‑agent optimizes the agent‑computer interface, and ADAS/meta‑harness discover scaffold code via meta‑agents. Harness‑Bench evaluates scaffold configurations under shared budgets, while surveys argue that code is becoming the operational substrate for state, verification, and feedback‑driven control in agentic systems.

Theory‑of‑Mind (ToM) benchmarks stress tracking observations, beliefs, intentions, and nested perspectives. BigToM, Hi‑ToM, MMToM‑QA, MuMA‑ToM, and ToMBench probe increasingly deep recursive belief reasoning, revealing that strong models still falter as recursion depth grows. UserHarness shows that explicit reconstruction of user mental states can serve as a hand‑crafted ToM scaffold, motivating our investigation of whether strong builders can automatically discover reusable ToM scaffolds for weaker targets.

The Scaffolding Framework

Method builds a validation‑driven scaffold for a fixed weaker target model.

The builder model receives only the small validation split $V$ and must synthesize an inference‑time scaffold that will succeed on the hidden test split $T$.

The builder is a strong, fully‑featured model that can run arbitrary code to design the scaffold.

Is the builder model used at inference time on the hidden test set?

No. The builder only runs during scaffold construction; the exported scaffold is the only component that processes $T$.

The target is a weaker model that will be deployed unchanged and must obey the scaffold’s entry point.

Does the target model get any additional training after the scaffold is built?

No. The target remains fixed; only the scaffold’s inference‑time logic changes.

The scaffold is an inference‑time harness that wraps the target, encoding reusable task structure discovered from $V$.

How does a scaffold differ from a simple prompt?

A prompt is just a text template; a scaffold can embed arbitrary code (routing, verification, symbolic solving) and therefore implements richer inference‑time procedures.

Sample a 5 % validation split $V$ from benchmark $D(j)$ and reserve the rest as hidden test $T$.

Initialize workspace $W_0=\{R, C_{\text{demo}}, V\}$ and place the builder inside harness $H_{\text{build}}$.

Iteratively propose a candidate scaffold $S$ and evaluate its accuracy $Acc_{S}(M_{\text{targ}};V)$ on the validation set.

Select the scaffold $\hat{S}$ with highest validation accuracy as the proxy optimum.

Export $\hat{S}$’s entry point; a human evaluator runs it on hidden test $T$ without further builder access.

Workspace $W_0$ contains $R$, a demo call $C_{\text{demo}}$, and the single validation example.

The builder tries three candidate scaffolds: $S_1$ (plain prompt), $S_2$ (prompt + verification), $S_3$ (prompt + routing).

Validation accuracies: $Acc_{S_1}=0$, $Acc_{S_2}=1$, $Acc_{S_3}=0$ (the single example is answered correctly only by $S_2$).

The builder selects $\hat{S}=S_2$ as the proxy optimum.

Exported scaffold $S_2$ is run on the 19 hidden examples; it achieves 12 correct answers (63 % accuracy).

This tiny toy shows how a single validation example can steer the builder toward a scaffold that generalizes substantially better than a naïve prompt.

**Figure 1.** Overview of the Strong-to-Weak Scaffolding evaluation framework. During recursive scaffold building, the builder model iteratively refines a scaffold to improve target-model performance on validation sets. During hidden evaluation testing, the final scaffold is evaluated on the full hidden test set to measure target-model performance.

Experimental Setup

Describes the iterative scaffold‑building process and experimental configuration for evaluating ToM tasks.

The target model alone cannot reliably solve Theory‑of‑Mind questions, so we need a scaffold that offloads reasoning. The builder model therefore iteratively refines a harness that structures the target’s inference.

At each round the builder inspects the current resources, proposes a new scaffold, evaluates it on a held‑out validation set, and uses the errors to improve the next scaffold.

How does Recursive Refinement differ from ordinary iterative fine‑tuning of a model?

Fine‑tuning updates the model’s parameters directly, whereas Recursive Refinement keeps the builder’s parameters fixed and instead iteratively rewrites an external scaffold that the target consumes. The builder never changes; only the scaffold evolves based on validation feedback.

Initialize builder workspace $W_0 \leftarrow \{R, C_{\text{demo}}, V\}$.

Set empty scaffold $S_0 \leftarrow \emptyset$ and iteration counter $k \leftarrow 0$.

While the builder has not submitted a scaffold:

Export final scaffold $\hat{S} \leftarrow S_k$ as executable entry point $f_{\hat{S}}(x; M_{\text{tar}})$.

Run hidden evaluation on test set $T$: $\hat{Y}_T \leftarrow f_{\hat{S}}(T; M_{\text{tar}})$ and report $\text{Acc}(\hat{Y}_T, Y_T)$.

Workspace $W_1$ becomes $\{R, C_{\text{demo}}, V, S_0, a_0=0.33, E_0\}$.

Builder uses $W_1$ to generate $S_1$, which corrects one of the two errors, yielding $\hat{Y}_V = [\text{right},\text{right},\text{wrong}]$ and $a_1 = 2/3$.

New error set $E_1$ now contains a single item; $W_2$ is updated accordingly.

After a third iteration the scaffold achieves $\hat{Y}_V$ = all correct, $a_2 = 1.0$, and the loop terminates.

The refinement process quickly concentrates on the remaining mistakes, turning a coarse scaffold into a perfect validator in just a few iterations.

The evaluation task aggregates four Theory‑of‑Mind benchmarks (BigToM, Hi‑ToM, MMToM‑QA, MuMA‑ToM) into a hidden 3,900‑item test set. Each builder also receives a 195‑item validation sample drawn with a fixed random seed.

We vary three hyper‑parameters: the platform (Cursor, Claude Code, GPT Codex), the builder model (Opus‑4.7, Sonnet‑4.6, GPT‑5.5, etc.), and the target model (GPT‑5.4‑mini, Gemini‑3.5‑flash). Each configuration is repeated three times to assess scaffold stability, yielding 72 runs in total.

Baselines are (i) Vanilla, where the target receives the raw prompt (macro‑average accuracies 0.488 for GPT‑5.4‑mini, 0.761 for Gemini‑3.5‑flash) and (ii) Human‑Inspired Harness (UserHarness) with macro‑average accuracies 0.939 and 0.941 respectively.

Results Overview

Scaffolding consistently boosts the GPT‑5.4‑mini’s accuracy across builders and platforms.

Scaffolding raises the GPT‑5.4‑mini’s mean accuracy from 0.488 to 0.763, a +56% relative gain, and the top scaffolded run reaches 0.912, surpassing the vanilla GPT‑5.4 baseline.

Table 1 reports the vanilla baseline at 0.488, the average of all scaffolded runs at 0.763 (+0.275), and the best run at 0.912 (+0.423, 86.7%).

**Figure 2.** Overview of the GPT-5.4-mini as target main results. (a) The mean accuracy of each evaluated builder–platform configuration, with blank cells indicating configurations that were not run. (b) The builder-level mean accuracy, with individual runs displayed as platform-colored markers. The dashed line denotes the reference baselines.

Scaffolding consistently improves target model performance.

Main Results and Stability

Scaffolding lifts GPT‑5.4‑mini to near‑ceiling accuracy while remaining reproducible.

Scaffolding raises the macro‑average accuracy of GPT‑5.4‑mini by +0.275, with every scaffolded run surpassing the no‑scaffold baseline.

Mean macro‑average 0.763 vs. baseline 0.488; 100 % of 57 runs exceed the baseline.

**Figure 3.** Main results by builder model and benchmark with GPT-5.4-mini as target. (a) The performance by builder model, averaged over platforms×repeats; R denotes the number of runs pooled. (b) The per-benchmark comparison between the best scaffold and three references: raw no-scaffold GPT-5.4, raw no-scaffold GPT-OSS-120B, and the human-inspired harness.

**Figure 4.** Each marker shows one repeat's full-set macro-average for a platform–builder combination setting, sorted by the average score; tight clusters indicate reproducible builds, while long bars indicate occasional weak scaffold builds.

Validation Refinement Dynamics

We assess how validation‑driven refinement impacts final performance and builder quality.

We examine how each builder refines its scaffold on the validation slice, tracking evaluation count, accuracy progression, and transfer to the full test set. The target model is GPT‑5.4‑mini.

The table lists various "Builder" models and their performance metrics, including "Val. Runs", "First", "Best", "Gain", and "Val-Full Gap".

Best validation accuracy is a strong proxy for final full‑set performance (Pearson $r$ = 0.96).

Figure 5 left panel shows a near‑one‑to‑one relationship across all builders.

Number of validation iterations is essentially uncorrelated with final full‑set accuracy (Pearson $r$ = 0.17).

Figure 5 right panel demonstrates the weak relationship.

**Figure 5.** Illustration of builder’s refinement dynamics. (a) Validation accuracy increases over iterations for each builder, using carry-forward averages across repeats. (b) Two scatter plots share the same full-set accuracy axis: the best validation score closely tracks final full-set performance (r = 0.96), whereas the number of refinement iterations is largely unrelated to it (r = 0.17).

Scaffolding Techniques and Platforms

Evaluating how the coding platform influences scaffold quality and builder performance.

We now ask whether the agentic coding environment—the platform on which a builder writes its scaffold—systematically improves scaffold quality when the target model is fixed to $GPT\text{-}5.4\text{-mini}$.

The taxonomy is a twelve‑item toolbox that classifies every scaffold‑building trick observed across runs.

How does this taxonomy differ from simply listing prompts used by the builder?

Prompts are individual input strings; the taxonomy groups the underlying engineering controls (format checks, decoding settings, routing logic, etc.) that shape how those prompts are generated and interpreted. It captures the procedural scaffolding rather than isolated textual cues.

**Figure 6.** Technique prevalence and solution approach statistics across runs and benchmarks. (b) Solution approach across benchmarks.

**Figure 7.** Platform effects with GPT-5.4-mini as the target. (a) Comparison of each builder's neutral Cursor run with its native-platform run, showing that matched native advantages are small and inconsistent. (b) We isolate Opus-4.7 across the full effort ladder, and shows the native-platform advantage emerges only at higher reasoning effort. (c) The pooled run distributions by platform. Overall, platform matters primarily as a second-order, conditional factor than as the main driver of scaffold quality.

Switching from the neutral Cursor platform to a builder’s native platform changes macro accuracy by only $+0.013$ on average, a non‑significant effect (paired permutation test $p=0.484$).

Averaged across eight matched builder‑platform configurations, the native advantage is modest and statistically unreliable.

For Opus‑4.7, the native Claude platform overtakes Cursor only at medium and higher reasoning effort, delivering a maximum accuracy gain of $+0.045$.

At low effort the native platform lags by $-0.034$, but at medium effort it leads by $+0.045$, with high and extra‑high effort still ahead ($+0.038$, $+0.032$ respectively).

Target Model Generalization

Scaffolding yields up to a 36.7% absolute accuracy boost on Gemini‑3.5‑flash.

We isolate the effect of the target model by fixing the platform (Cursor) and swapping only the downstream model between GPT‑5.4‑mini and Gemini‑3.5‑flash, evaluating five distinct builders.

Scaffolding the Gemini‑3.5‑flash target improves absolute accuracy by up to $+0.367$ compared with the GPT‑5.4‑mini baseline.

Opus‑4.7 (x‑high) builder yields $0.761$ accuracy on Gemini versus $0.488$ on GPT, a $+0.273$ uplift; the largest observed uplift across all builders is $+0.367$.

Across the five builders, the average uplift when moving from GPT‑5.4‑mini to Gemini‑3.5‑flash is $+0.225$ (± 0.04), confirming that the effect is consistent rather than isolated to a single builder.

**Figure b.** The headroom law, with each point denotes one builder×benchmark run.

Detailed Target Model Results

Scaffolding lifts weak targets far more than strong ones, with gains tied to remaining headroom.

Scaffolding improves the weak target GPT‑5.4‑mini by +0.262.

Averaged over three repeats, performance rises from 0.488 to 0.750.

The headroom law indicates that the more latent competence a target leaves unused, the larger the gain from scaffolding. This explains why weaker models, which have higher 1 − baseline, reap bigger improvements.

For GPT‑5.4‑mini the uplift is spread across all four benchmarks, whereas Gemini‑3.5‑flash gains are almost entirely from BigToM. The pattern mirrors each target’s remaining headroom on those tasks.

Builders adapt by delegating more to the target’s native reasoning when scaffolding a strong model, reserving rule‑based interventions for the residual headroom. This strategic shift is evident across all tasks.

When the target is near ceiling, additional scaffolding can disturb correct behavior, leading to systematic regressions. Selective, headroom‑aware scaffolding is therefore essential for strong models.

Builder Reasoning Effort

Increasing the builder’s deliberation improves scaffold quality across platforms.

We fix the builder to Opus‑4.7 and the target to GPT‑5.4‑mini, then vary only the builder’s reasoning effort across four tiers: low, medium, high, and extra‑high. The sweep runs on both Claude Code and Cursor, isolating the effect of builder deliberation from model identity and platform choice.

**Table.** Technique prevalence statistics across runs.

Builder reasoning effort yields a monotonic increase in macro accuracy.

Pooled accuracy rises from $0.711$ (low) to $0.793$ (medium), $0.807$ (high), and $0.856$ (extra‑high); Spearman $\rho = 0.77$.

Extra‑high effort significantly outperforms the high tier.

Accuracy $0.856$ vs. $0.807$; permutation‑test $p = 0.013$. It also beats the low tier ($p = 0.002$).

The biggest jump occurs from low to medium effort.

Accuracy improves from $0.711$ to $0.793$, a gain of $+0.082$; subsequent tiers add smaller increments.

Platform‑specific results show Claude Code improving from $0.694\pm0.004$ (low) to $0.872\pm0.005$ (extra‑high) with Python LOC rising from $653$ to $1{,}274$, while Cursor improves from $0.728\pm0.036$ to $0.840\pm0.020$ with LOC $510arrow987$.

Attribution of Improvement

We isolate which scaffold techniques drive the target’s accuracy gains.

To understand why scaffolds help, we compare the mean full‑set accuracy of runs that employ each technique against runs that omit it, then validate the patterns with three orthogonal checks.

Polarity/negation logic yields the largest positive lift, $+0.09$ in mean accuracy.

Mean accuracy with the technique exceeds the mean without it by $0.09$ points (see Figure 9a).

Structured extraction contributes $+0.06$ mean‑accuracy gain.

Runs using structured extraction outperform their counterparts by $0.06$ points on average (Figure 9a).

Hybrid fallback adds $+0.04$ to mean accuracy.

Mean accuracy difference $Δ = +0.04$ when hybrid fallback is present (Figure 9a).

Techniques that appear in almost every run—greedy decoding and benchmark routing—show small or negative $Δ$ values, but these should not be read as harmful because their contrast groups are tiny and unusually weak.

The best scaffold fixes $1{,}717$ baseline errors while breaking only $105$ correct predictions.

Paired McNemar test over $3{,}900$ items yields $χ^2 \gg 10^4$, $p < 10^{-4}$, confirming a highly asymmetric error shift.

Self‑scaffolding raises accuracy by $+0.22$ over the no‑scaffold baseline.

Mean accuracy of GPT‑5.4‑mini runs with a self‑generated scaffold exceeds the baseline by $0.22$ points (Table 7, “Acc.” column).

Stronger builders achieve an additional $+0.31$ gain on GPT Codex compared to self‑scaffolding.

When a more capable builder constructs the scaffold, GPT Codex’s accuracy improves by $0.31$ points relative to the self‑scaffold condition (Table 7).

**Figure 9.** Technique-level attribution analysis. (a) Mean accuracy of runs using each technique vs. not using. $n_{with}$ denotes the number of runs using the technique. Associational/universal techniques have small $\Delta$ for lack of a contrast group. (b) The technique's association with accuracy: difference in mean full-set accuracy between runs that use each technique and runs that do not.

Table 7 summarizes builder‑platform configurations: detection fraction ranges from $1.00$ down to $0.10$, while accuracy varies from $0.912$ to $0.605$, illustrating how stronger builders and higher detection fractions correlate with better performance.

Cognitive Load Reduction

Deterministic offloading correlates with higher accuracy, showing the scaffold reduces the target’s cognitive load.

We quantify the scaffold’s ability to offload reasoning by measuring the determinism fraction—the proportion of evaluation items answered entirely by code or deterministic rules.

The scaffold removes the bulk of routine reasoning from the weak target model, letting the target focus only on the residual, harder cases.

Higher determinism fractions yield substantially higher final accuracy.

Across 18 runs with GPT‑5.4‑mini as the target, a Pearson correlation of $r=0.72$ links determinism fraction to accuracy.

When determinism fraction drops from near‑perfect (≈1.00) to low (≈0.10), accuracy falls by about 21 % absolute.

Runs with determinism = 1.00 achieve $0.879$ accuracy, while runs with determinism = 0.10 achieve $0.664$.

**Figure 11.** Deterministic offloading as a measure of cognitive-load reduction. (a) scaffolds answering a larger share of items without target-model calls tend to achieve higher final accuracy. (b) offloadability varies sharply by benchmark: BigToM is almost fully compilable into code, whereas MuMA-ToM remains substantially model-dependent.

**Table c.** Per-benchmark accuracy uplift.

Remaining Error Analysis

We dissect remaining errors to reveal where scaffolding still falls short.

Recall that strong‑to‑weak scaffolding lets a powerful Builder iteratively craft a harness that reduces the Target’s reasoning load.

Top scaffolds fix 83 % of baseline‑wrong items while breaking only 7 % of baseline‑correct items, showing a Pareto‑improving effect.

Figure 12(b) quantifies the fix‑break asymmetry across the eight strongest GPT‑5.4‑mini scaffolds.

Read the original paper

Open the simplified reader on Paperglide

Browse all simplified papers