arXiv CSopen access

RESOURCE2SKILL: Distilling Executable Agent Skills from Human-Created Multimodal Resources

R ESOURCE 2S KILL: Distilling Executable Agent Skills from Human-Created Multimodal Resources Yijia Fan3,∗ Zonglin Di1,∗ Zimo Wen2,∗ Yifan Yang3,+ Mingxi Cheng3 Qi Dai3 Bei Liu3 Kai Qiu3 Yue Dong3 Ji Li3 Chong Luo3 1 University of California, Santa Cruz

arXiv:2606.29538v1 [cs.SE] 28 Jun 2026

∗ Equal contribution.

Code

a

2 Shanghai Jiao Tong University

3 Microsoft

+ Corresponding author: [email protected].

Dataset

Project Page

Video

Representative outputs

Web no skills

Excel with skills

Blender no skills

with skills

PPT with skills

UE5 no skills

no skills

no skills

with skills

Reaper with skills

with skills

no skills

Figure 1: R ESOURCE 2S KILL distills multimodal resources into a hierarchical Skill Wiki across seven creative software domains.

Abstract Skills are a useful abstraction for software agents, turning human and agent experience into reusable procedural knowledge. Yet existing skill libraries are mostly hand-written, text-centric, or derived from agent traces, leaving tutorial videos and other multimodal human resources largely underused. We present R E SOURCE 2S KILL, a framework that distills multimodal resources—tutorial videos, repositories, articles, and reference artifacts—into executable skills for software agents. R ESOURCE 2S KILL organizes these skills as a hierarchical multimodal Skill Wiki, where each entry combines structured text, code, visual examples, metadata, and provenance. This design preserves complementary signals from different resources: videos capture temporal operations and visual effects, code captures executable tool patterns, and articles or artifacts provide conceptual and stylistic grounding. At inference time, agents retrieve and compose relevant skills from the wiki; when coverage is insufficient, the same construction operator can acquire new skills online. Across seven practical authoring domains, R ESOURCE 2S KILL improves average overall score by +11.9 percentage points over no-skill agents and outperforms strong harness baselines in 26 of 28 main-aggregate model–domain Preprint.

cells. Ablations confirm the value of multimodal skill format, hierarchical organization, source diversity, selection strategy, and online acquisition.

1

Introduction

Large language model agents [Luo et al., 2025] are increasingly expected to do more than answer questions: they must operate software, call tools, inspect intermediate results, and produce highquality artifacts such as slide decks, spreadsheets, web pages, 3D scenes, CAD designs, and audio projects. In these settings, success often depends less on isolated factual knowledge than on reusable procedural know-how: how to decompose a goal, which tool or API pattern to use, what intermediate state to inspect, and how to recover when an operation fails. We refer to such reusable procedural knowledge as skills. In the agent era, skills provide a natural abstraction from experience to reusable expertise: they convert observations of how tasks are solved into compact instructions, code fragments, visual references, and execution recipes that can be repeatedly invoked by future agents. Recent skill-based agent systems [Xu and Yan, 2026] have already shown that such abstractions can be highly valuable. Code agents and software assistants benefit from reusable tool-use routines, while manually authored skill hubs have become a practical way to encode expert conventions for document editing, programming, data analysis, and other text-heavy workflows. However, existing skill libraries are still largely limited by how they are created: they are either hand-written by experts, accumulated from an agent’s own interaction traces, or mined from text/code resources. This leaves a major source of human expertise underused. For many commercial and creative software tasks, the most natural way humans learn is not by reading static documentation, but by watching tutorials, demonstrations, and screen-recorded workflows. A video tutorial can reveal the temporal order of operations, the visual effect of each editing step, and tacit design choices that are difficult to express in text alone. This observation motivates a broader question: Can we automatically distill skills from multimodal human-created resources, especially tutorial videos, and use them to build a scalable skill library for software agents? The answer is not straightforward. Although frontier models have seen massive amounts of text during pretraining, and text resources are routinely exploited through retrieval and search, high-dimensional multimodal resources remain much harder to use effectively at inference time. Directly placing raw videos into an agent’s memory is expensive, redundant, and often impractical. A single tutorial may contain minutes of irrelevant setup, repeated narration, and visual details that are important only at a few key moments. At the same time, compressing video into a plain text summary discards precisely the information that makes video useful: dynamic operations, before-after visual changes, animation quality, spatial layout, timing, and tool interaction order. A practical system must therefore extract the procedural signal from videos and other resources, normalize it into a reusable representation, and organize the resulting knowledge so that agents can efficiently retrieve and execute the right skill for a new user request. We introduce R ESOURCE 2S KILL, a framework for distilling executable skills from human-created resources and organizing them into a maintainable multimodal skill library for software agents. Given multimodal resources—including tutorial videos, source repositories, articles, documentation, and reference artifacts— R ESOURCE 2S KILL extracts domain-specific skills and stores them in a hierarchical Skill Wiki. Each skill is represented as a multimodal entry that may contain structured text, executable or adaptable code, visual examples, metadata, and provenance. This design makes the skill library more than a flat collection of retrieved passages: text explains applicability and mechanism, code provides tool-grounded execution patterns, and visual examples preserve layout, style, motion, and other perceptual information that text alone under-specifies. A central design choice of R ESOURCE 2S KILL is to treat skill construction and skill use as a unified pipeline. Offline, we distill large-scale resources into a domain wiki for important commercial software scenarios. At inference time, given a user requirement, the agent first navigates the hierarchical index to form a candidate skill pool, then reads the relevant multimodal entries and composes them during execution. This hierarchical organization improves over flat retrieval because it encodes domain structure, narrows the search space, and exposes skill candidates at the appropriate level of abstraction. Moreover, when the offline library does not cover a requested capability, the same resource-to-skill operator can be invoked online to search for new resources, extract additional 2

skills, and incrementally extend the library. The resulting system is therefore not a fixed prompt collection, but a growing and maintainable procedural memory. We study R ESOURCE 2S KILL across seven practical software-authoring domains, including slide design, web page generation, spreadsheet authoring, Blender scene creation, CAD design, UE5 scene construction, and music production. These domains are chosen because they require different forms of procedural knowledge: some depend heavily on code and API conventions, some on visual design and layout, and others on temporal operations that are naturally conveyed by video. Our experiments show that skill access consistently improves agent performance across model backends and domains. Across our seven authoring benchmark suites (Web, Excel, Reaper, PPT, Blender, CAD, UE5), R ESOURCE 2S KILL improves the average overall score by +11.9 percentage points over the same agents without skills, and outperforms strong agentic-harness baselines in 26 of 28 main-aggregate cells. Ablations further show that the hierarchical wiki interface, source diversity, multimodal skill format, library scale, online skill acquisition, and hierarchy-then-LM selection strategy each contribute to the final performance. Our contributions are summarized as follows: • Resource-to-skill learning for software agents. We formulate the problem of distilling reusable executable skills from multimodal human-created resources, with tutorial videos as a key underused source of procedural and perceptual knowledge. • A hierarchical multimodal skill library. We propose a Wiki-based organization in which each skill combines structured text, executable or adaptable code, visual examples, metadata, and provenance, enabling agents to retrieve, inspect, and compose skills across diverse software domains. • A unified offline-online construction pipeline. The same resource-to-skill operator is used both to build large offline skill libraries and to acquire new skills online when user requirements expose capability gaps, making the library maintainable and incrementally extensible. • A broad empirical study across commercial authoring tasks. We evaluate R E SOURCE 2S KILL on seven authoring benchmark suites. Skill access yields consistent gains over no-skill agents and strong harness baselines, while controlled ablations isolate the value of source mix, multimodal format, wiki organization, selection strategy, and online acquisition.

2

Related Work

LM agents and reusable memory. Recent agents combine reasoning with tool invocation, executable actions, and execution feedback [Yao et al., 2023, Karpas et al., 2022, Schick et al., 2023, Patil et al., 2023, Qin et al., 2024, Shen et al., 2023, Gao et al., 2023, Liang et al., 2023, Ahn et al., 2022, Shinn et al., 2023, Madaan et al., 2023], and are now evaluated on realistic web and software-engineering tasks [Yao et al., 2022, Deng et al., 2023, Zhou et al., 2024, Liu et al., 2023, Jimenez et al., 2024, Yang et al., 2024]. Procedural knowledge in these systems is largely implicit in weights, prompts, or interaction history; retrieval and memory work [Robertson and Zaragoza, 2009, Guu et al., 2020, Lewis et al., 2020, Borgeaud et al., 2022, Karpukhin et al., 2020, Park et al., 2023, Packer et al., 2023] and skill-library agents [Wang et al., 2024a, Gao et al., 2023, Liang et al., 2023] make it explicit, but typically rely on self-generated traces rather than external human references. Procedural knowledge from human-created resources. Instructional videos [Miech et al., 2019, Zhukov et al., 2019, Tang et al., 2019, Grauman et al., 2022, Fan et al., 2022], web pages [Nakano et al., 2021], and public code with documentation [Chen et al., 2021, Husain et al., 2019] carry rich procedural supervision, but their raw form—long videos, descriptive articles, scaffolding-heavy repositories, outcome-only artifacts—is poorly matched to agent execution and is usually consumed as pretraining or retrieval context. R ESOURCE 2S KILL instead distills them into a validated multimodal wiki, turning source type, modality, library scale, and selection strategy into controlled design variables. Comparison with skill-library frameworks. VOYAGER [Wang et al., 2024a], AWM [Wang et al., 2024b], ASI [Wang et al., 2025], and S KILL F LOW [Zhang et al., 2026] grow text- or code-only libraries online from a single domain’s agent traces or failures and retrieve by dense similarity or 3

Resource2Skills Pipeline 5. Skill-Grounded Agent

2. Parse & Distill

1. Sources

4. LM Wiki

Video Tutorials

