1 Introduction↩︎

Why solve the same problem twice? Current ML engineering agents do exactly this. MLE-Bench evaluates agents on 75 Kaggle competitions independently [1], and agents treat them independently too, resetting all state between tasks. Techniques that proved effective in one competition must be rediscovered from scratch in the next similar one. This redundancy is the cost of treating every competition as a cold start: many top-performing agents rely on frontier models, longer budgets, or both to compensate for repeated exploration.

Recent work has explored cross-task transfer [2]–[6], but stores knowledge in flat pools or by memory type. Agents with flat memory still lack the organization needed to load the right knowledge for the right task: everything goes into one context window, diluting the signal. Transfer helps only when the agent can select the right prior for the current task. The organization of accumulated knowledge therefore determines whether the agent spends its limited budget on useful exploration or on re-deriving known facts. We provide direct evidence that this distinction is consequential. In our controlled ablation, flat loading performs no better than loading no skills, whereas scoped hierarchical loading medals on every task.

HASTE (Hierarchical Accumulation of Skills for Transfer-Efficient ML Engineering) organizes accumulated skills into three scope tiers: global skills that apply across ML tasks, domain skills for tabular, vision, NLP, or audio tasks, and competition skills that remain tied to one dataset. An orchestrator coordinates domain specialists for tabular, vision, and NLP, each loading only the skills relevant to its scope. Between competitions, the orchestrator promotes learning upward via LLM-driven abstraction. This scoped loading means each agent sees only what is relevant, keeping prompts focused and iterations productive. The loaded skills act as a structured prior over the next code change. That prior keeps the per-task search narrow enough for a linear refinement loop to work: after two failed improvements the loop moves from broad exploration to optimization or fine-tuning, and any change that hurts validation score is reverted before the next step.

Across a multi-phase MLE-Bench Lite campaign, HASTE reaches the top public performance band using a non-frontier model and a 12h budget. Skill accumulation improves medal rate, reduces the number of refinement iterations needed, and raises the fraction of proposed changes that are worth keeping. A fixed-inventory ablation shows that accumulation needs scoped organization: tiered loading beats both flat and empty loading, while flat matches empty at much higher token cost.

1.0.0.1 Contributions.

The paper contributes a 3-tier hierarchical skill store with LLM-driven promotion between global, domain, and competition tiers, coupled to an orchestrator and matching domain specialists. It evaluates scoped loading directly with a fixed-inventory ablation, showing that hierarchy matters beyond skill volume: the same 159 skills help when loaded by scope but not when dumped into one flat prompt. To our knowledge, HASTE is the first MLE-Bench agent to organize reusable skills by cross-competition scope and evaluate scoped loading against flat and empty loading under a fixed inventory. The empirical study shows that this organization improves efficiency on MLE-Bench Lite, allowing a non-frontier model under a 12h budget to reach the same public performance band as stronger-model systems: a cold run with no accumulated skills achieves 40.9% medal rate, while reloading global and domain skills lifts the same system to 77.3%, flipping 8 of 13 previously failed competitions to medal. The study characterizes the resulting 159-entry plain-text skill inventory across 3 tiers and 4 domains.

2 Related Work↩︎

2.0.0.1 MLE-Bench agents and search strategies.

A first family of MLE-Bench agents advances the search axis. AIDE [7] runs greedy tree search; MLE-STAR [8] performs ablation-guided targeted refinement with web-retrieved priors; AIRA-Dojo [9] formalizes MLE agents as search-policy \(\times\) operator-set; R&D-Agent [10] separates a Researcher from a Developer. Population-based evolutionary search appears in LoongFlow [11] and FM Agent [12], whereas budget-aware or graph-augmented Monte Carlo search appears in MARS [13] and ML-Master [14]. HASTE contributes to the knowledge axis, which is orthogonal to search strategy and can be combined with any of these frameworks.

2.0.0.2 Cross-task knowledge transfer in LLM agents.

Several systems accumulate experience across tasks but store it as a flat pool. Voyager [5] maintains a code skill library indexed by embedding similarity in Minecraft; ExpeL [4] extracts natural-language insights via ADD/EDIT/UPVOTE/DOWNVOTE on a flat vector store; Reflexion [15] pioneered verbal self-reflection within a single task; ICAL [16] extends reflection to vision-language agents with a four-component knowledge structure. For data science specifically, Agent K [2] maintains persistent intrinsic state summarizing past episodes across competitions within an experiential-learning formalism; MLCopilot [3] retrieves related benchmarks via text embeddings and distilled knowledge; DS-Agent [17] combines embedding-ranked human-insight cases with iterative case-based reasoning; MLZero [18] separates semantic library knowledge from episodic execution traces; ADAS [6] evolves agents via Meta Agent Search over an archive of coded designs. SkillRL [19] reports a 25% performance collapse when distilled skills are replaced with raw trajectories, motivating aggressive compression.

