Resource2Skill: Distilling Tutorials into Executable AI Agent Skills

From Raw Resources to Executable Skills: The Distillation Model

Most agent frameworks provide tools at runtime, leaving the agent to figure out how to accomplish a task with no prior domain knowledge. Resource2Skill inverts that: before the agent ever runs, a distillation pipeline converts tutorial videos, reference artifacts, articles, and code into structured, browsable skill entries. At runtime the agent reads from two directory roots: skills_wiki/<domain>/ holds the structured wiki entries that the agent browses and searches, and skills_library/<domain>/ holds the executable assets that domain-specific MCP servers use when the agent calls a skill.

The README describes the framework as producing Web pages, PowerPoint decks, Excel workbooks, Blender scenes, and REAPER-style audio. The project description extends that list to CAD and Unreal Engine 5 as well. Each domain has its own MCP server registered in the agent loop, so the agent can call cross-domain skills by issuing MCP tool calls without knowing the implementation details of any single domain.

The skill dataset distilled from human resources is available separately on Hugging Face at microsoft/RESOURCE2SKILL, which means teams can start with the pre-built libraries rather than running the distillation pipeline themselves.

Six Domains and the cli.py Entry Point

All agent operations go through a single command-line interface: cli.py. Two subcommands are meant for setup validation before any full run. The first lists available domains:

python cli.py domains

The second validates that a domain's system dependencies are installed and importable:

python cli.py validate-domain --domain web

The validate-domain check is worth running for every domain before running a task, because each one depends on different system software. The web domain requires a Chromium install via playwright. The PowerPoint domain requires LibreOffice (specifically the soffice binary) for deck rendering. The REAPER-style audio domain requires the fluidsynth binary and a General MIDI soundfont file, with the soundfont path set via VWS_REAPER_SOUNDFONT. The Blender domain requires bpy (headless Blender as a Python module) and will not work on Python 3.10 since no bpy wheel exists for that version.

The core agent subcommand takes a domain, a task string, a model, and iteration limits:

python cli.py agent \
  --domain web \
  --task "Build a one-page landing site for a neighborhood arts nonprofit called Quartz. Warm hand-made editorial style; programs, impact, donation tiers, FAQ, footer. Save and STOP." \
  --model gpt-5.4 --reasoning low --max-iter 40

Generated files land in demo/<domain>/. For longer tasks on the PowerPoint backend, the README specifies the PPT Master flow, which uses an SVG-first approach and requires asking for it explicitly with the model flag set to gpt-5.5 and --n-skills and --top-k parameters.

More example prompts are stored in examples/case_prompts.json.

Installation: Python 3.11, Requirements, and Model Configuration

Python 3.11 is required. The README says most of the four non-Blender domains also run on Python 3.10, but the Blender domain's bpy dependency has no 3.10 wheel, so a 3.11 environment is the safer baseline. The installation sequence is:

python3.11 -m venv .venv
source .venv/bin/activate
python -m pip install --upgrade pip
python -m pip install -r requirements.txt

requirements.txt pins mcp to >=1.26. The README notes that mcp 1.10.x crashes the codebase's servers because those servers use from __future__ import annotations, which triggered an issubclass() error in earlier mcp releases. That pin matters if you are resolving dependencies in an environment that has an older mcp version cached.

Model configuration goes in a .env file. The repository includes a .env.example:

cp .env.example .env

The example shows Azure OpenAI fields:

AZURE_OPENAI_ENDPOINT=https://<your-resource>.openai.azure.com/
AZURE_OPENAI_API_KEY=<your-key>

Per-model endpoint overrides (AZURE_OPENAI_ENDPOINT_54, AZURE_OPENAI_DEPLOYMENT_54) allow running different backend deployments for the gpt-5.4 and gpt-5.5 model aliases that appear in the example commands. OPENAI_API_KEY and GEMINI_API_KEY entries are also present in .env.example for the collection and distillation utilities, but the runtime agent itself uses the Azure OpenAI fields by default.

Domain-Specific System Dependencies

The requirements.txt comment describes the four non-Blender domains as verified in a clean Python 3.11 environment as of June 2026, with both cli.py validate-domain and the MCP server imports passing. That verification covers web, ppt, excel, and reaper.