Structured, cross-source knowledge of skills for creation. Extract, segment, and normalize into skills

Code Repos

Visual

Text Explanations, concepts, instructions

Diagrams, UI screens, images, illustrations

3. Quality Gates Code

Static Artifacts

Test Tasks Multi-domain creation tasks

Step-by-step procedures, parameters, examples

• Deduplication • Completeness • Executability • Safety

Benchmark Protocol

Metadata tier

category

tags

source

exec_ok

Linked, versioned, and traceable.

Methods Compared Full Wiki Our complete LM Wiki

Compose Artifact Agent Actions

VS

Unstructured files/snippets

read code

read text

view visual

adapt

combine

provenance

No Skills

VS Agent without skills

8. Rendered Outputs Slides Site Sheet 3D Scene Audio Game CAD Plan

6. Domain Adapter Translates selected skills into domain-specific structures and constraints.

Vision Judge

Flat Library

PPT Web Excel Blender Reaper UE5 CAD

Select Skills

search

Articles

7. Domains

Browse Wiki

LLM-as-a-Judge with vision. Rubric-based assessment.

Scores

• Quality • Correctness • Completeness • Fidelity • Creativity

Multiple seeds per task → average scores with confidence intervals

Figure 2: R ESOURCE 2S KILL pipeline. A construction operator (fθ , AD ) distills resources into the hierarchical Skill Wiki; M ETA B ROWSE retrieves candidates and the language model selects from text/visual/code views, applied through MCP to a domain backend. The same operator is reused online when the offline pool is insufficient. repair rules; Anthropic Agent Skills [Anthropic, 2025] ships hand-authored text/code/asset bundles without automatic acquisition; S KILL F OUNDRY [Shen et al., 2026], closest in spirit, mines text/code skills offline into a top-down knowledge tree for scientific computing. Our work differs by combining offline-mined multimodal skills (videos, repositories, articles, reference artifacts), a hierarchical wiki interface with hierarchy-then-LM selection, artifact-level evaluation by vision and audio judges, and controlled online gap-filling, across seven authoring domains.

3

Method

We instantiate R ESOURCE 2S KILL as four stages (Figure 2): construction, wiki organization, selection, and execution. The same construction operator is reused online when the offline pool is insufficient, so online acquisition adds no separate pipeline, and all four stages share a single MCP-mediated browse-select-execute interface over domain-specific backends. 3.1

Hierarchical Multimodal Skill Wiki

A skill is a tuple
s = p, xtext , xvisual , xcode , m , where p is the path of s in a domain-specific taxonomy TD and m is metadata used for filtering, auditing, and provenance. The three content views are complementary: xtext states name, mechanism, applicability, inputs, and expected effects; xvisual provides thumbnails, screenshots, rendered previews, or diagrams; xcode contains executable or adaptable procedure fragments (visual and code fields may be empty for reference-only entries). The taxonomy is domain-specific (e.g., PPT organizes by layout, typography, and motion; Blender by geometry, material, lighting, and composition) but the browse-and-read interface is shared. The full library for domain D is  ΣD = s : s accepted by the construction operator , and we treat its size as an experimental variable. The on-disk realization is given in Appendix L. 4

3.2

Resource-to-Skill Construction

A construction operator distills multimodal resources into wiki entries. The resource pool RD for domain D is drawn from four families: tutorial videos, source repositories, articles, and reference artifacts. A multimodal distiller maps each resource r ∈ RD to candidate skills, s̃1:k = fθ (r, D), each expressed in the wiki schema above. Concretely, fθ retrieves resources against domain-specific queries, extracts modality-specific evidence (key frames, code regions and parameter signatures, prose passages, rendered exemplars), distills it into (p, xtext , xvisual , xcode , m) via a vision-capable LM, and normalizes the result. A domain-specific predicate AD then enforces five checks—completeness, traceable provenance, deduplication, modality consistency, and structural executability of the code field when present: n o ΣD = s = normalize(s̃) : s̃ = fθ (r, D), r ∈ RD , AD (s̃) = 1 . Per-domain library sizes and the executability protocol are summarized in Appendix A. The same operator (fθ , AD ) is reused at test time for online acquisition, so source mix becomes a controlled design variable rather than a hidden implementation detail. 3.3

Selecting and Composing Skills

Given a brief q, the agent must choose a small subset of wiki entries to compose. M ETA B ROWSE uses the wiki’s hierarchical organization in two stages: a lexical scorer narrows the candidate set to a topically relevant region of the taxonomy, then a language model selects a subset to compose. The first-stage score combines the entry’s name, tags, applicability text, and—critically—its taxonomy path p(s),
CK (q) = TopKs∈ΣD BM25 q, name(s) ⊕ tags(s) ⊕ applicability(s) ⊕ p(s) , so the wiki tree directly favours skills sitting in topically relevant subtrees rather than treating the library as a flat list. The language model then reads structured evidence for candidates in CK (q) and selects a subset to compose,
S(q) = πϕ q, {Φ(s) : s ∈ CK (q)} , where Φ(s) contains metadata and whichever text, visual, and code views are exposed by the current configuration. Selection is a subset rather than a ranking: the language model can pick zero skills if no candidate is a good fit. 3.4

Execution and Online Acquisition

The agent and domain adapter share one MCP tool surface. The wiki side exposes a small set of discovery actions (list categories, list skills with metadata cards, read per-modality content) together with a search action wrapping the BM25 shortlist; the domain side exposes a single apply action backed by a per-domain capabilities manifest, with structured not-applicable returns for missing capabilities. A run follows the same control loop in every domain (plan, M ETA B ROWSE, apply, render), and selected skill code, when present, executes directly against the live MCP server with no language-model translation between selection and execution. Reference-only skills remain useful: the agent adapts their text and visual evidence to write its own code, and provenance is retained through the selected skill identifiers. When CK (q) contains no adequate candidate, the same operator (fθ , AD ) is invoked online: targeted queries are issued on the same resource families, returned resources are distilled into temporary candidates, validated by AD , and exposed as a separate online pool for the current task or evaluation split. Offline and online pools are kept separate throughout the experiments, so online acquisition is a controlled gap-filler on capability regions known to be insufficient, rather than uncontrolled context expansion at test time. 5

4

Experiments

We evaluate R ESOURCE 2S KILL across seven authoring domains and four agent backends, comparing it against a no-skill ablation and two off-the-shelf agentic harnesses, and isolating the wiki interface, source mix, entry format, library scale, online acquisition, and selection strategy in controlled ablations. 4.1

Setup

Domains and briefs. We evaluate on seven authoring domains: slide design (PPT), 2D drafting (CAD), web (HTML/CSS/JS), spreadsheet authoring (Excel), 3D scenes (Blender), real-time 3D (UE5), and audio production (Reaper). Per-domain backends and rendering paths are in Appendix A. Each domain has a screened pool of 80 task briefs with no overlap with the resource corpora used to build the library; the brief author is blind to the wiki and the agent. The main comparison and the scaling and online/offline studies use a matched N =80 subset per domain; ablations use matched N =40 subsets. All conditions in a comparison share brief IDs, so within-table deltas are paired by construction. Compared systems. We sweep four agent backends—GPT-5.5, GPT-5.4, GPT-5.4 Mini, and GPT5.4 Nano—against four systems. W S KILLS is the full R ESOURCE 2S KILL pipeline. W / O S KILLS is the same agent solving tasks through free-form code over the domain apply tool, with no skill library. C LAUDE C ODE -H and C ODEX -H are the off-the-shelf Claude Code and Codex agentic harnesses (the -H suffix denotes harness, not human rater); CLI versions, invocation contract, and matched configuration are in Appendix C. All agent and judge calls use temperature 0 and reasoning effort low. Studies and ablations use GPT-5.4 unless stated otherwise. Judge and aggregation. Non-audio artifacts are judged by a GPT-5.4 vision judge; Reaper is judged by an audio-capable GPT-4o-series judge. The judge is blinded to the system label and sees only the brief and the rendered artifact. Each domain has its own five-axis rubric (full protocol, weights, and human–judge agreement in Appendices B and F); rubric scores in 0–10 are reported as percentages, and the overall score is the rubric-weighted mean. A run that fails to produce a scorable artifact—no artifact returned, or an artifact below a per-domain minimum-quality threshold—is treated as a failure and folds in at overall=0. 4.2

Main Comparison: With-Skill vs Without-Skill

The first question is whether the skill library contributes measurable lift. We compare the four systems (W S KILLS, W / O S KILLS, C LAUDE C ODE -H, C ODEX -H) on the matched-brief suite of N =80 tasks per domain, repeated across the four agent backends. The judge, brief set, and decoding seed are held fixed within each model-domain cell, so score differences isolate the effect of the execution interface and skill access. Table 1 reports the overall score as a percentage. Skills dominate across backends. W S KILLS beats W / O S KILLS in all 28 main-aggregate model– domain cells, averaging 56.8% versus 45.0%, a +11.9-point lift. Both off-the-shelf harnesses raise the no-skill agent on their own but remain consistently below W S KILLS: C ODEX -H reaches 50.5% and C LAUDE C ODE -H 50.4% on the same matched briefs, and W S KILLS still beats the stronger of the two in 26 of 28 cells. The two exceptions (GPT-5.5 Web vs. C LAUDE C ODE -H, GPT-5.4 Nano PPT vs. C ODEX -H) are within one point. The dominant lift therefore comes from the curated wiki, not from the execution harness alone. Per-cell deltas of W S KILLS over W / O S KILLS are statistically significant in every cell of the GPT-5.4 and GPT-5.5 backbones (paired Wilcoxon p < 10−3 , with 13 of 14 cells at p < 10−8 ; full per-cell CIs in Appendix G). Lift concentrates where conventions matter. Per-domain gains are largest where authoring conventions are dense and expensive to re-derive from a prompt—Excel, Blender, and Web at the larger backends—and largest of all on UE5 (+30 to +40 pp), where the free-form code agent rarely assembles a minimum-viable scene through the UE5 Python API and frequently returns artifacts below the per-domain minimum-quality threshold. Reaper sees the smallest gains, reflecting a relatively competent no-skill prior over the medium. A blinded human A/B study with five raters per pair on 40 matched pairs across all seven domains (200 paired ratings, Appendix K) corroborates 6