4pt

Table 1 compares these systems by organization, cross-task scope, hierarchy, promotion, and MLE-Bench evaluation; HASTE is the only one that organizes reusable knowledge by scope of applicability.

2.0.0.3 Hierarchical organization in agent systems.

Hierarchy is well-motivated outside ML engineering. The options framework [20] introduced temporally extended actions in RL, building on feudal RL [21] where a manager sets sub-goals for a worker; feudal networks [22] formalized this with different temporal resolutions. For LLM agents, GITM [23] uses an explicit three-tier decomposition for Minecraft. It is the closest published precedent for a 3-tier organization, although its tiers are within-task layers rather than cross-task scope layers. CoALA [24] classifies agent memory by type, and [25] formalize how bounded-capacity agents benefit from multi-level knowledge organization. HASTE brings this principle to ML engineering with empirical validation. Its 3-tier skill store and orchestrator-specialist hierarchy mirror a feudal architecture in which managers at different levels decide what knowledge a subordinate executor should see, while the stored knowledge itself is organized by scope of applicability.

2.0.0.4 Automated pipeline search and meta-learning.

Earlier AutoML systems reduce the cost of building a pipeline for each new dataset by searching within predefined model and hyperparameter spaces. Predefined-space systems such as AutoGluon [26], TPOT [27], Auto-WEKA [28], and Auto-Sklearn [29], [30] search hand-engineered configuration grids. Meta-learning extensions (e.g., Auto-Sklearn warm-starting) accumulate cross-dataset experience as numerical meta-features and predict configuration vectors on new tasks. These systems are effective within their predefined space but cannot incorporate qualitative insights (“tokenization choice X breaks on dataset Y because of Z”). AgentHPO [31] tunes hyper-parameters; CAAFE [32] generates feature-engineering code; EvoPrompting [33] searches architectures; AutoML-GPT [34] orchestrates training from model and data cards. Across this group, accumulated priors remain flat or implicit; HASTE splits them into applicability tiers. HASTE keeps the same goal of reducing per-task search cost, but the search takes place in unbounded Python code rather than a fixed configuration grid. It makes that larger space tractable by reusing plain-text lessons extracted from prior runs and loading only the lessons whose scope matches the current task.

3 Method↩︎

Figure 1 shows the two hierarchies that co-evolve during a multi-competition run. The skill hierarchy has global, domain, and competition tiers. The agent hierarchy has an orchestrator and three domain specialists for tabular, NLP, and vision tasks. Scoped context loading connects them: each agent receives only the skill tiers matched to its scope. The search space remains unbounded Python code; we restrict only the distribution over that space using accumulated structured priors.

3.1 Skill Hierarchy↩︎

The skill store is a plain-text filesystem of markdown files with YAML frontmatter, organized into three tiers by scope of applicability. Global has 5 entries and is loaded by every specialist. Domain has 12 NLP, 19 tabular, and 15 vision entries, loaded only by the matching specialist. Competition has 108 entries across 21 directories, loaded only on re-runs of that competition.

Within each tier, HASTE distinguishes three kinds of entries, written into different prompt slots at different stages. Technique entries record what worked or failed and feed proposal prompts, for example “target encoding helps high-cardinality categoricals in tree models.” Commitment priors record which design choices have high cross-task variance and feed the prototype screen, telling the agent which choices require evidence before commitment. Refinement hints record which knobs to tune per model family and feed the optimizing and fine-tuning stages. Other systems collapse these into one “lessons” bag; we separate them because they answer different questions and enter the loop at different points.

