cs.SEApr 3, 2026

SkVM: Revisiting Language VM for Skills across Heterogenous LLMs and Harnesses

Authors: Le Chen, Erhu Feng, Yubin Xia, Haibo Chen

Organizations: Shanghai Jiao Tong University Shanghai, China

Read PDF
Ask AI
Cite

Copy citation

DOINot available for this paper

Abstract

LLM agents increasingly adopt skills as a reusable unit of composition. 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. This fragility undermines skill portability and execution efficiency. To address this challenge, we analyze 118,000 skills and draw inspiration from traditional compiler design. We treat skills as code and LLMs as heterogeneous processors. To make portability actionable, we decompose a skill's requirements into a set of primitive capabilities, and measure how well each model-harness pair supports them. Based on these capability profiles, we propose SkVM, a compilation and runtime system designed for portable and efficient skill execution. At compile time, SkVM performs capability-based compilation, environment binding, and concurrency extraction. At runtime, SkVM applies JIT code solidification and adaptive recompilation for performance optimization. We evaluate SkVM across eight LLMs of varying scales and three agent harnesses, covering SkillsBench and representative skill tasks. Results demonstrate that SkVM significantly improves task completion rates across different models and environments while reducing token consumption by up to 40%. In terms of performance, SkVM achieves up to 3.2x speedup with enhanced parallelism, and 19-50x latency reduction through code solidification.

Figures & tables

Figure 1. Evolution of programming abstractions. Skills are the current frontier: natural language programs of hundreds of lines that lack a compiler and runtime for cross-target portability.
Figure 2. Skill performance across models and harnesses. Columns are tasks, rows are models, and each subplot corresponds to one harness. Cell colors indicate score deltas relative to the no-skill baseline, and cell labels show absolute task scores. Both model identity and harness choice significantly affect outcomes.
Figure 3. Skill download distribution on clawhub.ai and skills.sh. Both platforms show a long-tailed distribution.
Figure 4. Removing a required dependency hurts both correctness and efficiency.
Figure 5. SkVM architecture. The AOT compiler produces optimized skill variants at install time through three passes. The runtime manages variant selection, JIT optimization, and resource-aware scheduling during execution.
PrimitiveL1L2L3
gen.code.shellBasic commands (ls, cat)Pipes, redirection, loopsComplex pipelines (sed, awk)
reason.arithmeticSingle-step opsMulti-stepCompound
tool.execSingle commandParams and relative pathsChained multi-step execution
follow.procedure3 sequential steps5–7 with branchesLoops and verification
Table 1. Representative primitive capabilities and their proficiency levels. The full catalog contains 26 primitive capabilities across four categories.
Figure 6. Capability-based compilation on a PPTX skill. The compiler extracts skill requirements (left), profiles the target (middle), and applies transforms based on the gap (bottom).
Figure 7. Concurrency extraction on an incident-response skill. The compiler decomposes sequential steps into a workflow DAG, identifies parallel opportunities both between steps and within steps, and maps each to the appropriate concurrency primitive.
Figure 8. Code solidification pipeline. The AOT compiler analyzes skill code segments and generates JIT candidates with code signatures and templates (Stage 1). The runtime validates predictions across invocations (Stage 2). After promotion, a compiled function replaces LLM inference (Stage 3).
Figure 9. Skill compilation effectiveness. Cell values represent task completion rates after SkVM optimization, while cell color indicates the score improvement (green) or regression (red) relative to original baseline skills.
Figure 10. Average task score by skill variant. Four variants are compared across eight models and three harnesses: No Skill, Original, Skill-Creator, and SkVM -Optimized. Tier boundaries (SOTA / Mid / Small) are shaded. SkVM -Optimized skills consistently achieve the highest scores, with the largest absolute gains for weaker models and on OpenClaw.
Figure 11. Staged optimization breakdown across 14 skill categories. Each group shows scores at six stages: no skill, original skill, AOT-compiled skill, and skills optimized in three JIT rounds.
Figure 12. Score gain vs. token savings for SkVM optimization over the Original baseline. Each point is a (model, harness) pair. Color = model tier, shape = harness. Most points land in the upper-right quadrant: better quality and fewer tokens.
Figure 13. Per-category breakdown of capability profiling overhead for two small models. Left: duration in seconds. Right: cost in millidollars.
Figure 14. Environment binding restores correctness, token efficiency, and execution speed. From left to right: average score, average token use, and average duration across two tasks per model. Env-bound performance returns to complete-environment levels for all three models.
Figure 15. Code solidification across four cases. Blue bars show LLM inference latency, green bars show solidified execution. The dashed line marks the promotion point. Weather-forecast never promotes because the runtime model’s code patterns diverge from the AOT prediction, validating the promotion gate as a safety mechanism.
Figure 16. Performance of different parallelization strategies across eight tasks. Bars show sequential, DLP, ILP, and TLP execution.
More in this topic

