Agent performance depends on both reasoning ability and the environment in which it acts. Most research focuses on improving the model itself, but this paper from Apodex and the University of Illinois Urbana-Champaign takes a different approach: it studies test-time AI-for-AI, asking how a Builder model can learn to construct better execution environments for a Target model while both models' weights remain fixed. The core contribution is the meta-skill — a reusable principle specifying when support is needed, what resources to provide, and how the Target should use them. The Builder learns these principles from Target execution feedback on a development set, then uses the frozen skill bank to construct harnesses for unseen tasks. Across Harness-Bench and NewtonBench, full-bank meta-skills improve macro-average performance by 8.95 percentage points over no-skill construction, and 12.02 points over direct delivery of the same bank to the Target. When the same model serves both roles, gains reach 18.71 points on average, suggesting a path to system-level self-improvement through learning to build better environments.

Why Environment Design Matters More Than Model Scaling

The AI community has long treated agent performance as primarily a model-capability problem. If an agent fails, the instinct is to fine-tune, prompt-engineer, or swap in a stronger model. But an agent's effectiveness is equally determined by its execution environment — the tools, memory systems, control loops, and verification mechanisms that surround it. A capable PhD student who spends days repeating experiments because configurations are scattered across scripts will outperform a less capable student with a well-organized lab notebook, reproducible tooling, and clear validation workflows. The same principle applies to AI agents. This paper formalizes that intuition: instead of teaching the Target to solve tasks better, teach the Builder to design better support structures. Both models stay frozen; only the Builder's external knowledge bank changes.

Prior Work and the Gap This Paper Fills

Test-time AI-for-AI has two main threads. One searches agent programs and workflows — Automated Design of Agentic Systems, AFlow, Darwin Gödel Machine, and Meta-Harness all optimize the agent code itself. The other, strong-to-weak harness construction, uses a stronger Builder to supply executable support for a weaker Target. This paper builds on the second thread but adds a critical piece: reusable construction principles learned from actual execution feedback. Prior skill-learning work (Voyager, ExpeL, Agentic Context Engineering, SkillRL, Evo-Harness) focuses on task skills — how to perform a task. Meta-skills are different: they are principles for designing the support that helps the Target perform it. At the meta level, Meta Context Engineering and MetaSkill-Evolve learn skills for constructing context or improving task skills, but they don't separate the Builder's support-design knowledge from the Target's task knowledge. This paper's distinction — meta-skills guide support design, task skills guide execution — is the key conceptual advance.

What Is a Meta-Skill

A meta-skill is a triple: (when, provide, use). The when field identifies observable conditions that call for support — for example, "an artifact was edited after validation, making the earlier check potentially outdated." The provide field specifies the capability or resource the environment should supply — in this case, "version tracking and revalidation." The use field explains how the Target should employ that support while retaining responsibility for judgment — "inspect the current validation result before submitting, while retaining responsibility for content judgment and correction." This three-part structure ensures meta-skills are actionable, not just advisory. They don't tell the Target what to think; they tell the Builder what to build and the Target how to use what was built.

The Construction–Execution–Reflection Loop

The learning process starts with an empty meta-skill bank. For each development task, the Builder constructs a harness using the neutral baseline environment, public component interfaces, and its current skill bank. The Target executes within that harness, producing a public execution record and a benchmark-native score. The same Builder then reviews the generated harnesses and the Target's execution feedback to identify an observed error or recurring burden that better support could address. It compares the resulting lesson with the current bank and either revises an existing meta-skill (when evidence corrects or strengthens guidance), adds a new meta-skill (for a distinct reusable support need), or keeps the bank unchanged. Each batch permits at most one addition or revision, and it must cite supporting evidence from that batch. This constraint keeps the learned guidance grounded in observed behavior rather than hallucinated best practices.

