{"id":"630ec851-523c-4a81-adb2-6aa294b95a6f","arxiv_id":"2607.22529","paper_version":1,"verdict":"CONDITIONAL","confidence":"MODERATE","novelty_score":6.0,"correctness_risk":"medium","formal_verification":"none","parameter_count":7,"one_line_summary":"Skill Self-Play uses an evolving skill library to guide LLM self-training, improving tool-call and reasoning accuracy beyond unguided self-play on five model backbones.","lead":"The paper introduces a training method that lets a language model generate its own practice tasks, check its own answers, and package successful problem-solving patterns into reusable 'skills' it keeps improving. This skill-based self-play consistently beats simpler self-training on tool-calling and logic-puzzle benchmarks, and it can rescue models that initially perform poorly.","discovery_kind":"new_method","skeptic_critique":{"model":"deepseek-v4-flash","headline":"Self-consistency validity gate may certify wrong tool calls, undermining curriculum fidelity","rationale":"The reader identified the same load-bearing weakness (probe consistency as a circular validity proxy). I agree this is the most important concern to address, because the paper's methodological novelty is precisely a verification mechanism that claims to reconcile diversity and reliability. If the gate is unsound, the entire curriculum is built on self-confirmation, and the empirical gains become difficult to interpret—even if they are measured on held-out benchmarks. The concern is concrete: proposer and solver share initialization and training history, so the majority answer provides no independent signal of correctness. The paper does not provide false-acceptance statistics, external verification, or failure case analysis, so the gate's reliability is unsupported. This does not mean the paper should be rejected; the held-out gains are real measurements and the logical-reasoning results use a deterministic checker. But conditional acceptance is appropriate: the authors should either provide evidence that the gate has low false-acceptance or show that the main results are robust when the gate is replaced by a stronger verifier. Other concerns (single-seed runs, missing baselines) are secondary and do not change the core issue as directly. I keep the verdict as CONDITIONAL, consistent with the reader's assessment.","tokens_in":29234,"tokens_out":4678,"duration_ms":54697,"concrete_test":"Sample 200 accepted tool-call tasks per iteration from a Qwen3-4B-Instruct Skill-SP run. Have an external oracle (strong LLM or human annotator) independently verify whether the proposer-defined reference tool call is correct for the dialogue and whether the solver's majority answer matches the 'correct' call. Compute the false acceptance rate: tasks that pass the probe-consistency gate but have an incorrect reference. If the false acceptance rate exceeds 5%, the gate is allowing systematic bias into the curriculum; if it is below 1%, the concern is largely mitigated. Additionally, compare final held-out API-Bank/BFCL accuracy for a variant that replaces probe consistency with external verification, if feasible.","verdict_should_be":"UNCHANGED","load_bearing_attack":"The central claim is that Skill-SP's co-evolving skill loop yields held-out gains over unguided self-play. The mechanism's fidelity rests on Eq. 4's 'probe consistent' condition, which accepts a generated task when K rollouts of the current solver produce a unique majority answer matching the proposer-defined reference. Because the proposer and solver start from the same checkpoint and are trained in the same loop, systematic model-wide biases can make the solver confidently agree with an incorrect reference. The filter then certifies such tasks as valid, and the solver is trained to reproduce the same wrong call. This circular validation is not checked against any external oracle, and the paper reports no failure analysis of the gate (e.g., false acceptance rates, disagreement with human or stronger-model verification). If this happens at scale, the 'verified' curriculum is polluted; the reported held-out improvements might then reflect the model learning to make consistent-but-wrong tool calls that happen to transfer to benchmark schemas, rather than genuinely correct tool use. The logical-reasoning domain uses a deterministic checker and is less exposed, but tool-calling results—including the headline +42.9 point turnaround—depend on this self-referential gate. Since the central claim is about robust, generalizable capability gains, an unsound validity filter would undercut the interpretation of every reported improvement.","agreement_with_reader":"agree"},"referee_report":{"model":"deepseek-v4-flash","summary":"The paper proposes Skill Self-Play (Skill-SP), a self-evolution framework with three components: a proposer that generates tasks, a solver that learns to solve them, and a controller that maintains an evolving library of skill packages. The skill library guides task generation via routing and provides structural validators, while the proposer is trained to target the solver's learning frontier and the solver is trained on a mixed curriculum of skill-guided and open-ended tasks. The framework is evaluated on tool-call prediction (API-Bank, four BFCL categories) and logical reasoning (ZebraLogic) across five open-source backbones. The reported results show consistent gains over the base models and over an 'Unguided SP' baseline, with especially large gains on initially weak Ministral models. Ablations on Qwen3-4B-Instruct decompose the contributions of skill routing, skill evolution, and co-evolutionary updates. Diagnostics report that skill-routed tasks are near the solver's frontier, that the task pool is diverse, and that the skill library grows over iterations.","tokens_in":29607,"tokens_out":3535,"duration_ms":42166,"significance":"If the reported effects are robust, Skill-SP is a meaningful advance: it offers a concrete mechanism for combining structured verification with open-ended task diversity, and it demonstrates large turnaround effects on initially misaligned models. The paper includes detailed package-level case studies, a deterministic logical-reasoning checker, and a public code release, which are strengths for reproducibility. The work is also relevant to the growing literature on self-evolving LLMs. However, the empirical case is currently incomplete: all reported numbers come from single training runs, ablations use one backbone, the BFCL evaluation covers a selected subset of categories, and the main comparison is only to an in-house 'Unguided SP' baseline rather than to existing self-evolution methods. The circularity of the frontier-proximity diagnostic and the lack of failure analysis for the self-consistency validity gate are additional concerns. These issues do not invalidate the central idea, but they need to be addressed before the strength of the paper's claims can be fully assessed.","major_comments":[{"comment":"The 'probe consistent' validity gate is load-bearing for the tool-calling results, yet it is never checked against an external oracle. Accepting a task when K rollouts of the current solver agree with the proposer-defined reference can certify systematically wrong tool calls whenever the proposer and solver share the same model-wide biases. The paper reports no false-acceptance rate, no comparison against a stronger or independent verifier, and no analysis of the failure modes of this gate. Since the headline +42.9-point Ministral-3-8B gain (Table 1) is driven by this self-referential filter, the manuscript should provide at least a sampled audit (e.g., external judge or deterministic schema/argument checks) and report disagreement rates between the probe-consistency verdict and an independent oracle.","section":"§3.2, Eq. (4); Appendix C"},{"comment":"The 'frontier proximity' diagnostic (mean v_solve ≈ 0.57 for the skill stream) is partly an artifact of the method. Appendix C states that candidates are retained only when v_solve ∈ [0.25, 0.75], and Eq. (2) rewards v_solve near 0.5. A mean of 0.57 is therefore close to what the filter itself enforces, not independent evidence that the skill library anchors tasks at the frontier. To make the diagnostic meaningful, report the pre-filter v_solve distribution, acceptance rates, and a comparison against tasks sampled uniformly from the filtering interval. This does not undo the benchmark gains, but it removes a currently circular piece of evidence.","section":"§4.4, Fig. 5a; Appendix C"},{"comment":"All reported results are single training runs without confidence intervals, significance tests, or multiple seeds. Many of the claimed gains are small (e.g., +0.8 on BFCL for Qwen3-8B, +0.5 on Java for Granite-4.1-3B in Table 1), and the ablations are performed on only one backbone (Qwen3-4B-Instruct). Given the paper's central claim that Skill-SP 'consistently' pushes the performance ceiling, the absence of variance information is a substantive gap. At minimum, repeat the main comparisons and ablations with 2–3 seeds and report means and standard errors, or justify why single-run results are conclusive for the stated effect sizes.","section":"§4.2, Tables 1–2; §4.3, Tables 3–4"},{"comment":"The evaluation scope weakens the external-validity claim. BFCL is represented by only four of its categories (simple_javascript, simple_python, simple_java, and live_simple), and no full-BFCL or other held-out tool-calling benchmark is reported. More importantly, the only self-evolution baseline is the in-house 'Unguided SP', and it is absent from the reasoning domain because it fails to bootstrap. This makes it hard to judge how Skill-SP compares with existing self-evolution methods (e.g., self-play fine-tuning, SPIN-style methods, or other skill-based self-evolution pipelines). The paper should either add a stronger published baseline or explicitly position the contribution as 'skill-guidance over unguided self-play' and temper the general 'robust evolution engine' claim accordingly.","section":"§4.1; §4.2; Appendix G"}],"minor_comments":[{"comment":"Phrases like 'fundamental paradigm shift' and 'truly open-ended frontier' overstate the evidence. The paper itself (Appendix H) acknowledges fixed heuristics and minimal-capability requirements, so the conclusion should be more guarded.","section":"Abstract and §5"},{"comment":"The diversity diagnostic uses PCA visualization but no quantitative measure of coverage. Reporting a quantitative diversity score (e.g., average pairwise distance or coverage in embedding space) would make the claim easier to verify.","section":"§4.4, Fig. 5b"},{"comment":"The 'Frozen skills' variant is described as holding the initial library fixed, but the terminology could be confused with frozen solver/proposer variants in Table 4. Consider renaming to 'Static skill library' for clarity.","section":"Table 3, 'Frozen skills'"},{"comment":"The limitation statement that the curriculum blending ratio α and difficulty bounds 'may require empirical tuning for new task families' is important. It should be surfaced in the main paper, not only in a supplementary appendix, because it directly qualifies the 'autonomous' claim.","section":"Appendix H"},{"comment":"The choice of four BFCL categories should be justified in the main text. BFCL has many categories; selective reporting could inflate or deflate average gains depending on which categories are hardest for the base models.","section":"§4.1, BFCL subset"}],"recommendation":"major_revision","confidential_remarks":"The core idea is interesting and the paper is generally well structured, but the empirical support is not yet at the level required for the strength of the claims. The validity-gate audit and multi-seed results are the most important additions. The paper also leans heavily on self-citations and recent arXiv references; this is not a reason to reject, but the authors should ensure that the related-work comparison includes established self-evolution baselines from peer-reviewed venues or widely used open-source methods."},"author_rebuttal":null,"desk_editor":{"model":"deepseek-v4-flash","letter":"The method is real, and so is the caveat. Skill-SP's tool-call gains look good across five backbones, but the validity gate that certifies training tasks is built on the solver's own self-consistency, and the paper doesn't stress-test it. Treat the +42.9 point turnaround as provisional until we see a failure analysis of that gate.\n\nWhat's genuinely new: the evolving skill library as the controller of a self-play curriculum. Skills are not just inference-time context; they route the proposer, gate validity, and steer difficulty. That's a real combination, not routine X-applied-to-Y. The paper is also honest and thorough in the appendices: full pseudocode, training details, case studies of induced skills, and a limitations section that concedes the need for a minimum capability threshold and fixed heuristics. The gains are consistent across five backbones, which gives some confidence despite single seeds.\n\nThe soft spots are real but not all equal. The biggest is the validity gate. For tool calling, a task is 'valid' only if K rollouts of the current solver produce a unique majority answer matching the proposer-written reference. Since proposer and solver start from the same checkpoint and train in the same loop, the gate can certify tasks where the model is confidently wrong. The paper reports no false-acceptance rate, no disagreement with an external oracle, no failure analysis. That matters because the headline gain is on tool use. The concern is not fatal—logical reasoning uses a deterministic checker, and the held-out benchmark gains suggest the learned calls are not arbitrary consistent hallucinations—but the gap is real.\n\nSecond, all results are single runs with no confidence intervals. Third, the only baseline is unguided self-play; there's no comparison to R-Zero, SPIRAL, or other self-evolution methods. Fourth, the BFCL subset is selected (four of many categories). And the 'frontier proximity' diagnostic (mean vsolve≈0.57) is partly by construction, since the reward and the [0.25,0.75] filter explicitly select near-0.5 difficulty.\n\nOne correction to the review notes: the paper says the code is available. I can't verify the link, but it's not fair to say no code shipped.\n\nOverall: this is a serious paper with a real mechanism, and it deserves peer review. The authors need to add multiple seeds, a failure analysis of the probe-consistency gate, comparisons to prior self-evolution methods, and full BFCL. With those, the tool-call claims would be much stronger. I'd send it to review.","headline":"A real co-evolutionary mechanism with consistent gains, but the tool-call validity gate is self-referential and needs failure analysis before the headline numbers are trusted.","tokens_in":30094,"tokens_out":3995,"would_cite":true,"duration_ms":41241,"reading_group":"maybe","serious_thinker":"yes","would_accept_peer_review":true},"rs_alignment":null,"lean_confirmation":null,"pith_extraction":{"msc":[],"pacs":[],"model":"deepseek-v4-flash","headline":"Skill-SP claims that an evolving library of modular skills lets LLM self-play generate diverse, verifiable tasks, outperforming unguided self-play on tool use and reasoning.","keywords":["self-play","skill library","LLM self-evolution","curriculum learning","tool calling","logical reasoning","reinforcement learning","synthetic data verification"],"falsifier":"Take K=10 probe rollouts from a random sample of accepted Skill-SP tasks and compare the majority answer to an independent oracle (human-verified reference or deterministic solver). If more than ~5% of certified references are wrong, the filter is validating model self-consistency, not task correctness.","tokens_in":29166,"feed_emoji":"🧩","tokens_out":6923,"duration_ms":67025,"temperature":0.7,"pith_summary":"The paper addresses a known tension in LLM self-evolution: tasks verified by fixed environments are reliable but narrow, while open-ended task generation is broad but noisy, and passive filtering lets errors accumulate. Its proposal, Skill-SP, makes the skill—a reusable package of generation rules, examples, and executable validators—the unit that steers the whole loop. A proposer writes tasks conditioned on sampled skills, a solver trains on tasks at its current difficulty frontier, and a controller refines, prunes, and induces skills from execution feedback. On tool calling and logical reasoning across five open-weight backbones, the loop is reported to beat unguided self-play, with gains up to +42.9 points on tool use and +12.0 on reasoning, including turnarounds for models that initially could not produce valid tasks at all. The upshot: verifiable, open-ended self-improvement may be achievable without an external environment or a stronger teacher.","feed_headline":"Co-evolving skills lift LLM self-play by up to 42.9 points","feed_subtitle":"Skill-guided task generation keeps open-ended variety while keeping verification strict—unguided self-play stalls.","key_machinery":"The load-bearing object is the skill package s=⟨m,r,h,e,ν,σ⟩, a modular, machine-readable bundle of routing metadata, procedural rules, hints, few-shot examples, executable validators, and historical statistics. It does three jobs at once: injecting structural priors before the proposer writes a task, providing executable checks after the solver responds, and tracking difficulty so the controller can reroute, refine, prune, or induce skills. Around it, the loop is driven by a gated frontier reward—validity mask times a medium-difficulty score—and a bi-level update: the proposer maximizes that reward against the current solver, the solver maximizes environment reward on the top-ranked accepte","core_discovery":"Skill-SP's central claim is that a skill library can act as a proactive task-pattern interface, not a passive post-hoc filter. Each skill bundles routing metadata, procedural rules, generation hints, few-shot examples, executable validators, and usage statistics; the proposer samples skills to generate candidate tasks, complements them with an unguided exploration stream, and only tasks passing schema, contract, and probe-consistency checks enter the solver's frontier-ranked curriculum. The controller then evolves the library—refining packages from failure traces, pruning saturated ones, and inducing new ones from successful open-ended exploration. The reported consequence is that skill-rout","pith_inferences":["A testable extension: audit the probe-consistency gate against an external oracle. If a substantial share of accepted tasks have the wrong reference answer, the gate is certifying model bias, and the reported benchmark gains would shrink out-of-distribution.","Because the initial library is shared across all backbones and most of the gain comes from online evolution, transferring an evolved library from a strong model to a weak one could bootstrap models that cannot currently generate valid puzzles; the paper's limitations section points in this direction.","The dual-stream design suggests a general engineering recipe: keep an exploration stream always running and absorb its successes into the skill library; this is a cheap way to keep any self-play loop from mode-collapsing, independent of the specific reward.","One could quantify the marginal value of each newly induced skill by deleting it from the library and measuring the change in accepted task diversity and accuracy; the paper reports package counts but not per-skill attribution."],"forward_implications":["If the reported gains hold, self-improvement no longer needs a fixed environment: any domain with a machine-readable verification contract (tool schemas, constraint solvers) can be organized as an evolving skill library.","Competent backbones gain steadily (roughly +2.8 to +6.5 points on tool use, +1.0 to +12.0 on reasoning), while initially misaligned models can jump tens of points on tool use, because skills give them a way to synthesize valid tasks at all.","The ablation pattern implies that both the co-evolution of proposer and solver and the dynamic updating of skills are necessary; freezing any one component costs 2–3 points, and static skills barely beat unguided self-play.","Curriculum quality improves along two measurable axes at once: tasks stay near the frontier (mean solver success near 0.57) and the pool spreads out in embedding space, whereas unguided self-play collapses to narrow regions and cannot bootstrap logical puzzle generation.","The same recipe should extend to code generation, planning, and other contract-verifiable tasks, because the skill package only assumes a task can be represented as a prompt plus a hidden machine-checkable contract."],"fun_headline_variants":["Skill-SP: co-evolving skills boost LLM self-play","Skill self-play: verifiable open-ended LLM training","Co-evolving skills lift LLM self-play by 42.9 pts","Skill-guided self-play pushes LLM capability frontier","Skill-SP: bridging verification and exploration in self-play"],"cache_read_input_tokens":2304,"weakest_assumption_plain":"The load-bearing premise is that a task is 'valid' when K rollouts of the current solver give a unique majority answer matching the proposer's reference; if the model shares systematic biases, all K rollouts can confidently reproduce the same wrong answer and the filter will certify it as valid.","fun_headline_variants_meta":{"raw":{"variants":["Skill-SP: co-evolving skills boost LLM self-play","Skill self-play: verifiable open-ended LLM training","Co-evolving skills lift LLM self-play by 42.9 pts","Skill-guided self-play pushes LLM capability frontier","Skill-SP: bridging verification and exploration in self-play"]},"model":"deepseek-v4-flash","effort":"low","cost_usd":0.00047,"raw_usage":{"total_tokens":2194,"prompt_tokens":781,"completion_tokens":1413,"prompt_tokens_details":{"cached_tokens":256},"prompt_cache_hit_tokens":256,"prompt_cache_miss_tokens":525,"completion_tokens_details":{"reasoning_tokens":1330}},"tokens_in":525,"tokens_out":1413,"duration_ms":11271,"temperature":1.0,"reasoning_tokens":1330,"cache_read_input_tokens":256,"cache_creation_input_tokens":0},"cache_creation_input_tokens":0},"created_at":"2026-08-01T04:24:22.814977+00:00","model_set":{"reader":"deepseek-v4-flash"},"falsifier":"Take K=10 probe rollouts from a random sample of accepted Skill-SP tasks and compare the majority answer to an independent oracle (human-verified reference or deterministic solver). If more than ~5% of certified references are wrong, the filter is validating model self-consistency, not task correctness.","supporting_citations":[],"review_version":1}