Loading is deliberately simple: read the relevant directories and concatenate them. No embedding index is needed at the current scale of roughly 159 entries, with 10 to 60 loaded per agent. A character cap of 2000 in the prototype prompt and 4000 in refinement limits dilution if the inventory grows. The decision to avoid embedding-only retrieval follows recent results on the theoretical limits of single-vector embeddings for multi-field conditional retrieval [35]. Most skills come from an LLM reflection step at the end of each competition (Figure 8), in the spirit of Reflexion [15] and ExpeL [4], with paired success and failure analysis so that failure modes are recorded explicitly. Two skill types are additionally extracted algorithmically by a Prior Extractor. Commitment priors come from score variance across prototype model options; high variance implies a decision-relevant choice. Refinement hints come from per-knob deltas across refinement history, identifying which changes had the highest acceptance rate. These structured priors are mined from logs; to our knowledge, prior text-memory agents rely primarily on LLM summarization for this kind of memory.

3.2 Agent Hierarchy and Execution Loop↩︎

3.2.0.1 Orchestrator.

The orchestrator delegates experiment execution. Its responsibilities are: (i) domain classification, assigning each competition to a domain via manual tags for 100+ MLE-Bench competitions with a heuristic fallback; (ii) round scheduling, picking seeds first (one per domain for cold start) and then assigning remaining competitions to specialists; and (iii) skill promotion, evaluating new learnings via an LLM after each round (Figure 9). Promotion decides for each learning: skip (already covered), competition (too specific), domain (abstract and promote up one tier), global (universally useful), or conflict (contradicts an existing skill). When two learnings conflict, both are kept and annotated with conditions. For example, one skill records that ensembling helps when correlation is below 0.95, but hurts when a weaker member pulls down a stronger one. The store grows through abstraction and stays interpretable plain text on the filesystem. The top-level multi-competition loop is given in Algorithm 3 (Appendix 7.1).

3.2.0.2 Specialist.

Given a competition \(t\) and the scope-loaded skills supplied by the orchestrator, the specialist runs a five-stage per-competition pipeline. Appendix 7.2 gives the full pseudocode in Algorithm 4. (1) Task profiling: parse metadata, profile the dataset, select a CV strategy, and probe GPU/CPU/RAM; no model execution. (2) Prototype screen (Figure 6): the LLM proposes three fundamentally diverse approaches and executes each on a single validation fold; up to a \(2.7\times\) score spread between best and worst justifies this hedge against committing to a suboptimal foundation. (3) Adaptive refinement on the prototype winner with budget \(N{=}20\) and on the runner-up with \(N{=}6\) via AdaptiveRefine (Appendix 7.3), a linear loop across three tiers (Exploring, Optimizing, Fine-tuning) with auto-escalation on two consecutive non-improvements, stagnation exit at Fine-tuning, and revert-on-regression on every step (Figure 7); the runner-up branch is a second hedge, and in 3 of our 25 main-benchmark runs, the runner-up’s refined score beat the winner’s. (4) Ensemble: rank-average the top-3 checkpoints across both branches; accept the ensemble only if it beats the best single member. (5) Produce learnings (Figure 8): the LLM reflects on the full experiment history and emits 2 to 5 plain-text learnings, each with a proposed tier, which flow back to Algorithm 3 for promotion. A 6-mode failure taxonomy guides refinement diagnosis as prompt content: Underfitting, Overfitting, Feature_Gap, Noise_Ceiling, Distribution_Mismatch, and Diminishing_Returns. Tiered history compression keeps the prompt under 20 lines even at 50+ iterations.

This linear refinement loop is intentionally simpler than the trees, evolutionary populations, or MCTS used by other systems [7], [11]–[14]. We found linear refinement sufficient in this setting; the priors loaded by the orchestrator plausibly collapse the branching factor enough for linear search to match tree or evolutionary alternatives, but a controlled comparison at fixed knowledge condition is future work. The ablation in §4.5 shows the priors carry substantive weight at fixed search strategy: performance drops sharply when no skills are loaded.

3.2.0.3 Executor.

The executor is a pluggable backend; the agent has Read, Write, Edit, Bash, Glob, and Grep tools, a 3-attempt retry per step with diagnostic feedback between attempts, and validates submissions against sample_submission.csv (column names, row count, no NaN, dtype) before scoring. For cost efficiency, all experiments in this paper use the CLI backend (claude -p subprocess) billed via a fixed Claude Code subscription.

4 Experiments↩︎

4.1 Setup↩︎

We evaluate on MLE-Bench Lite [1], the 22-competition subset used for cross-agent comparison. Each competition runs Claude Sonnet 4.6 via the CLI backend on a SLURM node with 24 CPUs, 128 GB RAM, and 1 NVIDIA L40S 48 GB GPU. The wall-clock budget is 12h, half the dominant 24h budget on the leaderboard, with 20 iterations on the main benchmark and 11 on the ablation. The search space is unbounded Python code; evaluation uses the official Kaggle metric per competition, scored against held-out test sets via the MLE-Bench grader. No test labels are used in the iteration loop. Appendix 8 includes representative prompts, and Appendix 11 shows representative skills.

