One-sentence Summary

Salesforce AI Research and the University of Illinois Urbana-Champaign propose strong-to-weak scaffolding, a test-time capability transfer method in which a stronger builder model constructs inference-time harnesses that allow a weaker target model to nearly double its average performance on Theory-of-Mind benchmarks from $0.49$0.49 to $0.91$0.91 without any parameter updates, by offloading unstable model reasoning into deterministic code, benchmark-specific routing, and strict answer-format enforcement.

Key Contributions

• The paper studies strong-to-weak scafolding, a test-time paradigm where a stronger builder model constructs an inference-time harness that helps a weaker target model solve tasks without parameter updates.
• On four Theory-of-Mind benchmarks, using only 5% of data as a validation set, builder models iteratively refine harnesses and nearly double average target-model accuracy from 0.49 to 0.91.
• Analysis shows that the gains come from ofloading unstable model reasoning into deterministic code, benchmark-specific routing, and strict answer-format enforcement. Builder reasoning effort improves harness quality monotonically, and weaker target models receive the largest benefits.

Introduction

The authors study a practical alternative to model distillation: instead of training a weak model to match a stronger one, they let a strong builder model construct an inference-time harness (routing, prompts, deterministic solvers, verification, format enforcement) that makes the task easier for a fixed weak target model. Prior work either updates model parameters through distillation or fine-tuning, or improves a single model's reasoning via prompting and tool use, but does not transfer capability across models without training. The key contribution is formalizing strong-to-weak scaffolding as a distinct inference-time transfer setting and providing a systematic empirical analysis on Theory-of-Mind benchmarks, showing that well-designed scaffolds can boost a weak model's accuracy dramatically (e.g., from 0.49 to 0.91) by externalizing structured reasoning rather than relying on more training data or longer model reasoning.

Method

The authors propose an automatic harness-building framework in which a strong builder model $M_{\mathrm{build}}$Mbuild​ constructs an inference-time scaffold for a fixed, weaker target model $M_{\mathrm{tar}}$Mtar​. The goal is to improve the target model's performance on a collection of benchmarks by wrapping it with a custom inference procedure that can include prompt engineering, routing, pre/post-processing, verification, or other strategies.

For each benchmark $\mathcal{D}^{(j)}$D(j), a small validation split $\mathcal{V}^{(j)}$V(j) containing 5% of the examples is randomly sampled, and the remaining examples are set aside as a hidden test split $\mathcal{T}^{(j)}$T(j). The union of all validation splits is denoted $\mathcal{V}$V, and the union of all test splits is $\mathcal{T}$T. The builder model has access only to $\mathcal{V}$V during scaffold construction, while $\mathcal{T}$T is strictly held out for final evaluation.

At the start of a build run, the builder is placed inside an existing agentic coding harness $\mathcal{H}_{\mathrm{build}}$Hbuild​ and given an initial workspace

where $\mathcal{R}$R is a rule file describing task instructions and submission format, $\mathcal{C}_{\mathrm{demo}}$Cdemo​ is a demonstration file showing how to call $M_{\mathrm{tar}}$Mtar​, and $\mathcal{V}$V is the labeled validation set. The builder is not constrained to a fixed scaffold architecture. It may implement any inference-time procedure, such as prompt templates, benchmark routing, deterministic pre- or post-processing, answer-format enforcement, verification passes, few-shot retrieval, or direct symbolic solvers. The only requirement is that the final scaffold exposes a single entry point that can be applied to unseen test examples.

Conceptually, the builder searches over a space of possible scaffolds $\mathcal{S}$S to find the scaffold that maximizes accuracy on the hidden test set:

Since $\mathcal{T}$T is hidden, the builder instead uses validation performance as a proxy and selects a scaffold $\hat{S}$S^ by optimizing

The success of a scaffold therefore depends on identifying reusable task structure from the small validation slice and transferring it to the hidden test set. After the builder finishes, a human evaluator runs the exported entry point on $\mathcal{T}$T without further builder intervention. The overall process is summarized in Algorithm 1.

Experiment

The study evaluates strong-to-weak scaffolding, where a builder model writes a test-time harness to improve a weaker target model’s performance on Theory of Mind benchmarks. The experiments systematically vary the builder, platform, target, and builder reasoning effort, revealing that scaffolding consistently lifts the weak target, with the builder model and its reasoning budget being the dominant drivers of improvement, while the coding platform and the number of validation iterations have little effect. The gains arise from offloading structured sub-tasks into deterministic rules and from imposing reliable output formats, thereby reducing the target model’s cognitive load; the approach is most effective when the target has recoverable latent competence, and the remaining errors cluster in tasks that resist compilation, such as deep recursive belief tracking and Bayesian goal inference.

