Skill evolution 88 papers

MCE reframes context engineering as a two-level search rather than a fixed pipeline. Instead of hand-designing the harness that decides how context gets built — the generation-reflection-curation loops and itemized-list schemas behind methods like ACE, or the brevity-biased prompt rewrites behind GEPA — a meta-level agent evolves the harness itself: executable "skills" that combine natural-language methodology, scripts, and validation logic. It refines these through agentic crossover , a deliberative reasoning pass over the full history of prior skills, their executions, and validation scores, rather than a fixed recombination rule. A separate base-level agent then executes whatever skill the meta-agent hands it, reading training rollouts and writing the actual context as files and code instead of filling in a predefined schema. The two levels co-evolve under a simple (1+1) evolution strategy, tested across five unrelated domains: XBRL entity tagging (FiNER), retrosynthesis prediction (USPTO-50k), symptom-to-disease classification, Chinese criminal-charge prediction (LawBench), and prompt-safety classification (AEGIS2). DeepSeek-V3.1 is the model under test (Qwen3-8B for the safety task), MiniMax M2.1 does the evolving, and the field it's measured against includes ICL, MIPROv2, GEPA, Dynamic Cheatsheet, and Agentic Context Engineering (ACE) .

Evolving Programmatic Skill Networks builds agent skills as executable, typed programs — not prompts or embeddings — arranged in a directed graph that keeps growing and rewriting itself as the agent acts. The framework, called the Programmatic Skill Network (PSN) , grows through two linked mechanisms. Day to day, Reflect traces a failed run backward through the skill graph to pin down which specific subskill broke — a symbolic stand-in for backpropagation — and a maturity-aware update gate throttles how often a skill gets rewritten based on its track record, so reliable skills stop churning while shaky ones stay open to revision. Periodically, a refactoring pass collapses redundant or overlapping skills into one of five canonical patterns — parametric coverage, behavioral coverage, sibling specialization, common-subskill extraction, and duplication — with every rewrite gated behind a rollback check against recent tasks. Both mechanisms are evaluated on the MineDojo Minecraft tech-tree benchmark and on Crafter.

SAGE trains an LLM agent to build and reuse a library of executable skills by extending GRPO (Group Relative Policy Optimization) with two additions. Sequential Rollout chains two similar tasks from the same scenario into a single rollout, so skills the agent writes while solving the first task are still sitting in its skill library when it tackles the second — letting the reward signal from successful reuse flow back to the skill-writing step. A Skill-integrated Reward then stacks bonus credit on top of the normal pass/fail outcome reward — one bonus when a generated skill actually gets used by the next task, another when a task successfully reuses an earlier one. The agent writes in a DynaSaur -style unified format — a callable function it writes and immediately invokes, rather than calling raw APIs directly — so skill creation and task-solving happen in the same step, not as a separate post-hoc phase.

MLLM-based GUI agents that plan step-by-step from screenshots run out of usable knowledge once a task stretches across many steps and several apps. The fix: a Hierarchical Multimodal Skills (HMS) module that abstracts recorded trajectories into three tiers — execution skills (a literal recorded action sequence for one concrete goal), core skills (a parameterized function distilled from several similar execution skills), and meta skills (a further roll-up of core skills into a broad, reusable capability). Paired with HMS is Skill-Augmented Monte Carlo Tree Search (SA-MCTS), which uses the offline-learned hierarchy to prune the action space an online tree search has to explore, then writes newly discovered successful trajectories back into HMS so the library keeps growing after deployment instead of freezing at training time.

This framework skips runtime code generation entirely: it pre-builds and validates a library of Adobe Illustrator scripts offline, then serves them by lookup instead of writing ExtendScript on the fly. Task ideas come from two directions. A top-down pass walks documented software functionality -- drawing, arranging objects, and so on. A bottom-up pass mines an API synergy graph -- built from which Illustrator APIs actually co-occur in working scripts -- using GNN link-prediction to propose tasks for API pairs the system has never seen paired before. Each candidate then runs through skill generation with trials: an LLM writes a script, an LVLM validator checks both the execution output and the resulting canvas state, and the LLM gets up to three offline attempts to fix what broke -- all before any end user asks for it.

SkillWeaver turns a web agent loose on a new site and runs a tight loop: the agent discovers candidate skills, executes them repeatedly for practice, then distills the successful attempts into small, callable API functions instead of raw click-by-click logs. Later rounds draw on that growing skill library , so the agent composes earlier APIs into more complex ones rather than relearning a site from scratch every time.

Agent skill induction ( ASI ) lets a web-browsing agent mine its own successful task runs for reusable Python functions, instead of jotting down prose notes. Once a task finishes, the agent drafts candidate skill functions — say, a search_product(name) that chains together clicks and form fills — then rewrites the original trajectory to call those functions as a prefix and lets itself finish the task from there. A skill only earns a permanent slot in the agent's action space once that run clears three checks against the live environment: an LLM evaluator confirms the task was actually solved, the run actually invoked the new skill, and the skill's calls actually changed something on the page, not just executed without error. The setup is tested on WebArena (812 tasks spanning shopping, forums, dev tooling, content management, and travel/maps), with Claude 3.5 Sonnet running the agent, the evaluator, and the induction step itself, against a static non-adaptive baseline and against AWM , a prior method that induces the same kind of workflow knowledge but keeps it as free-text notes in memory instead of executable code.

Voyager pairs GPT-4 with three components instead of one clever prompt. An automatic curriculum proposes the next Minecraft objective by reading the agent's live state against its history of completed and failed tasks. A skill library stores the results as executable JavaScript functions, indexed by embeddings of their own descriptions and pulled back out via nearest-neighbor lookup. Before anything is committed to that library, an iterative prompting mechanism folds in game feedback and interpreter errors, and a dedicated self-verification critic judges whether the skill actually worked. None of this involves fine-tuning: GPT-4 (gpt-4-0314) is queried as a black box for curriculum, code generation, and verification; GPT-3.5 handles cheaper auxiliary text; embeddings come from text-embedding-ada-002.