4.2 Main Results↩︎

6pt

Across the multi-phase accumulation campaign, HASTE’s medal rate on MLE-Bench Lite is 77.3% (17 of 22), with 10 gold, 2 silver, and 5 bronze. The above-median rate is 86.4%. The per-competition table is in Appendix 9.

Table 2 places HASTE among public MLE-Bench Lite results. At 77.3%, HASTE reaches the same performance band as leading public MLE-Bench Lite agents while using a non-frontier model and a 12h budget. Two features distinguish it from the rest of the top-tier agents. HASTE is the only non-frontier-model agent at or above 77%: every other agent in this band uses Gemini-3-Pro-Preview, Claude Opus 4.6, or a model ensemble. HASTE is also one of only two top-band agents running at 12h; all others use the standard 24h budget. We note that public leaderboard numbers carry per-task statistical noise (paper-reported SD \(\approx 4.4\)) and that a multi-seed confidence interval is still pending; differences of less than 5 points on Lite fall within that noise, and the headline 77.3% is a campaign result rather than a multi-seed estimate (§[sec:sec:limitations]).

A cold-start single-pass of HASTE achieves only 40.9%, which would place it below every agent on Table 2; tiered skill accumulation adds 36.4 percentage points to the same system, lifting it into the leading public performance band.

4.3 Evidence for Skill Transfer↩︎

Skill accumulation lifts medal rate from 40.9% (9 medals) in a single-pass cold run to 77.3% (17 medals) when later phases reload accumulated skills. A cold run starts without prior competition experience. A warm run starts with skills learned earlier in the campaign. For the warm transfer evaluation, HASTE reloads global and domain skills only. Competition-specific skills are not loaded, so the result measures transfer from reusable knowledge rather than leakage from a previous attempt on the same dataset.

The improvement shows up in three ways. First, warm-start runs need fewer refinement iterations to reach their best score: 7.8 on average compared with 16.3 for cold-start runs, a 52% reduction. Second, the agent keeps more of its own proposed edits as the skill inventory grows. We measure hit rate as the fraction of attempted changes that improve validation score and are kept rather than reverted. When the inventory has 0 to 15 skills, the hit rate is 42%; once 50+ skills are available, it rises to 85%. Third, of the 13 competitions that failed the cold run, 8 flipped to medal in the warm run, while the 9 competitions that already medaled cold were skipped in the rerun phase (Appendix 10). The store grew from 5 entries at cold start to 72 by phase 12, and each promotion step used LLM abstraction to keep the entries readable as plain text.

4.4 Phase 0, Refinement, and What the Agent Learned↩︎

Refinement beats the prototype winner in 92% of runs (23 of 25), with an average gain of \(+0.045\) in the competition’s native metric; in 3 competitions, the runner-up’s refined score beat the winner’s, and the two cases where refinement underperformed both occurred in early phases with fewer skills. The final 159-entry skill store breaks down as 5 global, 15 vision, 12 NLP, 19 tabular, and 108 competition entries, all traceable to specific runs and including both successes and failures. For example, the global skill “ensembling a strong model with a weaker model can degrade performance” was learned from dogs-vs-cats and later prevented the same mistake in two vision competitions; “DeBERTa-v3-base is the strongest text-classification start under a 12h budget” was learned from detecting-insults and applied in jigsaw-toxic and spooky-author. Appendix 11 lists representative skills with source competitions and estimated iteration savings.

4.5 Ablation: Tiered vs.Flat vs.Empty Skill Loading↩︎

We test the loading function directly while holding skill inventory constant, varying only skill organization. We run 8 competitions spanning NLP, vision, tabular, and audio domains under three conditions, with the same model (Claude Sonnet 4.6), pipeline, 11-iteration budget, and 159-skill inventory frozen at one point in the benchmark campaign. The conditions differ only in which skills enter context: Tiered loads global, domain-matched, and competition-specific skills only (10 to 60 entries per competition); Flat loads all 159 skills ( 145K characters), the “dump everything into the prompt” approach; Empty loads no skills.

