COBRA-Skills cuts agent skill tuning costs by 55-58% on 50 examples

Teaching a language model agent a reusable skill means distilling a procedure from tasks it has already run, so it does not have to reason through the same problem twice. The hard part is the distillation. Most existing methods grade candidate skills by executing them, one task after another, and that execution is where the cost piles up. The more candidates a method wants to test, the more task data and compute it burns. Some groups have tried to dodge that bill by compressing skills without running them at all, the evaluation-free route SkillZip takes.

COBRA-Skills, described in an arXiv preprint submitted on 10 September 2026, treats that job as a budgeted sequential problem over a candidate space that shifts as the agent learns. The framework combines two mechanisms the abstract calls contextual-bandit-guided prioritization and evidence-grounded skill evolution. The first decides which candidate skills earn a slot in the evaluation queue. The second refines the survivors from the feedback of the runs that actually executed.

The bandit that decides what to test

A contextual bandit is a standard tool for choosing among options when feedback arrives one decision at a time and the goal is to spend a limited budget well, the same logic behind CoBa's compute-balanced routing. Pointed at skill candidates, it lets the method steer evaluations toward options flagged as promising or informative instead of grading every candidate in the pool. Because the candidate space evolves, the rankings get reseeded as the population improves rather than staying fixed at the start.

That design is the paper's answer to the cost problem. Execution-based evaluation stays in place, because a skill is only trustworthy if it has actually run. The leverage sits in cutting how many executions the method needs.

What six benchmarks and three models show

The authors report two headline results. Across six heterogeneous agent benchmarks and three target models, COBRA-Skills posts the strongest average performance among the methods it was compared against. On cost, it reduces optimization spend by 55 to 58 percent relative to a method called SkillOpt, while drawing on only 50 unique optimization examples per benchmark.

Measure	Reported figure
Average performance	Strongest among compared methods
Optimization cost vs. SkillOpt	55-58% lower
Unique optimization examples per benchmark	50
Agent benchmarks evaluated	6
Target models	3

Two secondary findings come with the numbers. The method stays robust when the agent harness changes, and it still works when the target model generates and refines skills itself. That second result is the useful one: the setup does not need a separate, stronger model sitting in the refinement loop.

What the abstract leaves out

An abstract is not a results section, and several things a skeptical reader would want are missing. There is no per-benchmark breakdown and no list naming the three target models. The abstract also gives no absolute cost figure, only the relative reduction against SkillOpt. The phrase "strongest average performance among compared methods" is bounded by whichever methods the authors picked, and beyond SkillOpt it does not say which ones those were.

The paper arrives as a preprint rather than a peer-reviewed publication, so no independent group has reproduced the figures. That gap matters more than usual here, because the cost reduction is stated as a range against a single named baseline, and the performance claim is relative rather than absolute. It is the same falsifiability problem that hangs over unverified claims about agent memory.

The efficiency figure is the part with reach past the paper. Skill optimization has carried a high enough price that reusing one skill set across tasks is often the practical choice. A method that trims that price by more than half, and asks for 50 examples rather than a large task corpus, changes how that trade-off looks. Cost, not raw capability, is where a lot of these experiments are being decided now, the lesson from Cursor's swarm rebuilding SQLite on the same scores and a smaller bill.

For now the honest reading stays narrow. COBRA-Skills proposes a cheaper way to search for agent skills by letting a bandit decide what gets tested, and the motivation is easy to see: loading an agent with skills can backfire, since added procedural skills sometimes trigger regressions. The efficiency numbers, though, are the authors' own, and they stay the authors' own until someone outside the group runs the comparison.