After two development-set passes, the bank freezes. At test time, for each new task, the Builder receives either the full bank or a BM25-retrieved subset (top two skills with positive relevance scores) and constructs a fresh, task-specific harness. The framework exposes seven optional harness component families: instructions, memory, context organization, composed tools, execution control, verification and recovery, and workspace preparation. The Builder selects and implements these components, deciding what memory stores to create, when to retrieve them, which tools and resources the Target receives, and how to structure the execution loop. Within the resulting harness, the Target reasons over observations, uses the available tools, and remains responsible for the final submission.

Experimental Setup: Harness-Bench and NewtonBench

The paper evaluates on two benchmarks. Harness-Bench covers 106 agent workflow tasks (11 development, 95 test) with a budget of 30 model turns, 30 tool calls, and 96K cumulative tokens per task. NewtonBench covers 324 interactive scientific law discovery tasks (32 development, 292 test) with 12 turns, 10 tool calls, and 192K tokens. The Builder is GPT-5.6-Sol across all experiments. Three Targets are tested: Gemini-3.6-Flash, Qwen3.8-Flash, and GPT-OSS-120B. All models run at temperature zero with high reasoning effort. Harness-Bench reports deterministic completion-oracle score averaged over test tasks. NewtonBench reports symbolic-structure accuracy. Both use end-to-end evaluation; harness-construction failures score zero.

Five baselines provide controlled comparisons: Native environment (Target alone in baseline environment), No-skill Builder (Builder constructs harnesses with empty skill bank), Direct Builder skills (Target receives meta-skills directly as instructions, no Builder harness), Independent structured Target skills (separate GPT-5.6-Sol learner extracts structured problem-solving skills from Target's neutral executions, supplied directly to Target), and Mined free-form Target skills (GPT-5.6-Sol consolidates Target's neutral trajectories into free-form notes, supplied directly to Target). The Direct baseline controls for semantic knowledge; the No-skill baseline controls for construction capability.

Main Results: Enactment Beats Instruction

The full-bank meta-skill Builder achieves 65.31% macro-average score across all six model-benchmark combinations. The no-skill Builder scores 56.36% — a gap of 8.95 percentage points attributable purely to the learned meta-skills, since construction capability is identical. More strikingly, the full-bank meta-skill Builder outperforms Direct Builder skills (full bank delivered to Target) by 12.02 points on average, with improvements up to 25.43 points on individual model-benchmark pairs. The same semantic knowledge, when enacted by the Builder as executable harness components rather than passed to the Target as instructions, produces substantially better outcomes.

The Independent Structured Target skills baseline — where a separate learner extracts task skills from the Target's own executions — scores 54.38% macro average, 10.93 points below the meta-skill Builder. Teaching the Builder to translate experience into executable support beats teaching the Target additional task skills. Mined free-form Target skills fare even worse at 51.23%.

Three patterns emerge. First, meta-skills are most useful when the teacher can enact them. The Builder translates declarative principles into persistent state, executable tools, verification logic, or control decisions, reducing the Target's burden to interpret and apply advice at inference time. Second, experience improves the Builder beyond construction capability — the 8.95-point gain over the no-skill Builder shows that accumulated guidance helps the Builder decide which support to build and how to integrate it with Target behavior, though gains vary across Targets and benchmarks. Third, experience helps most when coordination is the main bottleneck. On NewtonBench (recurring coordination failures across experimentation, reasoning, and symbolic submission), gains average 10.96 points over no-skill Builder. On Harness-Bench (heterogeneous workflows where support depends on Target-specific planning), gains average 6.95 points. Fourth, broad skill access usually outperforms sparse retrieval — full bank beats top-2 retrieval in five of six settings, with 7.19-point average gain on NewtonBench, suggesting complementary procedures whose combined value lexical retrieval misses.

Meta-Skill Refinement: Delayed Gains and Non-Monotonic Progress