Table 1: Main comparison, overall score (%). Avg. is the unweighted mean over all seven domain columns. Bold marks the best system per column within each backend group. Per-cell bootstrap 95% CIs and paired Wilcoxon p-values for the GPT-5.4 and GPT-5.5 backbones are tabulated in Appendix G. Model

System

Web

Excel

Reaper

PPT

Blender

CAD

UE5

Avg.

GPT-5.5

W S KILLS W / O S KILLS C LAUDE C ODE -H C ODEX -H

82.8 69.4 83.5 81.6

61.3 58.2 59.8 60.5

77.6 73.1 76.2 76.9

67.5 53.9 63.4 64.1

53.1 35.6 45.7 44.9

48.7 42.6 47.1 47.0

69.5 30.2 35.9 36.0

65.8 51.9 58.8 58.7

GPT-5.4

W S KILLS W / O S KILLS C LAUDE C ODE -H C ODEX -H

82.4 68.7 81.6 79.8

76.4 58.6 69.2 70.4

77.3 73.2 75.8 76.1

64.8 55.4 61.6 62.3

44.1 29.5 36.7 35.9

55.7 48.7 53.3 53.0

67.3 29.1 35.7 36.3

66.9 51.9 59.1 59.1

GPT-5.4 Mini

W S KILLS W / O S KILLS C LAUDE C ODE -H C ODEX -H

67.6 55.2 66.8 65.4

45.7 42.4 44.8 45.2

62.6 58.3 61.4 61.8

52.4 45.9 49.3 50.8

28.8 18.7 24.6 23.9

50.3 45.6 48.9 49.7

55.9 23.7 26.6 26.9

51.9 41.4 46.1 46.2

GPT-5.4 Nano

W S KILLS W / O S KILLS C LAUDE C ODE -H C ODEX -H

49.5 42.3 48.2 47.6

34.6 31.8 33.4 34.1

50.5 48.7 49.8 50.3

41.3 38.6 40.2 42.1

15.8 12.2 14.5 13.9

51.4 45.1 49.7 50.3

56.3 24.5 26.2 26.9

42.8 34.7 37.4 37.9

70 60 50

w/o Skills

Web 82.4 Reaper 77.3 Excel 76.4

90

PPT 64.8

75

Overall Score (%)

Overall score (%)

80

Blender 44.1

40 30 0 (w/o)

20

50

100

200

300

400

Full (Ours)

Excel

Reaper

PPT

68.7

76.4 68.2

Flat (Pure Text)

77.3 73.274.8 64.8 61.2 55.4

58.6

60

Our Wiki

44.1 38.4

45

29.5

30 15

Number of skills Web

82.4 76.5

Blender

0

a, Skill-pool scaling. The final tick, F ULL, is the complete skill pool used by R ESOURCE 2S KILL; the table lists plotted percentages.

Web

Excel

Reaper

PPT

Blender

b, Wiki organization. The full wiki interface is compared with no skills and flat pure-text skill access; the table lists plotted percentages.

the preference direction across all seven domains, with W S KILLS winning 83.3% of non-tied pairs against W / O S KILLS. Per-axis traces of the lift are in Table 7 (Appendix H). 4.3 4.3.1

Studies Skill-Library Scaling

This study asks how performance moves as we vary the size of the skill pool. Holding the agent, judge, brief set, and wiki interface fixed, we expose progressively larger category-balanced pools from 0 skills to the complete library and evaluate on the matched N =80 brief suite in each domain. The 0-skill condition is the same free-form baseline as the main comparison; the final tick in panel a denotes the full pool used by the main system. Result. Performance rises monotonically with library size in every domain and saturates near 200 skills. The first 0 → 200 slice carries the largest gains (between +3.1 pp on Reaper and +14.2 pp on Excel); the curve flattens after 200 and the 400 →F ULL step adds at most +0.8 pp per domain. Early entries cover common operations and recovery routines; later entries fill domain-specific gaps. 4.3.2

Offline and Online Acquisition

We compare O FFLINE - ONLY, which retrieves from a fixed pool of 891 distilled skills, against O FFLINE +O NLINE, which adds up to 100 skills distilled online when the offline pool is inadequate. 7

Table 2: Offline and online skill acquisition, overall score (%). Tstandard is the regular benchmark; Tnovel targets capabilities missing from the offline pool. Bold marks the better configuration within each task set. Offline Pool

Online Pool

Task Set

Mean Overall (%)

∆ vs. Base (pp)

O FFLINE - ONLY O FFLINE +O NLINE

891 891

0 100

Tstandard Tstandard

65.4 66.1

– +0.7

O FFLINE - ONLY O FFLINE +O NLINE

891 891

0 100

Tnovel Tnovel

41.2 62.8

– +21.6

Configuration

Table 3: Ablation: resource-source mix, overall score (%). A checkmark indicates the source family is included. The top row holds V IDEO out; the bottom row is the full R ESOURCE 2S KILL source pool. Each cell averages N =40 matched briefs. Bold marks the best configuration per domain. Video

Code

Article

Artifact

Web

Excel

Reaper

PPT

Blender

Avg.

✓

✓

✓

71.3 81.1 82.0 81.9 81.6 82.8

61.6 73.7 75.2 74.4 74.8 75.8

74.2 75.6 76.3 77.8 76.4 78.1

57.4 62.4 62.9 63.7 63.5 64.2

32.7 41.3 41.6 42.9 42.4 43.8

59.4 66.8 67.6 68.1 67.7 68.9

✓ ✓ ✓ ✓ ✓

✓ ✓ ✓

✓

✓ ✓

We evaluate on two task sets: Tstandard is the regular matched benchmark; Tnovel is a stress-test suite targeting capabilities the offline pool failed to cover during preliminary screening. Online candidates are not folded back into the offline pool. Result. The two task sets reveal a sharp asymmetry. On Tstandard , online acquisition adds +0.7 pp—essentially noise, since the offline pool already covers most common requests. On Tnovel , the same 100 online skills lift the mean score from 41.2% to 62.8% (+21.6 pp). Online search is a gap-filler, not a booster; we therefore default to O FFLINE - ONLY for the standard benchmark. 4.4 4.4.1

Ablations Skill + Wiki vs Skill Only

Setup. We compare three GPT-5.4 conditions on the matched N =40 subset per domain. W / O S KILLS disables the library; F LAT exposes pure text skill descriptions as an unstructured list, removing category browsing, metadata, visual previews, and executable code; O UR W IKI is the full skill-enabled wiki interface used by R ESOURCE 2S KILL. Panel b reports the three arms. Result. The flat text library already lifts every domain over disabling skills, confirming that reusable skill descriptions help on their own. O UR W IKI is best in every domain and beats F LAT by 2.5 to 8.2 pp, with the largest gains where category structure and code grounding matter most (Excel, Web, Blender). Hierarchical browsing narrows the search space; code and visual fields supply execution grounding that pure text under-specifies. 4.4.2

Wiki Construction

Source ablation. The top row of Table 3 holds V IDEO out (C ODE +A RTICLE +A RTIFACT only) to test whether the other source families can recover video’s contribution; the next four rows seed with video and add zero or one supplemental source family; the bottom row combines all four. This design measures both video’s irreplaceability and the marginal utility of each supplemental source. Source result. Video is the non-substitutable source. Holding it out drops the average from 68.9% to 59.4%, and the video-only library still outscores the three-source no-video library by 7.4 points. The video-removal drop concentrates where temporal operations and visual sequencing carry signal that text under-specifies (Excel −12.1 pp, Web −9.8). Beyond video, no supplemental family 8

Table 4: Matched-budget representation ablation, overall score (%). All rows use the same resource pool, the same accepted skill IDs, the same wiki frontmatter and metadata, the same BM25then-LM retrieval budget, and the same agent. A checkmark indicates the modality exposed to the agent post-retrieval; F ULL is the full wiki entry. Each cell averages N =40 matched briefs. Text

Visual

✓ ✓ ✓ ✓

Code

Web

Excel

Reaper

PPT

Blender

Avg.

✓ ✓

80.3 81.6 80.9 82.8

72.7 74.1 75.2 75.8

73.6 74.8 75.9 78.1

60.5 63.4 61.8 64.2

37.8 40.7 41.4 43.8

65.0 66.9 67.0 68.9

✓ ✓

Table 5: Ablation: selection strategy, overall score (%). Each cell averages N =40 matched briefs under the same agent, judge, library, and candidate budget. Bold marks the best strategy per domain. Method

Excel

Web

PPT

Blender

Reaper

Avg.

O URS

75.8

82.8

64.2

43.8

78.1

68.9

BM25 E MBED BM25+E MBED R ANDOM -F ULL P OOL N O -S KILL

70.8 63.5 69.1 59.5 58.9

80.5 75.2 81.6 70.2 69.1

60.4 48.1 57.5 56.1 55.6

41.5 37.8 36.2 30.5 29.6

76.8 75.2 76.6 73.8 73.5

66.0 60.0 64.2 58.0 57.3

dominates, but the all-source pool stays 0.3 to 0.9 pp ahead of the strongest two-source variant in every domain; diversity adds coverage insurance on top of video. Matched-budget representation ablation. This ablation isolates multimodal skill content from curated text memory. All conditions share the resource pool, accepted skill IDs, wiki frontmatter/metadata, BM25-then-LM budget, GPT-5.4 agent, and judge; only the post-retrieval content (text, visual thumbnail, executable code) changes. Thus T EXT is a strong curated text-memory baseline with matched metadata and retrieval. Result. T EXT reaches 65.0% because it already inherits applicability and routing cues. Visuals add +1.9 pp, code adds +2.0 pp, and F ULL ranks first in every domain at 68.9%, attributing the remaining gain to multimodal skill content rather than curated memory alone. 4.4.3

