{"id":"1ac4a9b3-dd07-45df-a87f-d0b927f83424","arxiv_id":"2608.01904","paper_version":1,"verdict":"CONDITIONAL","confidence":"MODERATE","novelty_score":6.0,"correctness_risk":"medium","formal_verification":"none","parameter_count":6,"one_line_summary":"A training loop where a knowledge graph supplies QA tasks, rewards evidence-backed search paths, and stores successful trajectories for reuse lifts macro QA accuracy by 2.6 to 3.7 points over self-play baselines.","lead":"CoEvoKG trains a question generator and a search agent together so that every successful search adds verified evidence back into a shared knowledge graph. That enriched graph then produces harder tasks and denser proof paths, closing the loop the paper says existing self-play agents leave open.","discovery_kind":"new_method","skeptic_critique":{"model":"deepseek-v4-flash","headline":"Self-confirming path-support gate: write-back is scored against the same graph it mutates, so the loop's only direct contribution (+0.6) may be an artifact.","rationale":"The paper's distinctive central claim is that verified trajectories written back into the KG create a self-evolving loop. The reader's weakest assumption already targeted Spath calibration; I agree and sharpen the mechanism: the scorer and the memory are the same object, so the 'verified' in verified graph memory is not externally anchored. This is not a fatal flaw—the paper reports the +0.6 effect and its sign test, discloses the seed fallback, and evaluates on external benchmarks, so the accuracy data are not fabricated or circular. But the +0.6 is both the smallest contribution and the one most vulnerable to self-confirmation; if it does not survive the provenance-stripped test, the title mechanism is unsupported, even though KG-based task generation and reward shaping might still justify most of the gains. That is exactly a conditional-accept situation: the main empirical result is plausible, but the mechanism need not be accepted until the gate's independence is demonstrated. I therefore keep the reader's CONDITIONAL verdict unchanged.","tokens_in":12908,"tokens_out":9644,"duration_ms":117982,"concrete_test":"Tag every evidence passage added by write-back with provenance. For a random sample of correct trajectories from early/late rounds, recompute Spath twice: (a) against live G_t, and (b) against G_t stripped of all self-contributed evidence (only original Wikipedia passages). If (a)−(b) grows across rounds, the gate is self-confirming. Then rerun the Table 2 build-up with both the solver reward (Eq. 7) and the write-back gate computed on the stripped graph; if the C3 gain (+0.6, p=0.0314) collapses or reverses, the co-evolution loop's measured contribution is an artifact of self-confirmation rather than evidence of a genuinely co-evolving memory.","verdict_should_be":"UNCHANGED","load_bearing_attack":"The load-bearing risk is that the component that actually closes the co-evolution loop—verified graph memory (Sec. 3.4)—uses a verification signal that is not independent of the loop. M(u,v) in Sec. 3.3 is computed deterministically from 'records mentioning both entities' in the current graph G_t; the same G_t is then advanced to G_{t+1} by writing back the solver's own correct and 'supported' trajectories. Consequently, once a correct trajectory adds evidence for an entity pair, every later trajectory over that pair gets a higher M, making the gate Spath ≥ τ_path and the process reward (Eq. 7) easier to satisfy. This is a self-confirmation loop: the solver is rewarded for re-finding connections that its own earlier successes established. The stakes are visible in Table 2: write-back (C3) adds only +0.6 macro points over C2, and this is the exact term most exposed to the bias. The 25–40% human-seed fallback (Sec. 3.2) is a separate confound for C1/C2, but it does not provide an independent check of Spath. Section 3.3's concession that 'any calibrated scorer could replace it' makes the absence of a calibration check the central gap.","agreement_with_reader":"agree"},"referee_report":{"model":"deepseek-v4-flash","summary":"CoEvoKG couples a task generator and a search agent through a shared knowledge-graph chain pool. The generator samples multihop entity chains and produces questions filtered by a quality gate; the solver is trained with GRPO on a reward that combines answer correctness with a path-support score computed against the current graph; proposer training uses a difficulty-bell reward on solver success rate. Correct, path-supported solver trajectories are written back into the graph, advancing G_t to G_{t+1}, which is intended to provide a persistent evidence memory and richer future tasks. On six QA benchmarks (NQ, TriviaQA, PopQA, HotpotQA, 2WikiMultiHopQA, Bamboogle) and three backbones, the paper reports macro-average gains of +11.2, +10.1, and +11.6 over base models, and +2.6 to +3.7 over Search-R1 and SSP under a matched budget. A build-up ablation attributes +1.5 to KG task generation (p=0.0011), +1.1 to path/difficulty rewards (p=0.0141), and +0.6 to evidence write-back (p=0.0314).","tokens_in":13197,"tokens_out":5498,"duration_ms":66109,"significance":"If the co-evolution loop is real, this is a useful and practical contribution: it shows that self-play search agents can be stabilized by treating the knowledge graph not only as a task source but also as a persistent, evidence-accumulating memory. The paper has several genuine strengths: evaluation on external, human-curated held-out subsets (the SSP release) with greedy decoding; a transparent build-up ablation that reports paired sign tests and openly states that write-back is 'positive but weaker'; a matched training budget across methods; and released code. These design choices make the central claim externally anchored rather than definitionally circular. The main risk is that the verification signal used to gate and reward write-back is computed from the same graph memory that write-back mutates, so the loop's only direct contribution may be partially self-confirming. That concern, together with the unablated seed-fallback mixture, means the manuscript needs additional controls before the co-evolution claim is fully established.","major_comments":[{"comment":"The path-support verification is not independent of the memory it gates. M(u,v) is computed deterministically from records in the current graph G_t, and write-back advances G_t to G_{t+1} using trajectories that passed Spath≥τ_path. Once a correct trajectory adds evidence for an entity pair, later trajectories over the same pair receive a higher M, making the threshold and the Eq. (7) process reward easier to satisfy. This is a self-confirmation loop rather than an external check. The paper concedes in §3.3 that 'any calibrated scorer could replace it' but provides no calibration evidence. This matters because Table 2 attributes only +0.6 macro points (p=0.0314) to write-back, exactly the term most exposed to the bias. Please add an external/oracle verification ablation or calibrate M on a fixed held-out set of trajectory–graph pairs that is frozen before write-back begins.","section":"§3.3–3.4, Eqs. (7)–(9)"},{"comment":"The seed fallback injects human-written verified questions into 25–40% of solver slots, declining over training. The comparison against SSP in Table 1 therefore conflates KG-chain task generation with a human-question curriculum; no ablation controls for seed fraction. Because C1 (KG task generation) is the largest ablation gain (+1.5, p=0.0011), the reader cannot tell how much of the superiority over SSP comes from KG chains versus the presence of 25–40% verified human questions. Please report an ablation that matches the seed mixture across methods (e.g., SSP augmented with the same seed pool, or CoEvoKG without seed fallback) and report the seed fraction per method per round.","section":"§3.2, Fig. 3, Table 2"},{"comment":"The headline matched-budget gains (+2.6 to +3.7 macro points over SSP/Search-R1) are reported without variance, number of seeds, or per-benchmark significance. A single seed and a single checkpoint selection can be noisy; paired sign tests are given only for the Table 2 ablation, not the main results. Please provide at least three seeds (or bootstrapped confidence intervals over the 2,625 held-out examples) for the main table and state the checkpoint-selection variance. This is especially important for Bamboogle, which has only 125 evaluation questions.","section":"Table 1, §4.1"}],"minor_comments":[{"comment":"The symbol G_t is used both for the graph memory at round t and for the discounted return in the REINFORCE++ estimator. Rename the return variable (e.g., R_t or G_return_t) to avoid notation collision.","section":"§3.5, Eq. (12)"},{"comment":"Clarify whether the extracted chain êτ always has the same length L as the original chain c. If the solver path length varies, define the relevant length in Eq. (9) explicitly.","section":"Eqs. (8)–(9)"},{"comment":"The exact values of α, β_text, γ, η, τ_path, the quality-gate retention threshold, the verifier model, and the annealing schedule (p*_s, p*_e, σ) are all deferred to the appendix. Please include these in the supplement or the main text, since they are needed to reproduce the path-support score.","section":"§3.2–3.3, Appendix"},{"comment":"The caption does not specify the vertical axes for the pool-size and seed-fallback-rate panels. Add axis labels and units so the 'grows then plateaus' and 'declines' claims can be read quantitatively.","section":"Fig. 3"},{"comment":"The comparison of mean solver success rates (0.405 vs. 0.410) should state how many rollouts and which checkpoint produced these numbers. A one-line description would make the diagnostic reproducible.","section":"§4.4"}],"recommendation":"major_revision","confidential_remarks":"The paper is interesting and honest about the small write-back effect. The main load-bearing issue is the self-confirming path-support verification; if the authors can provide an external calibration or an oracle-write-back ablation, I would be willing to accept. The seed-fallback confound also needs a controlled comparison. The lack of variance reporting in Table 1 is fixable and should be addressed in revision."},"author_rebuttal":null,"desk_editor":{"model":"deepseek-v4-flash","letter":"CoEvoKG is a real incremental step for self-play search agents, and the new idea actually is new: keeping the knowledge graph in the training loop as both task generator and evidence memory, with verified solver trajectories written back. That closed loop is absent from DeepDive (offline walks, fixed set), SSP (no KG grounding), and your own Cognitive Scaffold (inference-time memory only). The paper also scores points for honesty: the build-up ablation with paired sign tests is the right way to isolate contributions, and evaluation on external SSP held-out subsets with greedy decoding keeps the headline numbers anchored outside the training machinery.\n\nThe soft spots are proportionate. The load-bearing one, as the stress test notes, is the write-back term. Table 2 shows it adds only +0.6 macro points over the C2 configuration (p=0.0314), and the path-support scorer M(u,v) is computed deterministically from the current graph G_t, which then gets mutated by write-back of the solver's own successful paths. That is a real self-confirmation risk: the gate gets easier to satisfy as the loop runs, so the +0.6 could be an artifact. The authors are candid that the scorer is not calibrated—'any calibrated scorer could replace it' (Sec 3.3)—but they don't provide the calibration check, and weights/thresholds are in a deferred appendix.\n\nSecond, Table 1 has no variance or seed count, and Bamboogle's 125-question test set makes its 12-19 point deltas noisy. Third, the 25-40% human-seed fallback is disclosed but not ablated; if those seeds come from the evaluation benchmarks, that's a confound for the comparison with SSP. These are missing evidence, not counter-evidence. The central accuracy claim—+2.6 to +3.7 over matched-budget RL/self-play baselines—stays plausible and is worth testing.\n\nMy recommendation: send it to peer review, not desk reject. Ask the authors for seed-level variance, a real calibration experiment for M, and an ablation where write-back is evaluated with a scorer independent of the mutated graph (or fixed paths). Once that's done, the co-evolution claim can be taken seriously. I'd bring it to reading group and would cite it once the gaps close.","headline":"Genuinely new closed-loop KG self-play, but the write-back term that closes the loop is the weakest-supported part (+0.6 points) and the path-support scorer may be self-confirming; referee it, but ask for calibration and variance.","tokens_in":13769,"tokens_out":3406,"would_cite":true,"duration_ms":37576,"reading_group":"yes","serious_thinker":"yes","would_accept_peer_review":true},"rs_alignment":null,"lean_confirmation":null,"pith_extraction":{"msc":[],"pacs":[],"model":"deepseek-v4-flash","headline":"Closed-loop knowledge graph memory lifts search-agent self-play by about 10 macro points on six QA benchmarks.","keywords":["knowledge graph","self-play","search agents","reinforcement learning","multi-hop QA","evidence memory","LLM agents","task generation"],"falsifier":"Compute M(u,v) on held-out human-annotated entity-pair support labels; if the score does not track human judgments, the process reward is misaligned and CoEvoKG's reported gains could in part come from training to a heuristic rather than to evidence-supported reasoning.","tokens_in":12714,"feed_emoji":"🧠","tokens_out":4459,"duration_ms":44801,"temperature":0.7,"pith_summary":"CoEvoKG claims that a search agent trained by self-play improves most when the knowledge graph is kept inside the training loop: it generates multihop questions from entity chains and receives back verified evidence from successful searches, which enriches the graph that generates future tasks and computes rewards. On six QA benchmarks across three backbones, this closed loop raises macro-average accuracy by about 10–12 points over base models and by 2.6–3.7 points over matched-budget self-play and RL baselines. The central idea is that successful search trajectories should not be discarded; they should be written back into the evidence store that drives the next round of training. If correct, self-play for search agents is best modeled as two coupled processes—task distribution and evidence memory—not as RL against a fixed task pool.","feed_headline":"Closed-loop knowledge graph lifts search agents by ~10 points","feed_subtitle":"The graph both generates multihop questions and stores verified evidence, and self-play keeps improving where fixed-pool training stalls.","key_machinery":"The central mechanism is the evolving chain pool (graph memory): entity chains sampled from a Wikipedia-based knowledge graph, each node an article with its passage and each edge a typed relation label. Three components operate on it in a loop: (1) chain-based task generation, where a proposer turns sampled 2–3 hop chains into questions passing a quality gate; (2) a hybrid solver reward R_s = R_ans(1 + β S_path), where S_path is the geometric mean of a deterministic relation consistency score M(u,v) over adjacent entities in the searched path; and (3) verified evidence write-back, which appends deduplicated retrieved passages from correct, path-supported trajectories back into the originatin","core_discovery":"The paper's central claim is that a knowledge graph can serve simultaneously as a source of verifiable multihop training tasks and as a persistent evidence memory for the agent's own successful searches, and that closing the loop between these two roles is what makes self-play stable and effective. In each round a proposer generates questions from sampled entity chains, a solver answers them with multi-turn search, and any correct trajectory whose entity path is supported by graph evidence is verified, deduplicated, and written back into the graph memory. Later rounds sample from enriched chains and score path support against the enriched graph, so the task distribution and the reward signal","pith_inferences":["The paper's own ablation isolates write-back as a small (+0.6 point) contribution; extrapolating, the framework's gains may be mostly from chain-grounded task generation and path/difficulty rewards, meaning the memory loop's main role is sustaining a hard task distribution.","Because 25–40% of solver slots are human seed questions and this is disclosed but not ablated against SSP, part of the reported gains could come from the fixed seed pool rather than the co-evolution loop; a controlled ablation would settle this.","The risk of a self-confirming loop is real: if the graph is written back with the solver's own successful paths, S_path thresholds may become easier to satisfy as training progresses, so the process reward measures internal consistency rather than external truth; a test would be to freeze the graph after some round and continue training to see if gains persist.","The framework's design is portable to other structured evidence sources (e.g., citation graphs, molecular interaction networks, legal or biomedical databases) wherever entity chains and verifiable relations exist."],"forward_implications":["Under matched training budgets, CoEvoKG beats static-data agentic RL (Search-R1) and self-play (SSP) by 2.6–3.7 macro average points, and its validation accuracy keeps rising while SSP degrades after mid-training.","The process reward separates evidence-supported correct answers from lucky guesses, so training rewards search behavior rather than answer generation alone.","The verified chain pool grows then plateaus as deduplication kicks in, indicating the loop naturally saturates without collapsing onto seed questions.","The difficulty-annealed proposer keeps generated questions at the solver's competence frontier, with comparable success rates to seed questions but higher average hop count (2.23 vs ≈1.75), explaining larger gains on multihop benchmarks.","The seed-fallback rate declines from ≈0.40 to ≈0.25, showing the proposer increasingly produces admissible questions as training proceeds."],"fun_headline_variants":["Knowledge graph as evidence memory lifts search agents by ~11 points","Self-evolving search agents gain 10+ points via KG loop","CoEvoKG: closed-loop graph training improves agents across 6 QA sets","Graph-backed self-play boosts QA search agents by 2.6-3.7 points"],"cache_read_input_tokens":2304,"weakest_assumption_plain":"The load-bearing premise is that the deterministic relation consistency score M(u,v) is a calibrated proxy for evidence-supported search; the paper states that any calibrated scorer could replace it, but calibration is asserted rather than demonstrated, and the thresholds and weights are deferred to an appendix.","fun_headline_variants_meta":{"raw":{"variants":["Knowledge graph as evidence memory lifts search agents by ~11 points","Self-evolving search agents gain 10+ points via KG loop","CoEvoKG: closed-loop graph training improves agents across 6 QA sets","Graph-backed self-play boosts QA search agents by 2.6-3.7 points"]},"model":"deepseek-v4-flash","effort":"low","cost_usd":0.000249,"raw_usage":{"total_tokens":1434,"prompt_tokens":838,"completion_tokens":596,"prompt_tokens_details":{"cached_tokens":256},"prompt_cache_hit_tokens":256,"prompt_cache_miss_tokens":582,"completion_tokens_details":{"reasoning_tokens":527}},"tokens_in":582,"tokens_out":596,"duration_ms":7801,"temperature":1.0,"reasoning_tokens":527,"cache_read_input_tokens":256,"cache_creation_input_tokens":0},"cache_creation_input_tokens":0},"created_at":"2026-08-04T18:32:59.214309+00:00","model_set":{"reader":"deepseek-v4-flash"},"falsifier":"Compute M(u,v) on held-out human-annotated entity-pair support labels; if the score does not track human judgments, the process reward is misaligned and CoEvoKG's reported gains could in part come from training to a heuristic rather than to evidence-supported reasoning.","supporting_citations":[],"review_version":1}