The difference between loading functions is large despite the fixed inventory. Tiered loading achieves 100% medal rate (6 gold, 1 silver, 1 bronze), flat 62.5% (4 gold, 1 silver, 3 no-medal), and empty 62.5% (5 gold, 3 no-medal); mean test scores follow the same ordering (0.949 \(>\) 0.910 \(>\) 0.893). Figure 2 shows the per-competition breakdown; the full table is in Appendix 13.

Because the ablation is small, we treat the statistical tests as supporting evidence rather than a definitive test. With \(N=8\) and a single seed, formal tests are underpowered, but the qualitative pattern holds across measures. A paired bootstrap on per-competition score differences (tiered minus flat) gives a 95% CI of \([+0.001, +0.093]\) around a mean of \(+0.040\), which just excludes zero. The corresponding one-sided Wilcoxon signed-rank tests yield \(p=0.11\) for tiered \(>\) flat, \(p=0.08\) for tiered \(>\) empty (both paired across the same 8 competitions), and Fisher’s exact test on medal counts gives \(p=0.10\) for tiered (8/8) vs.flat or empty (5/8). The tests fall short of standard significance at \(N=8\); we report them transparently and emphasize the consistent direction of effect across all three measures. Multi-seed replication is the planned next step (§[sec:sec:limitations]).

The flat condition is especially informative because it tests whether more knowledge is enough. Flat skill loading leaves the medal rate unchanged relative to starting from scratch. Flat consumes 3.78M output tokens to empty’s 1.86M (tiered: 2.27M), doubling empty’s token cost for the same medal rate and a modestly higher mean score. The tokens per medal metric (total output tokens divided by medals won) makes the efficiency gap concrete: tiered spends 284K tokens per medal, flat 756K, and empty 371K (Figure 2b). Tiered is 2.7\(\times\) more token-efficient than flat per medal won. Flat runs the most experiments (75 vs.tiered’s 60 and empty’s 65) with a slightly higher execution success rate (87% vs.%), so the extra attempts appear poorly directed: more compute without medal-rate gains. Full resource breakdown is in Appendix 12.

The aggregate result hides where the difference is largest. The gap focuses on harder or niche tasks, where competition-specific skills provide a known-good starting point and domain skills guide model selection. On mlsp-2013-birds (audio), tiered scores 0.964 (gold) vs.flat 0.860 and empty 0.832 (neither medal); on random-acts-of-pizza, tiered 0.798 (silver) vs.flat 0.599 and empty 0.481. The 4 easier competitions, detecting-insults, histopathologic, tabular-playground, and plant-pathology, show smaller differences and all three conditions medal.

From the logs, three mechanisms appear to limit flat loading. Signal dilution: relevant skills are buried among domain and competition-specific skills for unrelated competitions. Context budget displacement: at  145K characters, the flat skill dump crowds out the agent’s own reasoning and code analysis. Overconfident model selection: in the flat-jigsaw rerun, the agent repeatedly attempted DeBERTa-v3-large (an aggressive NLP recommendation that triggered OOM) while the empty agent used simpler models and scored higher (0.985 vs.).

4.5.0.1 Scope of the ablation.

The flat condition couples three axes: organization, skill volume, and prompt-length budget (\(\sim\)​145K vs.\(\sim\)​25K characters). Because scoping is the mechanism by which the right 30 skills enter a 25K-character budget, a flat-but-character-capped condition that loads \(N\) random skills would test random subset selection, a different question. The supported claim is that, on this inventory, scoped loading outperforms both the flat full-load and empty-context baselines through the three mechanisms above; any broader claim about hierarchy reduces here to its role in enabling scoped loading at a controlled budget. The 159-skill inventory was itself accumulated under hierarchical promotion, so this ablation tests inventory transfer under different loading functions; a fully flat pipeline end-to-end remains a separate condition.

5 Discussion↩︎

5.1 Why Hierarchy Makes Agents Faster↩︎

The efficiency gain depends on scoped loading in addition to accumulation, and the ablation supports this as the main mechanism. A flat skill store sends every specialist unrelated advice, including domain tricks for other modalities and competition-specific quirks from unrelated tasks. Tier scoping keeps the context small and matched to the current agent; the resource table shows the cost of failing to scope, with flat loading spending substantially more tokens without improving on empty’s medal rate.

5.2 Per-Domain Performance and Token Usage↩︎

