SMO: Compiling Natural Language Skills into Graphs of Reusable State-Move-Outcome Bricks

Chao Chen, Jiashuo Zhang, Yunhang Shen, Liangyu Lian, Rongrong JiarXiv 2026 · arXiv

TL;DR

SMO (State-Move-Outcome) is a compilation framework that transforms messy, redundant natural language agent skills into a structured library of reusable "procedural bricks." By focusing on functional transitions rather than surface wording, SMO achieves a 2.46× compression ratio and a 59.3% reduction in tokens while simultaneously boosting agent task performance and cutting runtime costs.

What Problem Does This Paper Address?

As Large Language Model (LLM) agents become more sophisticated, they increasingly rely on external libraries of "skills"—essentially instructions on how to perform specific tasks. Currently, these skills are often stored as collections of natural language documents (like SKILL.md files).

The authors identify three major headaches with this document-centric approach:

  1. Redundancy: Different authors might describe the exact same operation using different prose, forcing the agent to re-interpret the same logic repeatedly.
  2. Entanglement: Reusable logic is often mixed with task-specific data (like specific file paths or names), making it hard to extract the "core" procedure.
  3. Fragility: It is difficult to verify if two skills can be safely composed or if a skill is actually valid before the agent tries to run it.
Figure 1: One procedure, many descriptions. Multiple rawSkills may encode the same operation using different natural-language expressions, causing repeated interpreta- tion. SMO compiles them into smoSkills that reference one shared admitted brick, reducing duplicated procedural con- text while retaining task-specific composition.

Methods

The researchers propose SMO, which treats skill management like a software compilation process. Instead of treating a skill as a block of text, they treat it as a series of State–Move–Outcome transitions.

The framework operates in two main paths:

1. The Reuse Compilation Path

This path takes a "raw" skill and breaks it down:

  • Atomization: The "Atomizer" splits the text into discrete procedural requirements.
  • L1 Matching: The system searches a symbolic basis for existing "bricks" that match the required state transitions.
  • L2 Binding: It maps task-specific variables (e.g., "sort by price") into the generic slots of the brick.
  • L3 Patching: If there's a tiny difference between the requirement and the brick, a "delta" is applied to bridge the gap.
  • Topology Construction: The bricks are assembled into a graph. Crucially, they are connected by "Outcome-to-State" gates, ensuring that one step's output actually satisfies the next step's requirements.

2. The Basis Evolution Path

If the compiler encounters a procedure it doesn't recognize, it doesn't just fail. It routes the gap to a Brick Foundry. Here, new candidate bricks are constructed, validated for novelty and reusability, and eventually admitted into the "frozen" symbolic basis for future use.

Figure 2: Overview of SMO. (a) The reuse path atomizes a rawSkill, reconstructs its requirements through L1 matching, L2 binding, and L3 bounded patching, and assembles a skill graph for Agent execution. (b) Only compilation gaps enter basis evolution. New operations join the next frozen snapshot only after candidate construction and admission; Agent execution does not feed back into SMO.

Datasets

The primary evaluation was conducted on SkillsBench v1.1, a benchmark containing 87 distinct tasks and 232 official skill documents. The authors also created an internal engineering-diagnostic corpus to specifically test how well the system handles structural sharing and generic contract formatting.

Key Insights and Ideas

  • Procedural Equivalence > Surface Similarity: The authors argue that a skill's value isn't in its wording, but in its transitions. Two instructions that look different but do the same thing should be the same "brick."
  • Structural Guards: By enforcing compatibility at the graph level (e.g., checking if a "Move" actually leads to the required "Outcome"), SMO prunes structural errors before the agent even starts executing.
  • Deduplication is the Engine of Efficiency: The massive token savings come from the fact that 232 raw skills were reconstructed using only 95 shared bricks. Once a brick is "loaded" into the agent's context, it doesn't need to be repeated for subsequent skills that use it.
Figure 3: Structural guards before Agent execution. L1 matching blocks incompatible operations, L2 binding blocks slot mismatches, and Outcome-to-State gates block incompatible transitions. The guards prune identifiable structural errors but do not guarantee task success.

Key Results

The results on SkillsBench v1.1 were impressive across the board:

  • Efficiency: Total tokens for the skill library dropped from 366,472 to 149,154 (59.3% reduction).
  • Performance: The average task score rose from 0.6379 to 0.7478. The number of instances where the agent passed 5 out of 5 trials increased from 138 to 164.
  • Runtime Savings: Because the agent has less redundant text to process, average runtime token consumption decreased by 38.38%.
  • Robustness: SMO matched or outperformed the raw text skills on 208 out of 232 test instances.

Limitations and Future Work

While SMO shows great promise, the authors note a few caveats:

  • Not a Silver Bullet: In 24 cases, performance actually regressed, suggesting that the compilation process might occasionally strip away useful nuances present in the original text.
  • Fixed Environment: The study used a specific model (GPT-5.5) and executor. It remains to be seen how well these bricks generalize across different LLM architectures.
  • Amortization: The reported savings exclude the one-time offline cost of compilation. The "profit" of using SMO depends on how frequently the compiled skills are reused.

Future work will focus on testing SMO with more diverse model families and refining the "admission" process for new bricks to ensure the symbolic basis remains high-quality as it grows.

Summary updated

Abstract

Large language model agents increasingly rely on reusable natural-language skills, yet growing skill collections remain accumulations of isolated text artifacts that are difficult to compare, deduplicate, and compose. We argue that the reusable content of a skill lies not in its surface wording but in its procedural transitions: which operation to execute under a given state and which observable outcome to produce. Based on this observation, we propose State-Move-Outcome (SMO), a compilation-like framework that decomposes raw skills into reusable procedural bricks and organizes admitted bricks as an externalized symbolic structure. When compiling a skill, SMO first retrieves and composes existing bricks, dynamically connects them through Outcome-to-State conditions, and creates a candidate brick only for an uncovered procedure; the candidate becomes reusable only after validation and admission. Experiments on SkillsBench v1.1 demonstrate that SMO represents 232 rawSkills from 87 underlying tasks with 95 shared bricks, reducing the corresponding skill representations from 366,472 to 149,154 tokens--a $\mathbf{59.3}\times$ reduction and $\mathbf{2.46}\times$ compression. Across 232 skill-conditioned evaluation instances, SMO raises the average task score from $\mathbf{0.6379}$ to $\mathbf{0.7478}$ and increases 5/5 Pass instances from $\mathbf{138}$ to $\mathbf{164}$, while matching or outperforming rawSkill on $\mathbf{208}$ of $\mathbf{232}$ instances. It also reduces average runtime token consumption by $\mathbf{38.38\%}$. These results show that compiling natural-language skills into shared procedural units can jointly improve skill reuse, representation efficiency, and downstream execution.
BibTeX
@misc{chen2026smo,
  author = {Chao Chen and Jiashuo Zhang and Yunhang Shen and Liangyu Lian and Rongrong Ji},
  title = {{SMO: Compiling Natural Language Skills into Graphs of Reusable State-Move-Outcome Bricks}},
  year = {2026},
  eprint = {2611.12041},
  archivePrefix = {arXiv},
  url = {https://arxiv.org/abs/2611.12041},
}
Figure