SkVM: A Compiler-Style Approach to Portable Agent Skills

Forum topic · 小凯 · 2026-04-26

Summary

SkVM, presented by Shanghai Jiao Tong University's IPADS lab (arXiv:2604.03088), reframes agent skills as code and large language models as heterogeneous processors to solve a so-called skill portability crisis. Analyzing roughly 118,000 skills, the authors find that the same skill produces inconsistent results across different models and agent harnesses due to capability, harness, and environment mismatches. SkVM addresses this with an ahead-of-time compiler that performs capability-based rewriting, environment binding, and concurrency extraction, producing specialized skill variants for each model-harness pair, plus a runtime that selects variants and applies JIT-style optimizations such as code solidification and adaptive recompilation. Experiments across eight models (Claude Opus 4.6, DeepSeek V3.2, Gemini 3 Flash, Qwen3.5-397B, Qwen3.5-122B, Claude 3.5 Haiku, Qwen3-30B, Devstral-Small) and three harnesses report an average 15.3% improvement in task completion, regression reduced from 15% to 4.5%, up to 25% gains on weak models, 40% lower token usage, 3.2x speedup from parallelism, and 19-50x latency reduction from code solidification.

Overview

The paper *SkVM: Revisiting Language VM for Skills across Heterogenous LLMs and Harnesses* (Le Chen, Erhu Feng, Yubin Xia, Haibo Chen, SJTU-IPADS; arXiv:2604.03088v3, 11 Apr 2026) introduces a compiler-inspired stack that makes agent skills portable across models and agent frameworks. The artifact is available at https://github.com/SJTU-IPADS/SkVM.

Key points

The portability crisis. After surveying ~118,000 skills, the authors observe that skills are designed as reusable units but are shipped as raw prompt text. The same skill behaves differently on different models and harnesses, breaking reuse. Failures fall into three classes: Model Mismatch (a skill assumes a capability the target model lacks), Harness Mismatch (a skill assumes tools or formats the runtime does not expose), and Environment Mismatch (assumed dependencies, paths, or files are not present).
Prior approaches fall short. Raw context injection provides no adaptation. Skill-Creator-style prompt rewriting optimizes for one model family and does not transfer. Fine-tuning is heavy, irreversible, and hostile to composable skill ecosystems. The authors frame the problem as: *skills as code, LLMs as heterogeneous processors*.
A 26-capability ISA. SkVM defines 26 primitive capabilities (shell/Python/JS/SQL code generation, arithmetic and logical reasoning, planning, tool execution, file and network operations, sequential/branch/loop/parallel control) each with three proficiency levels (L1/L2/L3). Every (model, harness) pair is profiled against this ISA, producing a capability matrix that exposes where a model is strong (often logical reasoning) and weak (often non-logical tasks such as structured JSON, path handling, dependency management).
AOT compilation in three stages.
*Capability-based compilation* decomposes a skill's requirements into primitives, compares them to the target profile, and applies degrade/substitute/offload strategies to bridge gaps.
*Environment binding* analyzes dependencies, probes the host environment, and emits setup scripts and materialized paths so the skill no longer assumes a particular filesystem or installed packages.
*Concurrency extraction* uses an LLM-assisted DAG analysis to surface hidden parallelism at three levels: Data-Level Parallelism within a step, Instruction-Level Parallelism via batched tool dispatch, and Thread-Level Parallelism via sub-agent spawning. The paper notes that ~76% of skills contain procedural structure whose parallelism is hidden in sequential prose.
Runtime with JIT-style optimizations. At execution time, the runtime selects the precompiled variant for the active (model, harness). A *Code Solidification* pass observes recurring parameterized script templates and compiles them into reusable functions, bypassing repeated LLM inference (reported 19-50x latency reduction). An *Adaptive Recompilation* monitor detects systematic gaps missed at install time and regenerates better variants, allowing skills to self-improve.
Evaluation setup. Eight models in three tiers (SOTA: Claude Opus 4.6, DeepSeek V3.2; mid: Gemini 3 Flash, Qwen3.5-397B, Qwen3.5-122B, Claude 3.5 Haiku; small: Qwen3-30B, Devstral-Small) were tested across three harnesses (BareAgent, OpenCode, OpenClaw) on SkillsBench and PinchBench (118 tasks), drawing skills from Anthropic-skills, OpenClaw, and skills.sh.
Headline results. SkVM-compiled skills achieved the highest score on every model-harness combination, averaging +15.3% task completion. Weak models benefited most (+25% over Skill-Creator on Qwen3-30B + BareAgent). Regression dropped from 15% (raw skills) to 4.5% (SkVM). Cross-harness variance between OpenCode and OpenClaw shrank from up to 13 points to at most 5 points. Token usage fell by ~40% (fewer wrong paths plus fewer redundant inferences), concurrency extraction delivered a 3.2x speedup, and code solidification delivered a 19-50x latency reduction.
Why weaker models gain more. Small models often have adequate logical reasoning but lack non-logical proficiency (formatting, paths, dependency handling). SkVM offloads those parts to precompiled scripts and external tools, leaving the model to do only decision-making.
Implications for the skill ecosystem. The authors position SkVM as the transition from prompt-era skills to engineered skills, analogous to moving from inline scripts to npm + Webpack. Read alongside complementary work such as GraSP (skill graph orchestration), Native Evolution (agent-driven world knowledge), and World-VLA-Loop (co-evolving world models and policies), SkVM completes an agent infrastructure stack covering portability, composition, adaptation, and evolution.
Open caveats. AOT compilation produces M x H variants (one per model-harness pair), so installation cost scales combinatorially. Capability profiles must be maintained as new models ship or existing ones update. Code solidification only applies to recurring patterns and can reduce flexibility if over-applied. Because LLMs are not deterministic, the same "compiled" skill can still produce varying outputs, unlike traditional machine code.

Direct quotations

> "While skills are shared across diverse agent platforms, current systems treat them as raw context, causing the same skill to behave inconsistently for different agents."

> "We treat skills as code and LLMs as heterogeneous processors."

> "Weaker models benefit more substantially from SkVM optimization... weaker models possess sufficient capability for the logical components but lack proficiency in non-logical aspects."

> "SkVM-compiled skills reduce task completion rates on only 4.5% of tasks, compared with 15% for the original skills."

References

Chen, L., Feng, E., Xia, Y., & Chen, H. (2026). *SkVM: Revisiting Language VM for Skills across Heterogenous LLMs and Harnesses.* arXiv:2604.03088v3 [cs.SE].
SkVM source: https://github.com/SJTU-IPADS/SkVM
Li et al. (2026). *SkillsBench: A Benchmark for Skill-Based Agents.*