LLM Agents

Large language model agents use language models to plan, use tools, and act across multi-step tasks and environments.

See all 705 papers

Explore similar work

CardsList
May 12, 2026

SkillSmith: Compiling Agent Skills into Boundary-Guided Runtime Interfaces

Recently, skills have been widely adopted in large language model (LLM)-based agent systems across various domains. In existing frameworks, skills are typically injected into the agent reasoning loop as contextual guidance once matched to a runtime task, enabling specialized task-solving capabilities. We find that this execution paradigm introduces two major sources of redundancy: irrelevant context injection and repeated skill-specific reasoning and planning. To this end, we propose SkillSmith, a boundary-first compiler-runtime framework that compiles skill packages offline into minimal executable interfaces. By extracting fine-grained operational boundaries from skills, SkillSmith enables agents to dynamically access and execute only the relevant components at runtime, thereby minimizing unnecessary context injection and redundant reasoning overhead. In the evaluation on SkillsBench benchmark, SkillSmith reduces solve-stage token usage by 57.44%, thinking iterations by 42.99%, solve time by 50.57% (2.02x faster), and token-proportional monetary cost by 57.44% compared with using raw-skills. Moreover, compiled artifacts produced by a stronger model can be reused by a smaller or more efficient runtime model, improving task accuracy in cases where raw skill interpretation fails. The source code and data are available at https://github.com/AetherHeart-AI/Aeloon.

Duling Xu, Zheng Chen, Zaifeng Pan +4

AetherHeart Tech Co., Ltd., Shanghai, China · Renmin University of China, Beijing, China · University of California San Diego, CA, USA

LLM Agent Workflow OptimizationLLM Agent Skill RetrievalLLM AgentsLLM Agent Efficiency
AskPDF
May 5, 2026

SkCC: Portable and Secure Skill Compilation for Cross-Framework LLM Agents

LLM agents increasingly rely on reusable skills (e.g., SKILL markdown files) to execute complex tasks, yet these artifacts lack portability: agent frameworks are highly sensitive to prompt formatting, leading to a large performance variation for the same skill. Nevertheless, most skills are authored once as format-agnostic Markdown, necessitating costly per-framework rewrites and also leaving security largely unaddressed, with widespread vulnerabilities in practice. To address this, we present SkCC, a compiler for LLM agents that introduces classical compilation design into agent skill development. SkCC centers on SkIR, a strongly-typed intermediate representation that decouples skill semantics from framework-specific formatting, thus enabling portable deployment across agent frameworks. Atop of this IR, a static Optimizer enforces security constraints, blocking vulnerabilities before deployment. Implemented as a four-phase pipeline, SkCC effectively reduces adaptation complexity from O(m×n)O(m \times n) to O(m+n)O(m + n) across mm skills and nn frameworks. Experiments on SkillsBench demonstrate that SkCC delivers consistent and substantial gains over original counterparts, with pass rate increases from 21.1% to 33.3% on Claude Code and from 35.1% to 48.7% on Kimi CLI. Further, the design achieves sub-10ms compilation latency, 94.8% proactive security trigger rate, and 10-46% runtime token savings across frameworks.

Yipeng Ouyang, Yi Xiao, Yuhao Gu +1

Sun Yat-sen University

LLM Agent SecurityLLM Agent Skill RetrievalLLM Agents
AskPDF
May 19, 2026

Formal Skill: Programmable Runtime Skills for Efficient and Accurate LLM Agents

Large Language Model (LLM) agents increasingly act inside real workspaces, where tools and skills determine whether model reasoning becomes reliable action. Existing skills remain largely informal: Markdown skills and instruction packs encode procedures as long natural-language documents, while function calling, Model Context Protocol (MCP) servers, and framework tools structure individual actions but usually leave workflow state, policy enforcement, and completion discipline outside the skill itself. We introduce Formal Skill, a runtime-native abstraction that represents reusable capability with JSON metadata and action schemas, reliable Python executors, hook-governed control logic, Formal Skill routing, and skill-local runtime state. By moving reusable procedure from repeated prompt text into executable state machines and hook policies, Formal Skill gives agents a token-efficient and enforceable control surface. We implement the abstraction in FairyClaw, an open-source event-driven runtime for executable, observable, and composable Formal Skills. On Harness-Bench, FairyClaw obtains highly competitive average scores while using substantially fewer tokens, with especially strong results on tasks that expose the role of Formal Skill.

Xi Zhang, Meijun Gao, Yuntian Zhao +6

Tool-Using AgentsLLM Agents
AskPDF