Frontier & other 5 papers

Skill-to-LoRA (S2L) treats a SKILL.md file as training data, not runtime cargo. Offline, a teacher model reads the full skill document and generates synthetic task-response pairs that demonstrate the behavior it describes; those pairs train a small LoRA adapter for that one skill, with the base model frozen the whole time. At inference, the adapter loads and the SKILL.md text disappears from the prompt entirely — what's left is a lightweight skill-id tag, and the model acts on a learned behavioral prior instead of re-reading procedure on every step.

SKIM (SKIll coMpression) replaces a reusable agent skill's full instructions with a small set of learned soft tokens , so the skill no longer has to be pasted into every prompt in full. A compressor model reads the skill text alongside a fixed budget of learnable slot tokens, an MLP projector maps the result into the target model's embedding space, and a LoRA adapter teaches the target LLM to treat those soft tokens as if it had read the source text directly. Training moves from general to specific across three stages: it first reconstructs 60.9k collected skills to build general procedural knowledge representations, warms up next on procedural question-answering over 214.3k WikiHow-derived QA examples, and finally aligns on roughly 60k skill-conditioned QA examples via LoRA fine-tuning with the target model. Skill complexity varies enormously, so before deployment SKIM runs what the paper calls offline resolution selection : generate diagnostic questions from a skill, check how well answers at each token budget (256, 512, or full text) match the full-text answer, and lock in the smallest budget that clears a fidelity bar — all computed once, offline, before the skill is ever deployed.

Skill-as-Pseudocode (SaP) rewrites markdown skill libraries into typed pseudocode, so agents stop re-deriving schemas and call syntax from prose on every retrieval. The pipeline clusters similar procedural passages across a library and extracts a typed contract for each cluster. Before promotion, each contract has to clear a four-check deterministic verifier — coverage, binding, replacement, risk. Verified contracts get inlined into a rewritten skill file alongside restored concrete action templates, so one retrieval now hands the agent both a typed signature for what a skill does and syntax it can invoke directly.

Agents built on vision-language models rarely repeat themselves. Ask the same policy to complete the same web task twice and the click sequences drift, even though the underlying reasoning hasn't changed. The standard fix is self-consistency — sample several rollouts, vote on the majority action — which trades inference cost for stability and throws away the pattern it just discovered. A reusable agent skill splits that task-relevant signal differently: some of it verbalizes cleanly into a procedure card, some of it lives in perceptual detail that resists description. Storing both streams side by side, uncoordinated, just duplicates whatever the text already captured.

Scale first: two public catalogs hold 118,000 agent skills between them — 28,990 on clawhub.ai, 89,280 on skills.sh. Running that catalog against eight LLMs and three harnesses (BareAgent, OpenCode, OpenClaw) on SkillsBench-style tasks turns up a blunt pattern: a skill isn't actually a portable unit. It's raw context that one model's harness happens to parse correctly and another's doesn't. SkVM's answer borrows from compiler theory — treat the skill as source code, the LLM as a heterogeneous processor, and decompose what the skill demands into primitive capabilities : 26 of them, spanning code generation, reasoning, tool execution, and procedure-following, each gated by a proficiency level. A one-time profiling pass scores how well a given (model, harness) pair supports each primitive, and that profile drives capability-based compilation , environment binding, and concurrency extraction before the skill ever runs — plus JIT code solidification and adaptive recompilation while it does.