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:
- Redundancy: Different authors might describe the exact same operation using different prose, forcing the agent to re-interpret the same logic repeatedly.
- Entanglement: Reusable logic is often mixed with task-specific data (like specific file paths or names), making it hard to extract the "core" procedure.
- 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.
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.
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.
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