Per-domain medal rates on the full benchmark are uneven: vision 80% (8/10), NLP 100% (6/6), tabular 40% (2/5), and the single audio competition (mlsp-2013-birds) reached gold. Remaining failures such as taxi-fare and dog-breed likely need approaches still absent from the skill store. Token usage scales sub-linearly with skill inventory: warm-start runs need fewer refinement iterations, so per-competition tokens drop as the store grows; per-condition totals are in Appendix 12.

5.3 Limitations↩︎

Single-seed evaluation is the main limitation. This choice matches the efficiency positioning of the work, but multi-seed replication at the full 75-competition benchmark is the priority for follow-up runs with additional compute. The §4.5 ablation tests scoped loading while holding inventory fixed. Other engineering components, including the prototype screen, runner-up branch, rank-average ensemble, failure taxonomy, auto-escalation, and revert-on-regression, remain for an analogous component-wise study.

6 Conclusion↩︎

These results suggest that knowledge organization can partly substitute for model strength and compute budget in ML-engineering agents: HASTE reaches competitive MLE-Bench Lite performance with a non-frontier model under a shorter budget, and the fixed-inventory ablation points to scoped loading as the source of the gain over skill volume alone. Multi-seed replication, held-out evaluation, full 75-competition runs, and retrieval-augmented loading at scale are next.

Impact Statement↩︎

This work aims to improve the efficiency of ML engineering agents through reusable knowledge organization. Its broader impacts are those of ML engineering automation generally; we do not foresee additional direct societal risks from the hierarchy mechanism itself.

7 Algorithms↩︎

7.1 Orchestrator↩︎

Algorithm 3 gives the top-level multi-competition loop described in §3.

7.2 Specialist Pipeline↩︎

Algorithm 4 formalizes the five-stage per-competition pipeline described in §3.2.

7.3 Adaptive Refinement Loop↩︎

Algorithm 5 gives the inner refinement loop invoked twice by the specialist, on lines 4 and 5 of Algorithm 4: once on the prototype winner with budget \(N{=}20\), once on the runner-up with budget \(N{=}6\). The three tiers, Exploring, Optimizing, and FineTune, progress under auto-escalation. Two consecutive non-improvements advance the tier; stagnation at FineTune exits the loop; revert-on-regression keeps a bad change from carrying into the next step.

8 Prompts↩︎

We include the four key prompts that drive the system.

8.1 Prototype Screen↩︎

The prototype screen prompt (Figure 6) is used at the start of each competition. It injects the resource probe and any accumulated skills, and asks the LLM for three diverse model proposals.

None

8.2 Refinement Proposal↩︎

The refinement proposal prompt (Figure 7) is the per-iteration call inside AdaptiveRefine. It carries the current tier, compressed history, and the loaded skills, and uses the six-mode failure taxonomy to structure the next change.

None

8.3 Learning Production↩︎

The learning production prompt (Figure 8) closes each competition. The specialist reflects on its full experiment history and emits two to five plain-text learnings, each with a proposed tier.

None

8.4 Skill Promotion↩︎

The skill promotion prompt (Figure 9) runs between rounds. The orchestrator evaluates each new learning against existing skills and decides skip, competition, domain, global, or conflict.

None

9 Per-Competition Main Benchmark Results↩︎

Table 3 reports per-competition results on MLE-Bench Lite.

10 Cold Run vs.Warm Run↩︎

Table 4 compares cold-run and warm-run outcomes across all 22 MLE-Bench Lite competitions. Nine competitions already medaled on the cold run (with few or no accumulated skills) and were skipped in the rerun phase. Of the 13 that failed the cold run, 8 flipped to medal on the warm run with accumulated global and domain skills, accounting for the lift from 40.9% to 77.3% medal rate. The remaining 5 failed both attempts.

4pt

11 Representative Skills↩︎

Table 5 shows representative entries from the skill hierarchy with their source competition and an estimate of how many refinement iterations they saved on later, similar tasks. The full skill inventory contains 5 global, 15 vision, 12 NLP, 19 tabular, and 108 competition entries.

12 Ablation Resource Breakdown↩︎

Table 6 reports the full resource usage of the three ablation conditions: medal rate, mean test score, output token consumption, wall time, experiments attempted (with success rate), and skills loaded. The headline finding (flat doubles empty’s token cost for fewer medals) is in §4.5; this table provides the supporting detail.

13 Ablation Per-Competition Table↩︎

Table 7 gives the full per-competition scores and medals for the controlled ablation (Figure 2 in the main text).

5pt

References↩︎