Ctx2Skill: Transforming Raw Context into Expert Skills via Self-Evolving Self-Play
From Context to Skills: Can Language Models Learn from Context Skillfully?
Ctx2Skill is a self-evolving framework designed to enhance Language Models' (LMs) context learning capabilities by autonomously discovering and refining context-specific skills. It achieves state-of-the-art results on the CL-bench, improving GPT-4.1's solving rate from 11.1% to 16.5% and GPT-5.1's from 21.2% to 25.8% without human supervision or parameter updates.
TL;DR
Researchers from THU, UIUC, and DeepLang AI have introduced Ctx2Skill, a framework that allows Language Models to "teach themselves" how to handle complex, unseen documents. By pitting two agents against each other—one creating tests and the other solving them—the system extracts high-quality, reusable procedural "skills" that can be plugged into any LLM. It improves solving rates on complex reasoning tasks by up to 48% relative to base models.
Context Learning: The Final Frontier of "Zero-Shot"
While modern LLMs like GPT-4 or Gemini are world-class at general knowledge, they often stumble when dropped into a 50-page technical manual or a niche legal document they haven't seen during training. This is Context Learning.
The prevailing solution has been "Skill Augmentation"—extracting rules from the text into a Markdown "cheat sheet." However, two walls stood in the way:
- Cognitive Load: Humans can't feasibly annotate every specialized document.
- Feedback Vacuum: Unlike coding, where a compiler tells you if you're wrong, who tells an AI if its "legal reasoning skill" extracted from a PDF is actually correct?
The Core Insight: Adversarial Evolution
Ctx2Skill bypasses the need for human feedback by creating a closed-loop economy of knowledge. It uses a 5-agent architecture to simulate a "classroom" where the curriculum and the student evolve simultaneously.
1. The Multi-Agent Loop
- The Challenger: Acts as the professor, generating tasks and rubrics based on the document.
- The Reasoner: The student trying to solve tasks using its current "Skill Set."
- The Judge: A neutral evaluator checking the Reasoner’s work against the rubrics.
- Proposer & Generator: The "tutors" that analyze failures and rewrite the skills for both sides.
2. Solving "Adversarial Collapse"
A common pitfall in self-play is that the Challenger eventually creates "impossible" or extremely niche trick questions. The Reasoner then learns "weird" skills to solve only those tricks, losing its grip on the general document knowledge.
Ctx2Skill introduces Cross-Time Replay. It saves "Probes" (representative easy and hard tasks) from every iteration. After the loop ends, it tests every version of the skill set against all saved probes and picks the one with the best balance (using a multiplicative Laplace-smoothed score).
Methodology: The Self-Play Dynamics
The system doesn't just restate facts; it synthesizes procedural knowledge. For example, in a D&D rule-following task, it doesn't just say "Healers heal." It refines a skill called constraint-extraction-and-strict-verification, which teaches the model how to cross-reference character HP with movement ranges before acting.
Performance: Bridging the Gap
The results on CL-bench (a benchmark for domain knowledge, rule systems, and simulations) are striking. Ctx2Skill doesn't just help the model it was built with; the skills are transferable. Skills generated by GPT-5.1 significantly boosted GPT-4.1, proving that the knowledge is model-agnostic.
| Model | Base Rate | With Ctx2Skill | Improvement |
|---|---|---|---|
| GPT-4.1 | 11.1% | 16.5% | +5.4% |
| GPT-5.1 | 21.1% | 25.8% | +4.7% |
| GPT-5.2 | 18.2% | 21.4% | +3.2% |
Deep Insights: Why Earlier is Often Better
One of the most interesting findings (shown in the figure below) is that the framework often chooses skills from Iteration 1 or 2. This confirms that "more reasoning" isn't always better—the Cross-Time Replay is essential to catch the sweet spot of generalization before the agents descend into over-specialized "logic games."
Critical Analysis & Conclusion
Ctx2Skill proves that we don't always need more "parameters" or "pre-training" to solve domain-specific problems. Sometimes, we just need a better way to organize the information we already have.
Limitations: The framework is computationally expensive (running 5 iterations with multiple agents). However, since these skills are generated once per document and can be reused for every subsequent query, the cost is amortized over time.
The Takeaway: For enterprises dealing with massive, proprietary document silos, Ctx2Skill offers a path to build "Expert Agents" that can truly master local context without the risks of hallucination or the costs of manual fine-tuning.