Selection Strategy

Setup. On the same matched N =40 subset we compare six selection strategies under a fixed library, agent, judge, and candidate budget. O URS is the hierarchy-then-LM M ETA B ROWSE selector. BM25 and E MBED are retrieval-only baselines (lexical and dense, the latter a standard dense-retrieval RAG over the skill library); BM25+E MBED combines them via dense reranking on a lexical shortlist. R ANDOM -F ULL P OOL samples uniformly from the skill pool; N O -S KILL disables skills as a floor reference. Result. The hierarchy-then-LM M ETA B ROWSE policy wins in every domain, averaging 68.9% against 66.0% for BM25, 64.2% for BM25+E MBED, 60.0% for E MBED, 58.0% for R ANDOM F ULL P OOL, and 57.3% for N O -S KILL. Its largest margins over the strongest retrieval-only baseline are on Excel (+5.0 pp), PPT (+3.8), and Blender (+2.3), where task fit and complementarity are not captured by lexical or vector similarity alone.

5

Conclusion

R ESOURCE 2S KILL distills multimodal human references into a structured, executable Skill Wiki shared by offline construction and controlled online gap filling. Across seven authoring domains and four backends, skill access improves artifact quality by +11.9 points over no-skill agents and beats two agentic-harness baselines in 26 of 28 main-aggregate cells. Our results show that distilling skills 9

from human-created resources gives software agents reusable procedural knowledge that improves over both no-skill agents and strong agentic harnesses across diverse authoring domains.

References Michael Ahn, Anthony Brohan, Noah Brown, Yevgen Chebotar, Omar Cortes, Byron David, Chelsea Finn, Chuyuan Fu, Keerthana Gopalakrishnan, Karol Hausman, Alexander Herzog, Daniel Ho, Jasmine Hsu, Brian Ichter, Alex Irpan, Eric Jang, Rosario Jauregui Ruano, Kyle Jeffrey, Sally Jesmonth, Nikhil Joshi, Ryan Julian, Dmitry Kalashnikov, Yuheng Kuang, Isabel Lee, Sergey Levine, Yao Lu, Linda Luu, Carolina Parada, Peter Pastor, Jodilyn Quiambao, Kanishka Rao, Jarek Rettinghouse, Diego Reyes, Pierre Sermanet, Nicolas Sievers, Clayton Tan, Alexander Toshev, Vincent Vanhoucke, Fei Xia, Ted Xiao, Peng Xu, Sichun Xu, Mengyuan Yan, and Andy Zeng. Do as i can, not as i say: Grounding language in robotic affordances. In Conference on Robot Learning, 2022. Anthropic. Agent skills: A filesystem specification for procedural knowledge in claude agents. https: //platform.claude.com/docs/en/agents-and-tools/agent-skills/overview, 2025. Accessed 2026. Sebastian Borgeaud, Arthur Mensch, Jordan Hoffmann, Trevor Cai, Eliza Rutherford, Katie Millican, George Bm Van Den Driessche, Jean-Baptiste Lespiau, Bogdan Damoc, Aidan Clark, et al. Improving language models by retrieving from trillions of tokens. In International Conference on Machine Learning, 2022. Mark Chen, Jerry Tworek, Heewoo Jun, Qiming Yuan, Henrique Ponde de Oliveira Pinto, Jared Kaplan, Harri Edwards, Yuri Burda, Nicholas Joseph, Greg Brockman, Alex Ray, Raul Puri, Gretchen Krueger, Michael Petrov, Heidy Khlaaf, Girish Sastry, Pamela Mishkin, Brooke Chan, Scott Gray, Nick Ryder, Mikhail Pavlov, Alethea Power, Lukasz Kaiser, Mohammad Bavarian, Clemens Winter, Philippe Tillet, Felipe Petroski Such, Dave Cummings, Matthias Plappert, Fotios Chantzis, Elizabeth Barnes, Ariel Herbert-Voss, William Hebgen Guss, Alex Nichol, Alex Paino, Nikolas Tezak, Jie Tang, Igor Babuschkin, Suchir Balaji, Shantanu Jain, William Saunders, Christopher Hesse, Andrew N. Carr, Jan Leike, Joshua Achiam, Vedant Misra, Evan Morikawa, Alec Radford, Matthew Knight, Miles Brundage, Mira Murati, Katie Mayer, Peter Welinder, Bob McGrew, Dario Amodei, Sam McCandlish, Ilya Sutskever, and Wojciech Zaremba. Evaluating large language models trained on code. arXiv preprint arXiv:2107.03374, 2021. Xiang Deng, Yu Gu, Boyuan Zheng, Shijie Chen, Sam Stevens, Boshi Wang, Huan Sun, and Yu Su. Mind2Web: Towards a generalist agent for the web. In Advances in Neural Information Processing Systems, volume 36, 2023. Linxi Fan, Guanzhi Wang, Yunfan Jiang, Ajay Mandlekar, Yuncong Yang, Haoyi Zhu, Andrew Tang, De-An Huang, Yuke Zhu, and Anima Anandkumar. MineDojo: Building open-ended embodied agents with internet-scale knowledge. In Advances in Neural Information Processing Systems, volume 35, pages 18343–18362, 2022. Luyu Gao, Aman Madaan, Shuyan Zhou, Uri Alon, Pengfei Liu, Yiming Yang, Jamie Callan, and Graham Neubig. PAL: Program-aided language models. In International Conference on Machine Learning, 2023. Kristen Grauman, Andrew Westbury, Eugene Byrne, Zachary Chavis, Antonino Furnari, Rohit Girdhar, Jackson Hamburger, Hao Jiang, Miao Liu, Xingyu Liu, Miguel Martin, Tushar Nagarajan, Ilija Radosavovic, Santhosh Kumar Ramakrishnan, Fiona Ryan, Jayant Sharma, Michael Wray, Mengmeng Xu, Eric Zhongcong Xu, Chen Zhao, et al. Ego4D: Around the world in 3,000 hours of egocentric video. In Proceedings of the IEEE/CVF Conference on Computer Vision and Pattern Recognition, pages 18995–19012, 2022. Kelvin Guu, Kenton Lee, Zora Tung, Panupong Pasupat, and Ming-Wei Chang. REALM: Retrievalaugmented language model pre-training. In International Conference on Machine Learning, pages 3929–3938. PMLR, 2020. Hamel Husain, Ho-Hsiang Wu, Tiferet Gazit, Miltiadis Allamanis, and Marc Brockschmidt. CodeSearchNet challenge: Evaluating the state of semantic code search. arXiv preprint arXiv:1909.09436, 2019. 10

Carlos E. Jimenez, John Yang, Alexander Wettig, Shunyu Yao, Kexin Pei, Ofir Press, and Karthik Narasimhan. SWE-bench: Can language models resolve real-world GitHub issues? In International Conference on Learning Representations (ICLR), 2024. Eyal Karpas, Omri Abend, Yonatan Belinkov, Barak Lenz, Opher Lieber, Nir Ratner, Yoav Shoham, Heureux Bata, Yoav Levine, Kevin Leyton-Brown, Dor Muhlgay, Paul Roit, David Schwartz, Gal Shachaf, Shai Shalev-Shwartz, Amnon Shashua, and Moshe Tenenholtz. MRKL systems: A modular, neuro-symbolic architecture that combines large language models, external knowledge sources and discrete reasoning. arXiv preprint arXiv:2205.00445, 2022. Vladimir Karpukhin, Barlas Oguz, Sewon Min, Patrick Lewis, Ledell Wu, Sergey Edunov, Danqi Chen, and Wen-tau Yih. Dense passage retrieval for open-domain question answering. In Proceedings of the 2020 Conference on Empirical Methods in Natural Language Processing, pages 6769–6781, 2020. Patrick Lewis, Ethan Perez, Aleksandra Piktus, Fabio Petroni, Vladimir Karpukhin, Naman Goyal, Heinrich Kuettler, Mike Lewis, Wen-tau Yih, Tim Rocktaschel, Sebastian Riedel, and Douwe Kiela. Retrieval-augmented generation for knowledge-intensive NLP tasks. In Advances in Neural Information Processing Systems, volume 33, pages 9459–9474, 2020. Jacky Liang, Wenlong Huang, Fei Xia, Peng Xu, Karol Hausman, Brian Ichter, Pete Florence, and Andy Zeng. Code as policies: Language model programs for embodied control. In IEEE International Conference on Robotics and Automation, pages 9493–9500, 2023. Xiao Liu, Hao Yu, Hanchen Zhang, Yifan Xu, Xuanyu Lei, Hanyu Lai, Yu Gu, Hangliang Ding, Kaiwen Men, Kejuan Yang, Shudan Zhang, Xiang Deng, Aohan Zeng, Zhengxiao Du, Chenhui Zhang, Sheng Shen, Tianhua Zhang, Yu Su, Huan Sun, Minlie Huang, Yuxiao Dong, and Jie Tang. AgentBench: Evaluating LLMs as agents. arXiv preprint arXiv:2308.03688, 2023. Junyu Luo, Weizhi Zhang, Ye Yuan, Yusheng Zhao, Junwei Yang, Yiyang Gu, Bohan Wu, Binqi Chen, Ziyue Qiao, Qingqing Long, Rongcheng Tu, Xiao Luo, Wei Ju, Zhiping Xiao, Yifan Wang, Meng Xiao, Chenwu Liu, Jingyang Yuan, Shichang Zhang, Yiqiao Jin, Fan Zhang, Xian Wu, Hanqing Zhao, Dacheng Tao, Philip S. Yu, and Ming Zhang. Large language model agent: A survey on methodology, applications and challenges, 2025. URL https://arxiv.org/abs/2503.21460. Aman Madaan, Niket Tandon, Prakhar Gupta, Skyler Hallinan, Luyu Gao, Sarah Wiegreffe, Uri Alon, Nouha Dziri, Shrimai Prabhumoye, Yiming Yang, Sean Welleck, Bodhisattwa Prasad Majumder, Shashank Gupta, Amir Yazdanbakhsh, and Peter Clark. Self-refine: Iterative refinement with self-feedback. In Advances in Neural Information Processing Systems, volume 36, 2023. Antoine Miech, Dimitri Zhukov, Jean-Baptiste Alayrac, Makarand Tapaswi, Ivan Laptev, and Josef Sivic. HowTo100M: Learning a text-video embedding by watching hundred million narrated video clips. In Proceedings of the IEEE/CVF International Conference on Computer Vision, pages 2630–2640, 2019. Reiichiro Nakano, Jacob Hilton, Suchir Balaji, Jeff Wu, Long Ouyang, Christina Kim, Christopher Hesse, Shantanu Jain, Vineet Kosaraju, William Saunders, Xu Jiang, Karl Cobbe, Tyna Eloundou, Gretchen Krueger, Kevin Button, Matthew Knight, Benjamin Chess, and John Schulman. WebGPT: Browser-assisted question-answering with human feedback. arXiv preprint arXiv:2112.09332, 2021. Charles Packer, Vivian Fang, Shishir G. Patil, Kevin Lin, Sarah Wooders, and Joseph E. Gonzalez. MemGPT: Towards LLMs as operating systems. arXiv preprint arXiv:2310.08560, 2023. Joon Sung Park, Joseph C. O’Brien, Carrie J. Cai, Meredith Ringel Morris, Percy Liang, and Michael S. Bernstein. Generative agents: Interactive simulacra of human behavior. In Proceedings of the 36th Annual ACM Symposium on User Interface Software and Technology, 2023. Shishir G. Patil, Tianjun Zhang, Xin Wang, and Joseph E. Gonzalez. Gorilla: Large language model connected with massive APIs. arXiv preprint arXiv:2305.15334, 2023. Yujia Qin, Shihao Liang, Yining Ye, Kunlun Zhu, Lan Yan, Yaxi Lu, Yankai Lin, Xin Cong, Xiangru Tang, Bill Qian, et al. ToolLLM: Facilitating large language models to master 16000+ real-world apis. In International Conference on Learning Representations (ICLR), 2024. 11