Freezing the skill bank after zero, one, or two development passes reveals how meta-skills develop. On NewtonBench, the first pass changes scores by less than 1.1 points; the second adds 13.01 points for Gemini and 12.33 for Qwen. Average gain from zero to two passes across all settings is 10.42 points. Early updates gather local observations; later revisions connect them into reusable interventions. But refinement is not monotonic. On Harness-Bench, Gemini improves with each pass, but Qwen drops 4.06 points from its first-pass peak. Revisions can sharpen guidance while making it overly specific to recently observed evidence. Effective learning requires both continued refinement and selective retention — a practical update rule should use development-only evidence to assess confidence in revisions and decide whether to continue, retain an earlier version, or roll back.

Self-Improvement Through Harness Design

The same model can serve as both Builder and Target. Across three settings using Gemini-3.6-Flash and Gemini-3.1-Pro, meta-skills yield average gains of 18.71 points over no-skill construction and 14.14 points over skills delivered directly to the Target. This identifies a distinct axis of self-improvement: improving how a model equips itself, without weight updates or a stronger teacher. As the Target's capabilities improve, the Builder can adapt its support to the Target's changing needs, while execution feedback informs further support refinement. Self-evolution involves coordinated improvement in both task-solving capabilities and the environments that support them.

Transfer Across Builders and Targets

Meta-skills specify support principles while leaving implementation to the Builder. The paper tests cross-Builder reuse by having Gemini-3.1-Pro construct harnesses using a frozen bank learned by GPT-5.6-Sol from Qwen-Flash executions. On NewtonBench, the Sol-to-Qwen bank yields a 13.36-point gain with Sol but a 4.45-point decline when transferred to Gemini-Pro; on Harness-Bench it yields a 2.72-point gain. Transfer is feasible but benefits depend on how the receiving Builder translates shared lessons into a harness — different Builders implement the same guidance differently. Recipient-side learning (Gemini-Pro learning its own bank from Qwen-Flash executions) outperforms the imported bank by 3.69 points on Harness-Bench and 9.93 points on NewtonBench, suggesting learning from the recipient's own harness executions better aligns meta-skills with its implementation choices.

More surprisingly, transferring Sol's Gemini-derived bank to Gemini-Pro building harnesses for Qwen yields gains of 4.58 points on Harness-Bench and 5.48 points on NewtonBench. On NewtonBench, the transferred bank scores only 0.68 points below Gemini-Pro's own Qwen-derived bank and outperforms the imported Sol-to-Qwen bank (which matches the receiving Target). The relevance of learned support principles may matter more than an exact source-Target match — guidance learned for one Builder-Target pair can remain useful when another Builder implements it for a different Target.

Which Harness Components Drive Gains

Ablation studies on NewtonBench isolate harness components. Removing the execution controller lowers scores for all three Targets: by 13.36 points for Gemini, 4.79 for Qwen, and 1.03 for GPT-OSS. The controller's role in improving execution is consistent, though only Gemini's confidence interval excludes zero. The benefit size varies with Target behavior and controller design — functions may include experiment sequencing, state tracking, or submission management. Effective harness design uses external coordination where it helps, tailoring the controller's functions to each Target's execution needs.

Removing memory plus context yields small positive estimated effects for Gemini and Qwen and a negative effect for GPT-OSS, though all confidence intervals contain zero. Additional state can preserve useful evidence, but its value depends on keeping that evidence relevant and avoiding redundant or outdated information. Meta-skills should support selective state exposure by guiding what to retain and when to surface it for the Target.

Outcome Transitions: Closing the Execution Gap

Aggregate scores conceal offsetting gains and regressions. Pairing full-bank and no-skill Builders on all model-task pairs reveals outcome transitions. On NewtonBench, cases with no valid submission fall from 394 to 254 (35.5% reduction), while correct discoveries rise from 439 to 535 (21.9% increase). Transitions include 145 recoveries from no valid submission to a correct law versus 46 regressions. Meta-skills enable more reliable completion of the scientific loop, creating opportunities for correct discovery. Valid-but-incorrect submissions also rise from 43 to 87 — completion enables but does not guarantee correctness. On Harness-Bench, full successes increase from 59 to 67, largely through transitions from partial to full success. Meta-skills help agents satisfy remaining requirements and turn partial progress into complete task fulfillment.