Scaffolding consistently lifts GPT-5.4-mini's macro-average accuracy from 0.488 to a mean of 0.763 across all runs, with every builder configuration outperforming the baseline. The best scaffolded run reaches 0.912, exceeding even the larger unscaffolded GPT-5.4 model, and the automated scaffold matches or surpasses a human-designed harness on the structured BigToM task. Residual errors remain concentrated in tasks demanding nested belief tracking or Bayesian inference, where the builder cannot fully compile away the reasoning burden. All 11 builder configurations improved over the no-scaffold baseline, and 100% of scaffolded runs exceeded it. The best run (GPT-5.5 on GPT Codex) achieved a 0.423 absolute improvement, an 87% relative uplift. The strongest scaffold outperformed both vanilla GPT-5.4 and GPT-OSS-120B baselines on every benchmark. On BigToM, the automated scaffold reached near-ceiling accuracy (1.00) and slightly exceeded the human-inspired harness (0.95). Top scaffolds fixed 83% of baseline mistakes while breaking only 7% of baseline-correct items, showing near-Pareto improvement. Remaining errors clustered in harder subtasks: Hi-ToM accuracy declined with recursion depth, and MMToM-QA errors concentrated in Bayesian goal-inference questions.

All scaffold builders substantially improve average accuracy over the no-scaffold baseline, with absolute gains of roughly a third or more. BigToM is near ceiling across builder models, while Hi-ToM, MMToM, and MuMA-ToM remain lower and more variable. The strongest builder configurations reach average accuracy above 0.85, and residual errors cluster in harder recursive, deceptive, and goal-inference cases. Every scaffold builder raises average accuracy well above the baseline, with absolute improvements ranging from roughly 0.31 to 0.39. BigToM is the most solved task component, reaching near-perfect or perfect accuracy for every listed builder. Top builder models such as GPT-5.5 and Opus-4.7 x-high achieve the highest overall averages, while no listed scaffold builder falls below 0.79.

Refinement improves validation accuracy for all builders, but the amount of improvement varies widely. Builders that start lower such as Sonnet and Gemini gain the most, while GPT-5.5 reaches the highest final validation accuracy and Opus variants tend to start stronger with smaller subsequent gains. Validation-full optimism gaps are mostly small and positive, indicating validation modestly overestimates full-set performance. GPT-5.5 attains the highest best validation accuracy despite having a lower first validation accuracy than the strongest-starting Opus variant. Sonnet and Gemini show the largest accuracy gains and also have the highest validation run counts. Opus variants generally begin with stronger validation accuracy but improve less than the largest-gain builders. GPT-5.4-mini records the smallest accuracy gain among the listed builders. Most validation-full optimism gaps are small and positive, while Gemini is effectively neutral.

Increasing the builder model's reasoning effort consistently improves scaffold quality, with pooled macro accuracy rising from 0.71 at low effort to 0.86 at extra-high effort. The largest gain occurs between low and medium effort, while further increases bring smaller but positive returns, and scaffold code length grows substantially with more deliberation. Pooled macro accuracy climbs monotonically with effort tier, from 0.71 (low) to 0.86 (extra-high), with a strong rank correlation between effort and per-run accuracy. Scaffold size expands from roughly 500–650 lines of Python at low effort to over 1000 lines at higher effort, indicating that more reasoning compiles additional decision logic into the harness.

Scaffolds targeting the weak GPT-5.4-mini model achieve higher final accuracy when a larger share of evaluation items are answered by deterministic code or rules, with a strong correlation (r=0.72) between determinism fraction and accuracy. This offloading reduces the reasoning burden on the target model, but its feasibility varies sharply across benchmarks: BigToM is almost fully offloadable, while MuMA-ToM resists compilation into structured code. Higher determinism fractions are strongly associated with higher accuracy (r=0.72): runs with determinism above 0.98 reach accuracies above 0.87, whereas the lowest-determinism run (0.75) yields only 0.749 accuracy. The ability to offload tasks to deterministic code is highly benchmark-dependent, with mean determinism ranging from ~0.94 in BigToM to ~0.36 in MuMA-ToM, where free-form dialogue reasoning is hardest to compile away.

the paper evaluate automated scaffold builders that compile reasoning strategies into code to assist a target model on theory-of-mind benchmarks. Scaffolding consistently improves accuracy over the no-scaffold baseline, with the best scaffolds surpassing larger unscaffolded models and achieving near-ceiling performance on structured tasks like BigToM. Residual errors cluster in nested belief tracking, Bayesian inference, and free-form dialogue reasoning, which resist compilation into deterministic rules. Builder model capability, reasoning effort, and the fraction of items offloaded to deterministic code all correlate with scaffold quality, though gains vary across benchmarks and builder types.