The authors distill 1,000 popular machine-learning repositories into 5,353 verified agent skills. The same Codex agent with the same GPT-5.5 model scores 73% instead of 31% on MLE-bench when it can load those skills. The model and the harness do not change. Only the operating context changes.
A machine-learning research agent has two parts. The model supplies reasoning, planning, and code. The harness supplies the loop: orchestration, memory, verification, and retries. The authors argue that a third layer is missing. They call it operational knowledge: what turns "I know this method" into "I can make this method run": which package implements it, how the data must be laid out, which configuration works, and which mistakes cost a run.
The knowledge exists in repositories, documentation, tests, and papers. But those sources are written for humans and are too large for the context window. So the agent rediscovers it by trial and error. Each failed run costs budget, and the agent loses what it learned when the task ends.
The paper uses the Agent Skills format that Claude Code and Codex already read. One skill is a folder with three layers. SKILL.md is the entry point. It states what the skill does, when it applies, the procedure, worked examples, and known failure modes. The agent reads only this file first. references/ holds the deep material: API documentation, parameter tables, algorithm detail. The agent opens it only when a step needs it. scripts/ holds executable wrappers with fixed inputs and outputs. The agent runs them instead of rewriting the code.
This layering is progressive disclosure: the agent sees a short summary first and opens detail only on demand. So it can hold thousands of skills at the cost of their summaries. One repository usually yields several skills, so the authors organize them as a skill graph. An entry skill states the scope of the source and points to component skills for data preparation, training, evaluation, serving, and troubleshooting. The agent reads the entry, follows the links the task needs, and leaves the rest closed.
The system is called DisCo. It runs in two modes over the same model and harness. In creator mode it turns a source into a skill graph. In researcher mode it solves a task with those graphs loaded. A creator run has four stages. Scope: decide which capabilities of the source are worth exposing. Ground: gather evidence for each capability from the source's code, docs, examples, tests, and configuration. Construct: wrap executables behind stable interfaces and assemble the three layers into a graph. Verify: test the graph before it enters the library.
The authors say verification separates distillation from summarization. DisCo installs the package in a private environment and checks import names, versions, public signatures, and CLI entry points against the live code. It writes assertion-backed test cases and runs the repository's own tests where they are safe. A failed check that points at the skill triggers a local repair and a rerun. Every accepted graph records the source commit, the package version, and any gap the checks did not close.
Two triggers start a run. Task-agnostic distillation starts from a source, a repository or a paper, and runs ahead of time to produce long-lived skills. Task-oriented distillation starts from a task: it decomposes the task, finds the capability gaps, searches the web for sources, and builds the skills that task class needs.
Creator mode is paid once per source, about 40 US dollars per repository with GPT-5.5 at high reasoning effort. Researcher mode pays only for the skills a task opens.
Task-agnostic distillation over 1,000 widely used ML repositories produced the AREX-Skill Library: 5,353 skills in 1,000 skill graphs. A router indexes them by 20 areas and 178 capability families. An LLM built the taxonomy from short repository summaries, with star counts withheld so popularity did not shape the tree. At task time the agent narrows from area to family to repository graph and loads only that branch. The library is public on GitHub.
All main comparisons fix the harness (Codex), the model (GPT-5.5 at high reasoning effort), and the run-time budget. The only variable is access to DisCo skills.
On MLE-bench, 75 Kaggle-style competitions, the share of competitions with any medal rose from 31.1% to 72.9% over three runs. On the hard tier it rose from 13.3% to 62.2%. The skill-equipped agent also passed the best public leaderboard entry, at 64.4%. On PaperBench, reproducing 20 ML papers, the replication score rose from 29.5 to 39.6. Skills improved 18 papers and hurt 2. On FrontierCS, 188 open-ended algorithm tasks, the score rose from 70.6 to 77.1. On PassNet, compiler-pass generation, the main score rose from 1.34 to 1.53, correctness rose from 81% to 91%, and failed samples fell from 14 to 5.
The caveats matter. The baseline is weak. Plain Codex at 31% is far below the other public MLE-bench agents, at 61% to 64%. The 134% relative gain is measured against that weak base; the gain over the strongest published agent is 8.5 points. The construction budget is not counted. For MLE-bench, each competition got its own skill graph, built with up to 24 GPU-hours of trial runs on that same competition, plus web search with the competition page blocked. The frozen skill then guided a separate 24 GPU-hour run. The skill condition therefore got practice that the baseline did not get. The FrontierCS graph was refined on development problems from the same benchmark. Skills make the agent work more. On FrontierCS, tokens per task rose from 2.5 million to 4.5 million and steps from 56 to 89. The authors show per-task gain does not correlate with the extra usage, but the cost is real. Regressions are not visible in the averages. On FrontierCS, 74 tasks improved, 66 did not change, and 48 scored lower, by 8.8 points on average. The two PaperBench regressions both had above-average baselines. The authors blame retrieval precision: a retrieved skill led the agent away from a strategy it would have found alone. One model, one harness. The main results use only GPT-5.5 inside Codex, and all numbers are the authors' own runs.
Load the library. It is public and in the standard Skills format, so a Claude Code or Codex setup can load it now. It helps most if your agents use ML libraries such as sentence-transformers, vLLM, diffusers, and LangGraph. The router is also a working example of exposing thousands of skills without loading all of them.
Run the recipe on your own repositories. Internal services, deploy tooling, and data pipelines hold the same kind of operational knowledge. Do not skip the verification gate: test each skill against the live package, and record the commit, the version, and the gaps you could not close. A skill without that record is a summary, and a summary goes out of date.
Write rules as defaults, not bans. In the PassNet skill, an absolute warning against reimplementing vendor kernels blocked a valid optimization on a convolution whose stride equals its kernel size. The fix was to state the rule as a default with the conditions for an exception. Also keep a fallback: the regressions came from a poorly matched skill, so let the agent return to unguided reasoning when the skill does not fit.