Benefits recur across Targets with task-dependent variation. All three Targets improve on NewtonBench by 6.85–13.36 points, with positive category-level estimates for gravity, radioactive decay, and Hooke's law across models. Harness-Bench shows gains for every Target on SRE/release tasks, with mixed effects elsewhere. GPT-OSS improves by 5.20 points overall but declines by 2.23 points on vertical workflows, illustrating that positive aggregate gain can coexist with category-specific regressions. This motivates reusing support principles while adapting their implementation to each Target's capabilities and the task's demands.

Limitations and Trade-Offs

The paper acknowledges several limitations. First, the meta-skill bank is learned from only two development passes with at most one update per task per batch — a constrained budget that may not capture all reusable principles. Second, the fixed BM25 retrieval for test-time skill selection is a simple baseline; the paper notes that broader access is not uniformly beneficial and motivates retrieval methods accounting for skill complementarity and Target response. Third, refinement is not monotonic — Qwen's Harness-Bench regression after the second pass shows that revisions can overfit to recent evidence. The authors suggest a practical update rule using development-only evidence to assess revision confidence, but this remains unimplemented. Fourth, cross-Builder transfer shows uncertain benefits (confidence intervals include zero), and the mechanism for why some transfers work better than others is not fully explained. Fifth, the self-improvement experiments use only Gemini variants; generalization to other model families is untested. Sixth, the framework assumes a fixed set of harness component families — the seven families may not cover all useful support types, and the Builder's ability to innovate new component types is limited by the provided interfaces.

What This Means for Practitioners

For developers building agent systems, the meta-skill framework offers a concrete alternative to prompt engineering and fine-tuning. Instead of stuffing more instructions into the model context, you build a separate Builder that learns from execution failures and constructs task-specific harnesses. The three-field meta-skill format (when, provide, use) forces clarity about trigger conditions, resource provision, and Target responsibilities — a discipline that prevents vague "best practice" advice from polluting the skill bank. The construction-execution-reflection loop is implementable with current LLM APIs: run the Target in a harness, capture the execution trace and score, feed both to the Builder with the current skill bank, and ask it to propose an evidence-grounded addition or revision.

The full-bank advantage over retrieval suggests that at current skill-bank scales (the paper's banks contain fewer than 20 meta-skills after two passes), putting everything in context works better than trying to retrieve relevant subsets. But the exception on Harness-Bench for Qwen (where retrieval slightly outperforms full bank) warns that this won't hold as banks grow. Practitioners should monitor for retrieval degradation as a signal to invest in smarter selection.

The controller ablation result is practically significant: execution control (sequencing, state tracking, submission management) consistently improves performance across all Targets. If you add one harness component first, make it a controller. Memory and context show promise but with high variance — design them for selective exposure, not indiscriminate accumulation.

For teams considering self-improving agents, the same-model results (18.71-point average gain) are the most actionable finding. You don't need a stronger model to improve your agent; you need your agent to spend some of its compute budget learning to build better harnesses for itself. The loop is: execute, reflect, distill meta-skills, rebuild harness, repeat. This is computationally cheaper than fine-tuning and doesn't require human annotation.

The Bigger Picture: Advisors Over Solvers

This paper reframes agent improvement as an environment-design problem. The meta-skill framework formalizes the advisor-student relationship: the Builder learns from the Target's struggles and encodes reusable support principles. The Target retains full judgment responsibility; the Builder only shapes the conditions under which that judgment is exercised. This separation of concerns — meta-skills for support design, task skills for execution — scales better than monolithic prompting because it lets each role specialize. As models become more capable, the bottleneck shifts from reasoning to coordination, verification, and resource management — exactly the problems meta-skills address. Better agents may begin with better advisors.

Read the paper on arXiv