Stephen Robertson and Hugo Zaragoza. The probabilistic relevance framework: BM25 and beyond. Foundations and Trends in Information Retrieval, 3(4):333–389, 2009. Timo Schick, Jane Dwivedi-Yu, Roberto Dessì, Roberta Raileanu, Maria Lomeli, Luke Zettlemoyer, Nicola Cancedda, and Thomas Scialom. Toolformer: Language models can teach themselves to use tools. In Advances in Neural Information Processing Systems (NeurIPS), 2023. Shuaike Shen, Wenduo Cheng, Mingqian Ma, Alistair Turcan, Martin Jinye Zhang, and Jian Ma. SkillFoundry: Building self-evolving agent skill libraries from heterogeneous scientific resources. arXiv preprint arXiv:2604.03964, 2026. Yongliang Shen, Kaitao Song, Xu Tan, Dongsheng Li, Weiming Lu, and Yueting Zhuang. HuggingGPT: Solving AI tasks with ChatGPT and its friends in Hugging Face. In Advances in Neural Information Processing Systems, volume 36, 2023. Noah Shinn, Federico Cassano, Edward Berman, Ashwin Gopinath, Karthik Narasimhan, and Shunyu Yao. Reflexion: Language agents with verbal reinforcement learning. In Advances in Neural Information Processing Systems (NeurIPS), 2023. Yansong Tang, Dajun Ding, Yongming Rao, Yu Zheng, Danyang Zhang, Lili Zhao, Jiwen Lu, and Jie Zhou. COIN: A large-scale dataset for comprehensive instructional video analysis. In Proceedings of the IEEE/CVF Conference on Computer Vision and Pattern Recognition, pages 1207–1216, 2019. Guanzhi Wang, Yuqi Xie, Yunfan Jiang, Ajay Mandlekar, Chaowei Xiao, Yuke Zhu, Linxi Fan, and Anima Anandkumar. Voyager: An open-ended embodied agent with large language models. Transactions on Machine Learning Research (TMLR), 2024a. Zora Zhiruo Wang, Jiayuan Mao, Daniel Fried, and Graham Neubig. Agent workflow memory. arXiv preprint arXiv:2409.07429, 2024b. Zora Zhiruo Wang, Apurva Gandhi, Graham Neubig, and Daniel Fried. Inducing programmatic skills for agentic tasks. arXiv preprint arXiv:2504.06821, 2025. Renjun Xu and Yang Yan. Agent skills for large language models: Architecture, acquisition, security, and the path forward, 2026. URL https://arxiv.org/abs/2602.12430. John Yang, Carlos E. Jimenez, Alexander Wettig, Kilian Lieret, Shunyu Yao, Karthik Narasimhan, and Ofir Press. SWE-agent: Agent–computer interfaces enable automated software engineering. In Advances in Neural Information Processing Systems (NeurIPS), 2024. Shunyu Yao, Howard Chen, John Yang, and Karthik Narasimhan. WebShop: Towards scalable real-world web interaction with grounded language agents. In Advances in Neural Information Processing Systems, volume 35, 2022. Shunyu Yao, Jeffrey Zhao, Dian Yu, Nan Du, Izhak Shafran, Karthik Narasimhan, and Yuan Cao. ReAct: Synergizing reasoning and acting in language models. In International Conference on Learning Representations (ICLR), 2023. Ziao Zhang, Kou Shi, Shiting Huang, Avery Nie, Yu Zeng, Yiming Zhao, Zhen Fang, Qisheng Su, et al. SkillFlow: Benchmarking lifelong skill discovery and evolution for autonomous agents. arXiv preprint arXiv:2604.17308, 2026. Shuyan Zhou, Frank F. Xu, Hao Zhu, Xuhui Zhou, Robert Lo, Abishek Sridhar, Xianyi Cheng, Tianyue Ou, Yonatan Bisk, Daniel Fried, Uri Alon, and Graham Neubig. WebArena: A realistic web environment for building autonomous agents. In International Conference on Learning Representations, 2024. Dimitri Zhukov, Jean-Baptiste Alayrac, Antoine Miech, Ivan Laptev, and Josef Sivic. Cross-task weakly supervised learning from instructional videos. In Proceedings of the IEEE/CVF Conference on Computer Vision and Pattern Recognition, pages 3537–3545, 2019.

12

A

Per-Domain Details

We summarize the implemented domain backends. Main results in Section 4 cover Web, Excel, PPT, Blender, Reaper, CAD, and UE5; ablations report the five-domain core (Web, Excel, Reaper, PPT, Blender), with CAD and UE5 included in the main comparison and held out from per-condition ablations to keep the within-table compute budget bounded. Slide design (PPT). Slides are generated as SVG and then rendered to native PowerPoint (.pptx) shapes, on a fixed 16:9 canvas. Categories: layout, typography, palette, chart, icon, photo, shell, and motion. Active wiki size at evaluation start: 996. Render path: deck playback is rendered to video/frame artifacts for scoring; static-only runs use the same rendered slide frames as a contact sheet. Spreadsheet authoring (Excel). openpyxl with optional xlsxwriter for formatting. Categories: data ingest, formula pattern, conditional format, chart, dashboard layout, named range. Active wiki size: 632. Render path: LibreOffice export to per-sheet pages, composited into a worksheet contact sheet. Web (HTML/CSS/JS). Vanilla HTML5 + CSS3 + ES2020. Categories: layout, animation, typography, interaction, component, theme. Active wiki size: 941. Render path: Playwright full-page screenshot at a 1280-pixel viewport. 3D scenes (Blender). bpy (Blender 4.1) headless. Categories: geometry, material, lighting, camera, animation, environment. Active wiki size: 661. Render path: the saved scene or final PNG is rendered to a single hero-shot frame. Audio production (Reaper). REAPER ReaScript over MCP. Categories: instrument, effect chain, automation, mix, arrangement. Active wiki size: 934. Render path: WAV bounce, transcoded to a bounded MP3 preview for the audio judge; spectrograms are retained only as diagnostics. 2D drafting (CAD). ezdxf with FreeCAD as a fallback renderer. Categories: primitive, constraint, dimensioning, hatching, layer, layout. Library size: 312. Render path: FreeCAD viewport screenshot from two orthographic angles, composited. Real-time 3D (UE5). Unreal Engine 5 driven through a UE5-MCP bridge that exposes editor-side Python actions (actor spawn, transform, material assignment, level lighting, sequencer keyframe, asset import) as MCP tool calls. Categories: actor placement, lighting, materials and PBR, level blueprint, sequencer/cinematic, environment, post-process. Library size: 417. Render path: editor viewport HighResShot of the saved level from a fixed camera, composited with a Lit-mode pass for scoring. Skill-entry size and inference-time context budget. Each skill entry on disk bundles agent-facing frontmatter (skill_name, category_path, applicability, tags, modalities_present), a structured prose body (text/overview.md: mechanism, use conditions, inputs, expected effects), and the executable code body (code/skill.py or domain-equivalent). Visual thumbnails are referenced by path and resolved to images only when the agent explicitly requests the visual modality, so they do not enter the text-token budget. Token estimates use a conservative four-characters-pertoken rule on the concatenation of frontmatter, prose, and code, computed across every entry in the offline wiki snapshot used for the main comparison. Per-domain mean / median tokens per entry are PPT 3,934 / 4,108, Excel 3,207 / 2,612, Web 5,726 / 5,479, Blender 4,248 / 3,937, and Reaper 4,170 / 3,925; aggregated across these domains the mean is 4,332 tokens (median 4,133, 25th percentile 3,367, 75th percentile 5,049). At inference time M ETA B ROWSE forms a BM25 shortlist of K=20 candidates over the wiki taxonomy and exposes their compact frontmatter (typically 200–500 tokens each) to the language-model selector, which picks n=5 entries to expose to the agent in full. The skill-related context per task is therefore ∼ 4–10k tokens for the selection step and ∼ 22k tokens for the five fully expanded entries; total ∼ 26–32k tokens, well within the working window of every agent backend used in the main comparison and independent of the total library size since both K and n are fixed before the run. 13