For web, one post-install step is needed: python -m playwright install chromium. For PowerPoint, LibreOffice must be available on the system PATH as soffice. For REAPER-style audio, fluidsynth must be installed as a binary and a soundfont file must be placed somewhere accessible; the path is passed to the environment as VWS_REAPER_SOUNDFONT=/path/to/soundfont.sf2. For Blender:

pip install bpy

bpy installs headless Blender as an importable module, but only in a Python 3.11 environment.

The combination of these requirements means a machine set up for all six domains would have Chromium, LibreOffice, fluidsynth, a soundfont, and bpy installed alongside the Python environment. A container-based setup for each domain separately is feasible but not documented in the repository; the top-level directory has no Dockerfile or docker-compose file.

Where Resource2Skill Does Not Fit

Resource2Skill is not a general-purpose agent framework. It is a domain-specific runtime for the skill types its MCP servers know about. If your target domain is not web, PPT, Excel, Blender, CAD, UE5, or REAPER audio, the framework has no path for adding a new domain without writing a new MCP server and distillation pipeline.

The framework also assumes the underlying model is accessed via Azure OpenAI or compatible API endpoints. Teams using local models, models hosted on other providers, or models that do not support the MCP tool-calling protocol will need to adapt or replace the agent loop in core/.

The project has no GitHub releases. Version control is entirely on the main branch. Any team building an integration that depends on a specific skill library state will need to pin to a specific commit hash rather than a release tag. The HuggingFace dataset (microsoft/RESOURCE2SKILL) version may differ from what the repository's skills_wiki and skills_library directories contain at any given moment.

The README also notes that a skills-lock.json file is in the root, suggesting the skill libraries are versioned separately from the code, but the README does not document the lock file format or how to update it.

Resource2Skill Versus General Agent Frameworks

AutoGen, also from Microsoft, is a framework for orchestrating multi-agent workflows. It provides conversation patterns between agents and lets each agent call tools, but it does not include a mechanism for pre-distilling domain knowledge from tutorials into a persistent, browsable skill library. An AutoGen agent building a PowerPoint file from scratch has no pre-loaded knowledge of SVG recipes or PPTX structure unless the developer supplies that context at runtime. Resource2Skill's PPT Master backend, by contrast, instructs the agent to call pptmaster_select_r2s_refs first and read each chosen skill's svg_recipe as a scaffold, drawing on skills distilled from existing tutorials.

The difference matters most for domain coverage depth: Resource2Skill carries compressed knowledge from human-created tutorials, so it can follow PPTX conventions or Blender material idioms without the model having seen those patterns in its pre-training data. The trade-off is tighter scope. AutoGen works for any task a model can express as tool calls; Resource2Skill only performs well for tasks that fall within the six supported domains and that fit the skill-based execution model.

Skill Libraries on Hugging Face and the skills-lock.json

The distilled skill libraries live on Hugging Face at https://huggingface.co/datasets/microsoft/RESOURCE2SKILL. The README states that at runtime the agent reads from the two local roots: skills_wiki/<domain>/ and skills_library/<domain>/. This means the HuggingFace dataset is a canonical upstream source, and the repository may not contain all skill files by default (they may be fetched or synchronized separately).

The skills-lock.json file in the root suggests a versioning mechanism for skill library state, analogous to a package lock file for the skills dataset, but the README does not describe its schema or how to regenerate it. Teams that modify or extend the skill libraries will need to inspect that file to understand how skill versions are tracked.

The MIT license allows teams to modify and redistribute the skill libraries alongside custom MCP servers. There is no patent grant in the MIT license, but Microsoft's SECURITY.md and CODE_OF_CONDUCT.md files in the repository follow standard Microsoft open-source policies. The CITATION.cff file provides structured citation metadata for academic use.

Editorial conclusion

Research engineers who need a reproducible base for skill-based agent workflows across web, Office, and 3D software can use Resource2Skill as a starting point. Anyone without Python 3.11 or without the per-domain system binaries should run cli.py validate-domain for each target before building on top of it. The REAPER domain additionally requires fluidsynth and a General MIDI soundfont; the Blender domain requires the bpy Python module, which has no wheel for Python 3.10. The MIT license imposes no redistribution barriers. The project has no GitHub releases, so dependency versions are determined entirely by requirements.txt and must be pinned by any downstream consumer.

Frequently asked questions

Official sources

1. Issues
2. License: MIT
3. microsoft/Resource2Skill on GitHub
4. Project website
5. README