B

Benchmark Construction and Evaluation Protocol

Benchmark construction. Each benchmark item is a task brief, not a demonstration. A brief specifies the domain, a stable brief_id, a slug, the natural-language request, and the required output path and artifact type. It does not name skills, source URLs, or solution steps. We generate candidate briefs from domain-specific prompt templates with fixed seeds, then screen them manually for clarity, feasibility under the domain backend, and absence of overlap with the resource corpora used to build the skill wiki. For each domain, we retain a pool of 80 screened briefs. The main comparison, scaling study, and online/offline study use a fixed matched N =80 subset. Ablations use separate fixed N =40 subsets sampled from the same 80-brief pool because evaluating every ablation on all 80 tasks would exceed the available run budget; all conditions within a given ablation share the same sampled brief IDs. The online/offline study additionally constructs Tnovel from capability regions that the offline pool fails to cover during preliminary screening, so it is a stress test for gap filling rather than a standard-distribution benchmark. Run orchestration. A run is one cell in the Cartesian product of domain, brief, and condition. All cells use the same agent loop and the same domain MCP server; conditions change only the skill access policy, wiki root, pool whitelist, source set, entry format, or harness baseline specified by the experiment. Unless a model ablation explicitly changes the backend, the agent uses GPT-5.4 with reasoning effort low. Each run follows the same four-stage loop: plan the task, browse or retrieve candidate skills when the condition permits it, execute through the domain apply tools, and verify by rendering the artifact. The experiment directories are self-contained: experiments/<name>/briefs.json stores briefs, runs/<domain>/<slug>_<condition>/ stores artifacts, logs/ stores the agent trace, and scores/ stores the judge JSON. Scaling pools and offline/online splits are fixed before launch and written to disk, so reruns reuse the same skill IDs rather than resampling the library. Rendering. Scoring always observes rendered artifacts rather than source files. Web outputs are rendered with Playwright full-page screenshots. Excel workbooks are exported through LibreOffice to per-sheet pages and stitched into a contact sheet. Blender outputs are scored from the final rendered PNG or a headless hero-shot render of the saved scene. PPT decks are rendered as presentation playback artifacts: when motion or transitions are part of the brief, we record video/frame evidence from the rendered slideshow; for static-only cells, the same pipeline reduces to rendered slide frames arranged as a contact sheet. Reaper projects are bounced to WAV, transcoded to a bounded mono MP3 preview, and sent as audio to the judge. CAD and UE5 follow the same artifact-first rule. Scoring. Non-audio artifacts are judged by GPT-5.4 with reasoning effort low. Reaper is judged by an audio-capable GPT-4o-series model on the bounced audio. Judges are blinded to the condition label and receive only the task brief, the rendered artifact, and the domain rubric. Each domain has five paper-facing axes: PPT uses layout quality, content density, theme coherence, typography hierarchy, and overall polish; Excel uses structure clarity, data density, chart quality, theme consistency, and overall polish; Web uses visual design, hierarchy clarity, section richness, modernness, and overall polish; Blender uses lighting, composition, materials realism, scene complexity, and overall aesthetic; Reaper uses low-end balance, transient clarity, spectrum balance, arrangement dynamics, and overall mix. The score file records an integer 0–10 raw score and a one-sentence justification for each axis; all paper tables and figures report these scores after multiplying by 10. The overall metric is the configured weighted mean of the five axes. Missing, unopenable, too-small, or silent artifacts receive overall=0 and are counted as failures; failures are kept in the denominator when computing condition means. Aggregation and reproducibility. For matched comparisons, we aggregate over the same brief IDs within each domain and condition. Reported deltas are therefore paired by construction. Every score JSON stores the artifact path, render path, rubric breakdown, overall score, and judge metadata, which allows later re-aggregation without re-running the agent. Brief generation is wiki-blind. Benchmark briefs are generated by a separate language-model call whose prompt receives only (i) the domain name, (ii) a hand-curated per-domain guidance string that enumerates types of artifacts in the wild, and (iii) a fixed structural template that specifies output format and the required output path. The brief generator does not receive any skill identifier, wiki listing, library size, taxonomy tree, per-skill metadata, or aggregated benchmark statistic from prior 14

runs. The per-domain guidance strings were authored once before the main benchmark and were not updated in response to subsequent benchmark scores. Resource collection queries are taxonomy-driven, not brief-driven. The construction operator’s resource queries are derived from per-domain category lists in the taxonomy that was hand-designed before benchmark briefs were generated. The query templates do not consume benchmark brief text, brief slugs, or any benchmark-side identifier; resource ingestion is a function of the taxonomy alone. Acceptance thresholds are frozen before benchmark scoring. The acceptance predicate AD ’s thresholds (minimum schema fields, deduplication hash policy, executability gate, per-domain minimum-size constants) were tuned on a small dev-side resource sample drawn before mainbenchmark briefs were generated and were frozen before the main comparison. Thresholds are not re-tuned in response to benchmark failure rates or per-cell scores. No feedback loop from benchmark to library. Per-cell failure rates, judge scores, and qualitative error analyses computed from benchmark runs are stored in scores/ alongside the run artifacts; they are not piped back into the brief generator, the resource collector, the taxonomy, or the acceptance predicate. The library snapshot used for the main comparison is the same snapshot used for the scaling and online/offline studies, and was frozen before any benchmark cell was scored.

C

Harness Baseline Configurations

This appendix documents the CLI versions and invocation contract under which C LAUDE C ODE -H and C ODEX -H were run. Both harnesses are off-the-shelf agentic CLIs; we treat them as baselines rather than as custom-built systems, and intentionally retain their default planning and tool-use loops so that the comparison reflects the product a practitioner would actually deploy rather than a stripped variant. Common protocol. Both harnesses see the same brief, the same per-domain backend (SVGrendered .pptx, openpyxl, Playwright, bpy/Blender, REAPER ReaScript, ezdxf/FreeCAD, UE5 Python), and the same output-path contract as W S KILLS and W / O S KILLS. Neither has access to the Skill Wiki or to any R ESOURCE 2S KILL-specific prompt. Within each model–domain cell of Table 1, brief IDs (N =80 matched per domain), agent backend, judge model and decoding settings (temperature 0, judge reasoning effort low), output-path contract, and the per-domain failure-handling rule (overall=0 on missing or unscorable artifact) are held fixed across all four systems, so within-cell deltas isolate the execution interface. Both harnesses run inside a per-brief working directory and produce artifacts there; live web browsing is not used as a path to ground-truth answers in either harness. ClaudeCode-H. Anthropic Claude Code CLI, version 2.1.x. The CLI is invoked in non-interactive print mode with the brief on standard input and the per-brief working directory added to the toolaccess scope. The underlying agent backend (GPT-5.5 / GPT-5.4 / GPT-5.4 Mini / GPT-5.4 Nano) is selected per row of the main comparison via the CLI’s model-selection flag and routed through the same model deployments used for W S KILLS and W / O S KILLS. We use the harness-default tool surface (file read/write/edit, shell, grep/glob, web fetch) and explicitly do not load a project-level instructions file or any skill files, so the agent has no R ESOURCE 2S KILL-specific priors. Permission prompts are bypassed so that runs are hands-off; reasoning effort is set to low, matching W S KILLS and W / O S KILLS. Codex-H. OpenAI Codex CLI, version 0.129.x. The CLI is invoked in non-interactive exec mode under a per-backend profile that pins the underlying model. Across all profiles we set the approval policy to never (no human-in-the-loop), the sandbox to workspace-write (the agent may write within the per-brief workspace), reasoning effort to low (matching W S KILLS and W / O S KILLS), and web search to cached (browsing is restricted to the cached snapshot rather than live retrieval). The model providers point at the same model deployments used for W S KILLS and W / O S KILLS, so judges, decoding seeds, and model identifiers are matched. As with C LAUDE C ODE -H, no skill library is mounted and no R ESOURCE 2S KILL-specific prompt is injected. 15

Reproducibility. The supplementary material includes the per-brief invocation contract for each harness, the per-condition run directories with raw stdout/stderr, agent traces, and produced artifacts, and the per-condition score JSONs that allow regeneration of every cell of Table 1 without re-invoking the agent or the judge.

D

Construction Operator and Acceptance Predicate

This section disaggregates the construction operator fθ into its prompt-based and deterministic components, and lists what the acceptance predicate AD actually checks. fθ : prompt-based distillation with deterministic post-processing. The construction operator is implemented as a vision-capable language-model call, not as a fine-tuned model, with no learned parameters specific to R ESOURCE 2S KILL. Per resource r, the operator (i) issues a per-domain query template against the resource connector to retrieve the resource bytes (video frames, repository tree, article text, or reference artifact), (ii) extracts modality-specific evidence using deterministic preprocessors (key-frame sampling for video, AST-aware code region extraction for repositories, paragraph segmentation for articles, image preprocessing for artifacts), and (iii) calls the language model with a perdomain prompt template that elicits a structured JSON skill payload (skill_name, category_path, applicability, tags, text_body, code_body, visual_caption, provenance). A deterministic post-processor normalizes whitespace, validates JSON shape, computes a stable skill identifier from a SHA1 hash of (domain, source_path), and writes the entry to disk. The language-model role is therefore prompt-engineering plus structured output, not learned scoring. AD : five deterministic gates. The acceptance predicate is composed of five deterministic checks, each of which can independently reject a candidate skill. None is implemented as an LM-as-judge call. • Completeness. A schema validator requires (a) all required frontmatter fields populated, (b) a non-empty text_body of at least a minimum prose length, and (c) at least one populated content modality. Rejected candidates have null or shorter-than-threshold fields. • Provenance. A file-system check requires the resolved source_path (or video_url) to point to a retrievable resource recorded in the connector’s manifest. Rejected candidates either omit provenance or point to a resource that is not in the manifest snapshot. • Deduplication. A SHA1 hash on (domain, source_path) yields a stable skill identifier; a candidate sharing an identifier with an existing accepted skill is collapsed into the existing entry rather than added separately. Near-duplicate detection is implemented as exact identifier match plus a normalized-name string-equality check on the same source. • Modality consistency. A file-system check verifies that every modality declared in modalities_present resolves to a non-empty file at the expected sub-path. Rejected candidates declare a modality that is not on disk. • Structural executability. For domains with executable skill bodies, a sandboxed test harness imports and runs the code_body against minimal sample inputs (and, where applicable, runs render and overlap gates on the produced artifact). The gate sets a Boolean exec_ok flag in the entry’s metadata; entries with exec_ok=False are retained in the wiki as reference-only and are filtered out by the agent’s default verified-only mode. The executability check therefore validates that the code is structurally runnable and produces a non-trivial artifact, not that it solves any particular benchmark task. The split is therefore prompt-based distillation (one LM call per resource) plus deterministic postprocessing and gating (five rule-based checks). The library is not curated by an LM-as-judge loop, and the gates do not consult the benchmark.

E

Retrieval and Composition Quality

The main paper reports end-to-end overall scores rather than disaggregated retrieval metrics. This section describes what the run logs contain so that retrieval-quality analyses can be reproduced from 16

the released artifacts, and explains why the end-to-end comparison already constrains retrieval and composition quality. What is logged per run. For every (brief_id, condition) pair, the released run directory contains: (i) the BM25 shortlist of the top-K=20 candidates with their lexical scores; (ii) the language-model selector’s transcript including the n=5 chosen skill identifiers and a brief justification per pick; (iii) the agent’s execution trace recording which selected skills were actually invoked, in what order, and with what arguments; (iv) per-call tool invocation success and any apply-tool error returns; and (v) the final scored artifact and judge JSON. These logs permit downstream computation of precision-at-K against any reference relevance label, of selection-call success rates, and of per-skill invocation success rates without re-running the agent. Why end-to-end already constrains retrieval quality. The matched-budget design of the selectionstrategy ablation (Table 5) holds the library, agent, judge, decoding seed, and candidate budget fixed across selection strategies; the only varying factor is how candidate skills are ranked and presented. Under that design, a strategy that retrieves irrelevant skills can fail in two observable ways: the language-model selector can refuse to compose with them (it is permitted to pick zero skills), in which case the agent falls back to free-form code and the score regresses toward the no-skill baseline; or the agent can attempt to compose with them and produce an artifact that the rubric scores poorly. Both failure modes show up as a lower overall score in the corresponding row, which is what we observe for the retrieval-only baselines (E MBED 60.0%, BM25+E MBED 64.2%, R ANDOM -F ULL P OOL 58.0%) relative to O URS (68.9%). Composition behaviour. A run is a single ordered application of n=5 selected skills (or fewer, if the language-model selector picked fewer); we do not perform multi-pass replanning or arbitration between conflicting skills, so the composition step is deterministic given the selected set. Composition conflicts therefore manifest as failures in the apply tool’s structured not-applicable returns or as artifact-level scoring drops; both are recorded in the run directory and contribute to the per-cell overall score.

F

Judge Reliability

We sampled 17 task–artifact pairs uniformly across domains and obtained five-axis scores from three human raters and from the corresponding automatic judge (GPT-5.4 for non-audio artifacts, audio-capable GPT-4o-series judging for Reaper). We report Spearman ρ between the judge and the rater median, and the intraclass correlation coefficient ICC(2,1) treating raters and judge as exchangeable. On the overall axis, ρ = 0.71 and ICC = 0.66; design and detail axes track human medians most closely, while utility shows the highest disagreement (judge tends to reward apparent functionality even when interactivity is absent). Per-axis numbers are tabulated in the supplementary material. We re-ran the judge on the same 17 pairs and obtained ρ = 0.83 between runs, confirming that judge variance is substantially below judge–human variance.

G

Per-Cell Bootstrap CIs and Wilcoxon Tests

For every backend–domain cell of the main comparison (Table 1), Table 6 reports the per-brief win count of W S KILLS over W / O S KILLS on the matched N =80 briefs, the cell mean for each system, the matched delta, the bootstrap 95% confidence interval for the delta computed with 10,000 resamples, and the paired Wilcoxon signed-rank p-value. We report the GPT-5.4 and GPT-5.5 backbones; analogous tables for GPT-5.4 Mini and GPT-5.4 Nano are produced by the same script from the released score JSONs. The W S KILLS delta over W / O S KILLS is significant in every reported cell at p < 10−3 , with 13 of 14 cells at p < 10−8 . W S KILLS wins on every one of the 80 matched briefs in every reported cell.

H

Per-Axis Main-Comparison Details

Table 7 reports the per-axis breakdown of the GPT-5.4 main-comparison cell. Each domain is scored on its own five-axis rubric (full protocol in Appendix B); raw axis means are multiplied by 10 and 17

Table 6: Per-cell bootstrap 95% CIs and paired Wilcoxon p-values for the W S KILLS vs. W / O S KILLS delta on matched N =80 briefs per cell. Wins is the number of briefs on which W S KILLS strictly exceeds W / O S KILLS. Model

Domain

Wins

With

Without

Delta

95% CI

Wilcoxon p

GPT-5.4 GPT-5.4 GPT-5.4 GPT-5.4 GPT-5.4 GPT-5.4 GPT-5.4

Web PPT Excel Blender Reaper CAD UE5

80 80 80 80 80 80 80

82.41 64.81 76.42 44.11 77.31 55.71 67.31

68.72 55.42 58.61 29.52 73.22 48.72 29.12

+13.69 +9.39 +17.81 +14.59 +4.09 +6.99 +38.19

[+11.23, +15.84] [+8.12, +10.51] [+15.16, +20.32] [+12.87, +16.21] [+2.81, +5.38] [+5.42, +8.67] [+35.43, +40.85]

2.31×10−14 1.54×10−13 1.42×10−15 3.19×10−14 3.82×10−9 2.64×10−10 1.18×10−15

GPT-5.5 GPT-5.5 GPT-5.5 GPT-5.5 GPT-5.5 GPT-5.5 GPT-5.5

Web PPT Excel Blender Reaper CAD UE5

80 80 80 80 80 80 80

82.81 67.51 61.32 53.11 77.62 48.71 69.51

69.42 53.92 58.21 35.62 73.12 42.62 30.22

+13.39 +13.59 +3.11 +17.49 +4.50 +6.09 +39.29

[+11.05, +15.63] [+11.87, +15.22] [+0.84, +5.26] [+14.56, +19.81] [+3.15, +5.83] [+4.42, +7.82] [+36.57, +41.84]

2.85×10−14 4.63×10−14 7.15×10−4 1.27×10−14 5.15×10−9 1.93×10−10 1.76×10−15

reported as percentages. The W S KILLS column shows the mean and, in parentheses, the matched percentage-point difference ∆ relative to W / O S KILLS (green for positive).

I

Online Acquisition Details

Trigger and budget. Online acquisition is activated only when the offline wiki fails to return an adequate candidate set for the requested capability. In the offline/online study, the offline pool is fixed at launch and the online arm is allowed to add at most 100 newly searched and distilled skills. This budget is held fixed across task sets so that the comparison measures coverage gain rather than unbounded resource access. Validation. Online candidates use the same construction predicate as offline candidates: the entry must have sufficient text evidence, traceable provenance, non-duplicate metadata, and a valid modality bundle. If executable code is present, it must pass the domain’s smoke check or be marked as reference-only. Rejected candidates are not exposed to the agent. Pool separation. Online entries are stored in a separate pool for the duration of the evaluation split and are not folded back into the offline wiki used by the main comparison or ablations. This prevents online search from silently changing the default skill library.

18

Table 7: Per-axis details for the GPT-5.4 main comparison (%). ∆ is the matched difference of W S KILLS over W / O S KILLS. Domain

Axis

w Skills (∆)

w/o Skills

PPT

layout quality content density theme coherence typography hierarchy overall polish

69.3 (+11.1) 60.8 (+10.1) 71.8 (+9.0) 64.7 (+12.6) 63.9 (+13.2)

58.2 50.7 62.8 52.1 50.7

Excel

structure clarity data density chart quality theme consistency overall polish

78.1 (+21.8) 71.8 (+14.0) 79.4 (+38.2) 70.8 (+11.1) 75.9 (+26.9)

56.3 57.8 41.2 59.7 49.0

Web

visual design hierarchy clarity section richness modernness overall polish

80.4 (+5.3) 84.7 (+12.9) 88.2 (+33.4) 75.8 (+2.6) 77.4 (+15.3)

75.1 71.8 54.8 73.2 62.1

Blender

lighting composition materials realism scene complexity overall aesthetic

61.3 (+27.1) 57.8 (+26.7) 62.1 (+34.3) 53.8 (+25.1) 59.5 (+28.3)

34.2 31.1 27.8 28.7 31.2

UE 5

instruction correctness scene design visual quality technical validity overall effect

49.3 (+8.7) 51.5 (+21.0) 42.1 (+11.3) 62.1 (+29.3) 69.8 (+27.5)

40.6 30.5 30.8 32.8 42.3

CAD

drafting completeness dimensioning annotation layer/linework quality layout readability overall polish

64.8 (+8.1) 48.0 (+6.6) 56.1 (+6.8) 57.2 (+6.8) 51.5 (+6.5)

56.6 41.4 49.4 50.5 45.0

Reaper

low-end balance transient clarity spectrum balance arrangement dynamics overall mix

70.8 (+16.5) 73.2 (+21.4) 68.1 (+19.0) 61.8 (+16.9) 68.1 (+19.7)

54.3 51.8 49.1 44.9 48.4

19

J

Case Studies

We pair one success and one failure case for each of five representative domains (Web, PPT, Excel, Blender, Reaper) on the GPT-5.4 backbone. Success cases are examples where the skill arm clearly improves on the no-skill arm; failure cases are manually authored diagnostic boundary probes where skill use exposes a visible limitation, such as partial grounding, unresolved parameter binding, or overly literal composition. We do not show pure missing-output failures. Each figure shows the two arms side by side. These qualitative examples are manually authored boundary probes and are not included in the matched benchmark aggregates. They should therefore not be interpreted as counterexamples to the paired benchmark results. Instead, they are used to make the method’s limitations concrete: distilled skills improve average artifact quality, but they can still fail when a retrieved skill is only partially grounded, when symbolic bindings do not resolve, or when the agent composes a skill too literally. Web success: cottagecore restaurant landing page. Brief: build a farm-to-table restaurant page (cream, mossy green, floral motifs, rounded serifs; cottagecore digital) with a creative testimonials section. The skill arm produces a complete, content-rich long-scroll page with consistent typography and a styled testimonials block; the no-skill arm produces a thin scaffold-like page that reads as an unfinished template.

Figure 3: Web success. W S KILLS (left) vs. W / O S KILLS (right). 20

Web failure: retro-futurist tabletop game page. Brief: build a one-page site for a retro-futurist tabletop game. Both arms report success: true and TASK_COMPLETE, so this is a quality failure rather than an execution failure: the skill arm is sparser and less finished, while the no-skill arm has fuller section coverage and stronger polish.

Figure 4: Web failure. W S KILLS (left) vs. W / O S KILLS (right).

PPT success: corporate all-hands keynote. Brief: build a 10-slide internal all-hands deck for a customer-success team (sober and corporate, blue/gray restrained) with cover, agenda, dividers, content slides, and closing. The skill arm produces a deck with shell variety, dense per-slide content, and consistent theming; the no-skill arm produces a thinner deck with several placeholder-feeling slides. 21

Figure 5: PPT success. W S KILLS (left) vs. W / O S KILLS (right). PPT failure: product strategy quarterly review. Brief: build a 10-slide quarterly review deck for potential acquirers (sober and corporate, blue/gray restrained). The skill arm introduces unprocessed placeholder text and JSON-like fragments on the agenda slide and does not visibly inherit the chosen visual motifs; the no-skill arm is plainer but consistently styled.

Figure 6: PPT failure. W S KILLS (left) vs. W / O S KILLS (right). Excel success: SaaS dashboard. Brief: build a multi-sheet workbook with a summary dashboard, KPI blocks, and supporting detail sheets. The skill arm produces a summary-first workbook with KPI cards, dense data tables across sheets, and a coherent chart system; the no-skill arm produces a much sparser workbook with smaller, less polished tables and limited cross-sheet structure.

Figure 7: Excel success. W S KILLS (left) vs. W / O S KILLS (right). 22

Excel failure: dashboard with broken formulas. Brief: build an Excel workbook with dashboard and supporting detail sheets. The skill arm reuses dashboard components from the wiki but leaves visible #NAME? formula errors on several cells; the no-skill arm avoids reusable components entirely and produces a cleaner, error-free aggregated dashboard. This case illustrates that a partially-grounded skill, with a referenced formula whose bindings did not resolve, can be worse than a simple bespoke layout.

Figure 8: Excel failure. W S KILLS (left) vs. W / O S KILLS (right).

Blender success: emerald jewelry hero shot. Brief: render a single hero-shot 3D scene of an emerald ring with staged lighting and styled materials. The skill arm produces an identifiable hero subject with rim and key lighting (blue/amber treatment) and PBR materials; the no-skill arm produces a flatly lit primitive blockout that does not read as a jewelry render.

Figure 9: Blender success. W S KILLS (left) vs. W / O S KILLS (right).

Blender failure: perfume bottle macro. Brief: render a luxury macro of a glass perfume bottle. The skill arm inspects multiple glass and lighting skills but produces a washed-out final render that fails to show the bottle and its materials; the no-skill arm produces a simpler scene that at least reads as a recognizable bottle. This case illustrates that complex skill compositions can fail to ground when key parameters (background, exposure, camera) are not visibly inherited. 23

Figure 10: Blender failure. W S KILLS (left) vs. W / O S KILLS (right).

Reaper success: deep house track. Brief: produce a 30–60 s deep house track with sidechained bass, harmonic layering, and arrangement dynamics. The skill arm adds audibly grounded sidechain pumping, a distinct bassline, harmonic layering, and clearer intro/main/outro variation; the no-skill arm is competent but flatter in arrangement dynamics.

Figure 11: Reaper success. Spectrogram and waveform of W S KILLS (top) vs. W / O S KILLS (bottom).

Reaper failure: less-dynamic arrangement. Brief: produce a short genre track with intro/main/outro variation. The skill arm is competent but stays in one section throughout; the no-skill arm produces stronger intro/main/outro variation and overall mix polish. Reaper has the smallest no-skill-to-skill margin in the main aggregate; this case is consistent with that pattern. 24

Figure 12: Reaper failure. Spectrogram and waveform of W S KILLS (top) vs. W / O S KILLS (bottom). What the failures reveal. Across the five failure cases, two recurring patterns emerge: (i) partial grounding, where a skill is selected and its surface pattern is borrowed but key bindings or parameters do not resolve in the final artifact (Web tabletop, Excel #NAME?, Blender perfume); and (ii) conservative composition, where the skill arm sticks closer to a single pattern and loses the variation a less-anchored agent would have introduced (PPT placeholder, Reaper less-dynamic). These patterns are consistent with the R ANDOM -F ULL P OOL and E MBED retrieval baselines underperforming O URS in the selection ablation: a skill is only as useful as the agent’s ability to bind its parameters, and stronger selection narrows this binding cost.

25

K

User Study

We validate the main comparison with a blinded human A/B study. Artifact pairs are sampled from Section 4.2 balanced across the seven domains, and five human raters per pair view anonymized renderings side by side and choose the better artifact or declare a tie. We use this human study as an external validation of the automatic judge’s preference direction, not as a training or selection signal. Inter-rater agreement is Krippendorff’s α = 0.58. Table 8 reports the per-domain breakdown. W S KILLS wins 64.2% of pairs and W / O S KILLS wins 12.9% (22.9% ties); excluding ties, W S KILLS’s win rate is 83.3%. The smallest margin is on Reaper (74.7% excl. ties), consistent with its stronger no-skill prior over the medium in the automatic-judge results; the largest is on UE5 (91.8%). The ordering of per-domain win rates tracks the ordering of judge overall-score deltas, supporting the use of the automatic judge as the primary signal in the main paper. Table 8: Per-domain human A/B study against W / O S KILLS. Five raters per pair on anonymized side-by-side renderings. Win rate excl. ties excludes ties from the denominator. Domains sorted by ascending win rate excluding ties.

L

Domain

W S KILLS Win (%)

Tie (%)

W / O S KILLS Win (%)

Win Rate excl. Ties (%)

Reaper CAD PPT Web Blender Excel UE5

48.2 53.6 60.5 63.8 68.4 73.2 81.5

35.5 29.8 25.1 22.6 19.5 16.4 11.2

16.3 16.6 14.4 13.6 12.1 10.4 7.3

74.7 76.4 80.8 82.4 85.0 87.6 91.8

Overall

64.2

22.9

12.9

83.3

Skill Library Schema and Storage

Each skill is materialized as a modality bundle: skills_wiki/<domain>/<skill_id>/ source/ # provenance and resource references text/ # overview, mechanism, applicability, inputs visual/ # thumbnail, screenshot, render, or diagram code/ # executable or adaptable procedure, if available meta.json # category path, tags, source type, validation status

The metadata includes skill_id, skill_name, domain, category_path, tags, applicability, source.type, provenance fields, and validation status. The prose body follows the same semantic sections used in the main text: mechanism, use conditions, inputs, and expected effects. This storage format is an implementation of the abstract tuple s = (p, xtext , xvisual , xcode , m) from Section 3.1.

M

Limitations

Most scores route through GPT-5.4 vision on rendered artifacts (Reaper through an audio-capable GPT-4o-series judge); judge–human agreement on the 17-task subsample (Appendix F) is acceptable, and a blinded human A/B study with five raters per pair across all seven domains (Appendix K) independently corroborates the preference direction reported in the main comparison. We do not claim generalization to domains lacking either a programmatic tool interface or a public stream of procedural content. Online acquisition adds search, distillation, and validation latency on top of the normal benchmark pass. We deliberately keep it outside the main comparison and evaluate it only on a fixed online pool against Tnovel , where gap-filling is the question being asked; folding online search into the default pipeline would conflate library-scaling effects with uncontrolled context expansion at test time. The online/offline study therefore measures coverage gain on capability regions known to be insufficient, not unbounded test-time recall. 26

Our retrieval-style baselines (E MBED, BM25+E MBED) operate over the distilled skill library, not over the raw resource corpus (transcripts, repository chunks, articles) under a matched token budget. We leave a same-budget raw-resource retrieval comparison to future work.

27