Artificial Intelligence · arXiv:2610.12176 v1 · submitted 8 Oct 2026 · 24 references
Recursive Self-Improvement through Multi-Agent Self-Supervision
The paper says
“Recursive self-improvement (RSI) of a model on non-verifiable tasks, such as open-ended research, faces a supervision bottleneck when its outputs exceed what even human experts can reliably assess, leaving the model itself (optimizee) as the best available optimizer and evaluator.”
more of the abstract
However, a single model instance struggles to critique and improve its own complex reasoning under this homogeneous loop. To address this, we propose Multi-Agent Self-Supervision (MASS), an RSI method that alternates between evolutionary workflow optimization and supervised fine-tuning on self-generated trajectories. Guided by early findings that multi-agent topologies excel at complex reasoning, MASS prompts a single base model to iteratively propose, execute, and self-evaluate multi-agent workflows. Through an evolutionary search constrained by structural guardrails, the model optimizes these computational-graph-like orchestrations, discovering the most effective distinct roles and information routing for a given task. Over two MASS cycles with Qwen3.6-27B, the model achieves 1.2-1.6x higher performance per output tokens on four open-ended public benchmarks. Because the improved model subsequently acts as a better optimizer and evaluator, this alternating framework enables a continuous, recursive bootstrapping of the model's capabilities. Moreover, multi-agent traces are also more training-efficient: a student trained on them outperforms a single-agent student trained on 1.4x more training tokens. These findings suggest that jointly learning orchestration and bounded subagent execution from multi-agent trajectories can provide an effective signal for RSI.
from the abstract
Pith says
Machine review · deepseek-v4-flash · 9 Oct 2026 · what was read was not recorded · not checked by a person
It can be wrong. Challenge this review or reply to it.
Holds up, with conditions. MASS offers a clever framework for recursive self-improvement, but the emprical payoff is modest and the central prformance per token claim lacks statistical grounding. This line is wrong
4 major objections · 6 minor
How often objections from reviews like this one are right: not yet measured
Not checked: figures, code, what the 24 references say.
The paper says, at §4.2, Figure 2, Appendix C.5
The review did not quote this passage.
A classifier read this sentence of the paper as acknowledging the concern (probability 0.77):
“Matching realized lengths does not impose an equal generation budget, and workspace preference does not assess every SFT target.”
Pith says: Objection 1 of 4 · major
The central quantitative claim – 1.2–1.6× higher score per output token on four research benchmarks – is not robust. On MLR-Bench, a paired two-sided sign test across 12 task-mean scores gives p=0.2266, which does not reject the null. On DSBench, the improvement from 0.473 to 0.482 is within one standard deviation of the base.
more of objection 1
The two terminal benchmarks decline. Moreover, the score-per-token metric conflates capability with output length because token budget is not fixed: a model that produces shorter but not more correct outputs improves the ratio without genuine capability gain. The paper acknowledges that the conditional means on MLR-Bench and AstaBench refer to different sets of completed tasks, which undermines the quality-per-token interpretation. The strongest evidence for capability improvement is the 69.9% win rate on the three private test tasks, but those tasks were generated by GPT-5.5 and are not public. The score-per-token claim should be either re-phrased to reflect its dependence on task completion rates and length, or supported by a held-out token budget evaluation.
The paper says, at §4.4, Figure 6, Appendix D
The review did not quote this passage.
A classifier read this sentence of the paper as acknowledging the concern (probability 0.89):
“These differences in sampling, data, and checkpoint selection limit what can be attributed to teacher composition alone.”
Pith says: Objection 2 of 4 · major
The claim that a multi-agent student trained on 28.82M processed tokens beats a single-agent student trained on 42M tokens (i.e., 1.4× more tokens) is not adequately controlled. The piecewise-linear interpolation of single-agent points (S, S+, S++) is only a coarse reference.
more of objection 2
Differences in data composition (the multi-agent data come from different task mixtures and include an execution directive), sampling ratio (2:1 subagent-to-orchestrator vs. uniform for controls), and checkpoint selection (validation loss vs. external judgments for controls) prevent causal attribution to multi-agent trajectories alone (Appendix D acknowledges these differences). The paper should present a matched-pair comparison where the same training tasks, token budget, and selection method are used, or explicitly limit the claim to these specific conditions.
The paper says, at §7, entire paper
The review did not quote this passage.
A classifier read this sentence of the paper as acknowledging the concern (probability 0.62):
“Accelerating the speed of these performance gains in each cycle remains an important direction for future works.”
Pith says: Objection 3 of 4 · major
The paper evaluates only two MASS cycles. The term 'recursive self-improvement' implies a continuing process; with only two steps it is difficult to distinguish genuine recursive gain from a one-time improvement from the first cycle of multi-agent distillation. The stability of the inner-loop optimization over more cycles is unknown. The authors themselves note that accelerating the speed of gains is important future work, but the present evidence does not establish that the framework will continue to improve beyond two generations.
The paper says, at §5.1, Figure 7
The review did not quote this passage.
Pith says: Objection 4 of 4 · major
The claim that optimizer capacity, rather than evaluator capacity, is the main bottleneck in RSI speed is based on the speed with which the all-Qwen loop reaches unanimous wins (11/12 tasks by iteration 20). The slower rate compared to GPT-5.5 optimizer replacements is informative, but the all-Qwen loop eventually catches up.
more of objection 4
Thus the bottleneck is about convergence speed, not ultimate capability. The paper should temper the claim to 'optimizer capacity can be a speed bottleneck', which it already does, but ensure this is distinct from an ability bottleneck.
6 minor objections
The paper says, at Abstract, §1
Pith says: minor objection 1 of 6
The phrase 'higher performance per output tokens' is ungrammatical; should be 'per output token'.
The paper says, at Figure 2
Pith says: minor objection 2 of 6
The figure labels are difficult to read because of small fonts and overlapping annotations. Consider increasing font size and using a legend for arrows.
show 4 more
The paper says, at §2, near bottom
Pith says: minor objection 3 of 6
The notation L^{(g)} is introduced but the parentheses are used inconsistently in the text. Standardize.
The paper says, at §4.2, Table 1
Pith says: minor objection 4 of 6
The win rate of L^{(0)}(xt + w^{(1,i)}) vs L^{(0)}(xt + w^{(0,i)}) is interesting but variance across tasks and iterations is not reported. Adding error bars would help.
The paper says, at §5.2, Table 2a
Pith says: minor objection 5 of 6
The behavioral audit uses only 110 bare-prompt rollouts per generation. Given the stochasticity of LLM outputs, a larger sample would increase confidence in delegation counts.
The paper says, at Appendix C.5
Pith says: minor objection 6 of 6
For MLR-Bench, the sign test (p=0.2266) is the appropriate paired test and should be given more prominence. The paper should state that the primary benchmark evidence is not statistically significant at conventional levels.
What would settle it
Pre-register a confirmatory evaluation on the four research benchmarks with a fixed maximum token budget per task (e.g., 32k output tokens) for all three model generations. If the score per budget ratio and the absolute score difference between L(0) and L(2) both shrink to statistical insignificance (using paired tests across tasks), then the headline claim of improved performance per output token is not supported. Additionally, measure output token counts per task to verify that L(2) outputs are not systematically shorter.
from the skeptic's reading
How the review went
4 readings by deepseek-v4-flash · 9 Oct 2026
- Reader holds up, with conditions
- Skeptic disagrees
- Editor wrote the verdict above
- Referee major revision: 4 major objections, 6 minor
Not run on this paper: the simulated authors' defence.
Pith did not check this review's objections against the paper.
The review in full
The review in brief, machine-written
MASS is a well-thought framework: evlutionary search over multi-agent workflows followed by SFT on the resulting trajectories, all with the same model as executor, evaluator, and optimizer. The core idea — bootrrapping coordination behavior into shared weights — is genuinely novel, and the paper does a lot of things right. They ship detailed ablations, run behavioral audits, and report declines on two public benchmarks with the same candor as improvements. That's fair and rare.
The trouble is that the headline empirical claim — 1.2–1.6× higher score per output token on four research benchmarks — rest on very thin ice. The absolute improvements are small: AstBench 0.053→0.067, DSBench 0.473→0.482. On MLR-Bench the paired sign test gives p=0.23, and both Terminal-Bench 2.0 and SWE-bench Verified go down. The score-per-token metric conflates capability with output length, and the paper does not fix a token budget. The authors themselves note that the conditional means on MLR-Bench and AstBench refer to different sets of completed tasks. So the ratio could be driven by brevity rather than genuine problem-solving strength.
The other evidence is more solid: higher evaluator accuracy (73%→93%), faster workflow discovery, and the structural analysis of learned workflows. The multi-agent training efficiency result (68.3% vs 64.0% on a smaller budget) is interesting but confounded by data composition and different seletion procedures, which they acknowledge.
The weakest link remains that the model must propose useful workflow edits — and the paper's own ablation shows that optimizer capacity is the bottleneck. Two cycles of RSI with an initially weak optimizer don't yet demonstrate a sustainable flywheel.
This is a paper I'd send out to peer review: the methdology is novel and the problem important. But I'd tell the referee to demand stronger statistical practice, more cycles, and a fixed-token-budget comparison before accepting. It's not there yet.
The strongest objection
The paper's central quantitative claim—1.2–1.6× higher score per output token on four research benchmarks—rests on small absolute improvements (e.g., AstaBench 0.053→0.067, DSBench 0.473→0.482) that are within one standard deviation for DSBench and not statistically significant on MLR-Bench under a paired sign test (p=0.2266, Appendix C.5). The score-per-token metric conflates task-solving ability with output length: if L(2) produces shorter but not more correct outputs, the ratio improves without genuine capability gain. The paper does not fix a token budget across models, so the observed ratio could be driven by conciseness. Two of the six public benchmarks (Terminal-Bench, SWE-bench) decline, and, as the paper notes, the conditional means on MLR-Bench and AstaBench refer to different task completions. The main empirical support for RSI thus rests on thin evidence. The strongest claim in the abstract is weakened if these improvements are not robust.
The reader identified optimizer capacity as the weakest assumption, but the paper's own ablation shows the homogeneous optimizer succeeds on 11/12 tasks; the concern is about the strength of the reported empirical evidence for the central claim. The improvements on public benchmarks are small and statistically fragile per the paper's own tests. This threatens the primary quantitative support for the method, not just a secondary bottleneck. Since the reader's verdict is CONDITIONAL and already notes 'modest' and 'not universal' improvements, the reader likely had a similar concern, but the phrasing focused on optimizer capacity. I therefore set agreement to 'disagree' because I emphasize a different weak point. The verdict should remain UNCHANGED because the paper's method and internal ablations are still informative, but the confidence in the central claim should be lowered. The CONDITIONAL verdict already captures that nuance.
The referee's report
If the central claims hold, MASS offers a novel framework for RSI on tasks where definitive external verifiers are unavailable, using multi-agent coordination to break the homogeneity loop. The demonstration that post-training on task-solving traces can improve workflow optimization and self-evaluation without separate training targets is notable. However, the quantitative evidence for the main efficiency and capability claims has statistical brittleness and interpretational confounds that limit the immediate significance.
Pith's reading of the paper (a machine's summary, not the authors')
The paper argues that when a language model is its own best supervisor, a single instance struggles to critique and improve its own complex reasoning. The authors propose Multi-Agent Self-Supervision (MASS), which orchestrates multiple copies of the same model into a structured team, then distills the team's coordinated traces back into shared weights. Over two cycles on a 27-billion-parameter model, MASS yields 1.2–1.6× higher performance per output token on four open-ended research benchmarks and a 68.3% win rate against the base model on private test tasks. A student trained on multi-agent trajectories also outperforms a single-agent student trained on 1.4× more tokens.
What carries the argument. The central mechanism is an alternating loop of workflow optimization and supervised fine-tuning. In the inner loop, the model proposes, executes, and self-evaluates multi-agent workflows through an evolutionary search over role descriptions, instructions, output contracts, and agent call order (hop). The best workflow per task is retained. In the outer loop, the model generates multiple trajectories under those workflows, selects the best via pairwise comparisons and a Bradley-Terry model, and fine-tunes all parameters (or a LoRA adapter) on the orchestrator and subagent conversations. The same model then serves as agent, evaluator, and optimizer in the next generation.
Core claim. Multi-agent coordination, where copies of the same model play distinct roles with explicit information contracts and execution order, generates self-supervision that is both higher quality and more learning-efficient than single-agent long-horizon trajectories. The paper shows that optimizing the communication structure—what agents share, to whom, and in what order—yields workflows that outperform those optimized on role descriptions alone. Post-training on orchestrator and subagent traces jointly improves task solving, workflow optimization, and self-evaluation without separate training targets for those roles.
The premise it rests on. The base model can generate meaningful workflow edits—adding roles, changing subagent order, or adjusting information contracts—based on its own self-evaluation feedback, even when its evaluator accuracy is only 73%.
If the paper is right (Pith's inferences, not the authors')
If a model can bootstrap its coordination skills from its own multi-agent traces, then future recursive self-improvement cycles may require less human-curated supervision for open-ended research tasks.
The finding that multi-agent trajectories are more token-efficient than single-agent ones suggests a principled way to scale self-improvement with limited compute: prioritize structured orchestration over brute-force inference.
The observed transfer from task-solving post-training to better workflow optimization and evaluation implies that a single improvement loop can strengthen multiple roles simultaneously, simplifying the design of autonomous research systems.
The evolutionary workflow search could be extended to include tool-use patterns, reward-sampling strategies, or reasoning-cost budgets, enabling the model to discover not just role assignments but also efficient resource allocation across subagents.
The Bradley-Terry selection step may be bottlenecked by evaluator accuracy, which the paper shows improves from 73% to 93% after one cycle. Further cycles might push this toward ceiling, after which the bottleneck may shift to the optimizer's ability to propose novel structures.
Jointly training orchestrator and subagent traces resembles a form of structured hierarchical imitation learning; a formal comparison with other hierarchical credit-assignment methods (e.g., hindsight relabeling) could clarify whether the advantage comes from the multi-agent structure or from the separation of concerns in the training data.
Check this review
Pith stored no record of this review's passes and took no fingerprint of it. Reviews made by code from 13 Nov 2026 on carry both.
How often reviews like this one are right
Reviews like this one: written by deepseek-v4-flash, where what was read was not recorded.
How often objections from reviews like this one are right: not yet measured
Reviews by people
This review was written by a machine. No person has reviewed this paper on Pith yet. A scientist listed on Pith can review it for a fee, and their review is published here whatever it concludes.
The paper
Abstract
Recursive self-improvement (RSI) of a model on non-verifiable tasks, such as open-ended research, faces a supervision bottleneck when its outputs exceed what even human experts can reliably assess, leaving the model itself (optimizee) as the best available optimizer and evaluator. However, a single model instance struggles to critique and improve its own complex reasoning under this homogeneous loop. To address this, we propose Multi-Agent Self-Supervision (MASS), an RSI method that alternates between evolutionary workflow optimization and supervised fine-tuning on self-generated trajectories. Guided by early findings that multi-agent topologies excel at complex reasoning, MASS prompts a single base model to iteratively propose, execute, and self-evaluate multi-agent workflows. Through an evolutionary search constrained by structural guardrails, the model optimizes these computational-graph-like orchestrations, discovering the most effective distinct roles and information routing for a given task. Over two MASS cycles with Qwen3.6-27B, the model achieves 1.2-1.6x higher performance per output tokens on four open-ended public benchmarks. Because the improved model subsequently acts as a better optimizer and evaluator, this alternating framework enables a continuous, recursive bootstrapping of the model's capabilities. Moreover, multi-agent traces are also more training-efficient: a student trained on them outperforms a single-agent student trained on 1.4x more training tokens. These findings suggest that jointly learning orchestration and bounded subagent execution from multi-agent trajectories can provide an effective signal for RSI.
The paper's own sentences, arranged, kept beside the review and separate from it. Each label is drawn from a closed vocabulary; the number beside it is the probability the classifier gave that label. No sentence in this record was written by a model.
abstract compiled · 2026-10-09
The authors' main claim, as the classifier picked it out 0.99
“These findings suggest that jointly learning orchestration and bounded subagent execution from multi-agent trajectories can provide an effective signal for RSI.”
How the main claim is stated: hedged possibility 1.00
What the abstract itself states, as probabilities: claims first 0.04 · states limitation 0.45 · human participants 0.06 · controlled comparison 0.82 · randomized assignment 0.02 · states quantitative result 0.98 · compares with prior results 0.77 · mentions code or data availability 0.03
The abstract, sentence by sentence
This table labels the abstract only (arXiv listing abstract v1). The number is the probability the classifier gave the label.
| Sentence | Role | The authors' own work | States the main conclusion | Strength |
|---|---|---|---|---|
| Recursive self-improvement (RSI) of a model on non-verifiable tasks, such as open-ended research, faces a supervision bottleneck when its outputs exceed what even human experts can reliably assess, leaving the model itself (optimizee) as the best available optimizer and evaluator. | background 0.85 | 0.07 | 0.04 | asserted 1.00 |
| However, a single model instance struggles to critique and improve its own complex reasoning under this homogeneous loop. | gap 0.67 | 0.14 | 0.03 | asserted 0.99 |
| To address this, we propose Multi-Agent Self-Supervision (MASS), an RSI method that alternates between evolutionary workflow optimization and supervised fine-tuning on self-generated trajectories. | contribution 0.84 | 0.68 | 0.13 | asserted 0.96 |
| Guided by early findings that multi-agent topologies excel at complex reasoning, MASS prompts a single base model to iteratively propose, execute, and self-evaluate multi-agent workflows. | method 0.96 | 0.58 | 0.06 | asserted 0.91 |
| Through an evolutionary search constrained by structural guardrails, the model optimizes these computational-graph-like orchestrations, discovering the most effective distinct roles and information routing for a given task. | method 1.00 | 0.82 | 0.07 | asserted 1.00 |
| Over two MASS cycles with Qwen3.6-27B, the model achieves 1.2-1.6x higher performance per output tokens on four open-ended public benchmarks. | result 1.00 | 0.96 | 0.21 | asserted 1.00 |
| Because the improved model subsequently acts as a better optimizer and evaluator, this alternating framework enables a continuous, recursive bootstrapping of the model's capabilities. | interpretation 0.93 | 0.62 | 0.29 | asserted 0.99 |
| Moreover, multi-agent traces are also more training-efficient: a student trained on them outperforms a single-agent student trained on 1.4x more training tokens. | result 1.00 | 0.89 | 0.08 | asserted 1.00 |
| These findings suggest that jointly learning orchestration and bounded subagent execution from multi-agent trajectories can provide an effective signal for RSI. | interpretation 1.00 | 0.82 | 0.71 | hedged possibility 1.00 |
What kind of paper the classifier reports this is: method or tool 1.00 · evidence from observation or experiment 0.94
What was examined, and what was not
Sources read
- arXiv listing abstract v1
Not examined
- full text
- figures and tables
- references and citing sentences
- relations to other papers
Levels run
- P abstract
Not run
- S sections
- T body sentences
- C citations
- R cross-paper relations
How the labels were made
Compiled by classifier-1.13.0 via TypeSafe API, question bank abstract-p1-20260923, 2026-10-09: 1 request, 7,084 input tokens.
Every quoted sentence on this record is the authors'. Every label is from Pith's closed vocabulary, with the probability shown beside it. This record as JSON
Figures (9)
Figures are the authors', reproduced from the paper.
References (24)
- [1] research_report.md as a conference-style paper (8-12 pages equivalent) with sections: Title/Abstract; Introduction & related work; Data (sources, timestamps, release calendar construction, leakage risks); Feature engineering (macro shock construction); Methodology (regime mode... on Pith
- [2] deliverables/index.json manifest listing every artifact produced (all plots, report, code entry points, metrics paths) on Pith
- [3] in three trials per model. Each task asks the agent to implement a research idea, run exper- iments, and write a report. Runs use the benchmark’s sandbox with Python 3.11, two CPU cores, 48 GB RAM, no GPU, and a two-hour limit. The official rubric judge (Claude Sonnet 4.6, tem... on Pith
- [4] Reproducible code (Python) including: data download scripts (FRED/Yahoo/Stooq + calendar scraping with caching), feature generation, model training, walk-forward evaluation, and backtester with costs. Provide requirements.txt (or pyproject.toml) with pinned versions and a sing... on Pith
- [5] andall-mpnet-base-v2(Song et al., 2020). Long text is split into chunks whose nor- malized embeddings are averaged. The hop sequence is resampled at eight phase anchors. Whiten- ing PCA reduces the representations to dimensiond= 10, with the transform fitted once over all agen... on Pith
- [6] results/model_comparison.json comparing model families and horizons (config, features used, OOS IC, OOS Sharpe, stability score). Also include results/ablation_log.json documenting each ablation run (features removed, delta metrics, notes). Use uv for all Python workflows--run... on Pith
- [8] deliverables/plots/ with at least these PNGs: macro_event_timeline.png, feature_importance_overall.png, regime_confusion_matrix.png, oos_ic_by_horizon.png, equity_curve_spy_timing.png, drawdown_spy_timing.png, turnover_and_costs.png, subperiod_performance_pre_post_2020.png, ab... on Pith
- [10] results/metrics.json containing: predictive metrics (IC, RankIC, AUC if classification, calibration error), trading metrics (annualized return/vol, Sharpe, Sortino, max drawdown, turnover, cost-adjusted performance), and per-subperiod metrics on Pith
- [12] research_report.md as a conference-style paper (7-9 pages equivalent) with required sections plus an ablation study section; embed plots via  on Pith
- [13] deliverables/index.json manifest on Pith
- [14] deliverables/plots/: - deliverables/plots/interface_pr_curve.png - deliverables/plots/interface_roc_curve.png - deliverables/plots/ablation_feature_set_bar.png - deliverables/plots/family_split_performance_boxplot.png - deliverables/plots/precision_at_k_curve.png on Pith
- [15] Reproducible code (Python) including: - src/download_pdb_complexes.py - src/compute_interface_labels.py (distance threshold + parameters) - src/build_graphs.py (node/edge featurization) - src/train_geometric_gnn.py (PyTorch Geometric or e3nn) - src/evaluate.py + src/plotting.p... on Pith
- [16] results/metrics.json with AUROC, AUPRC, precision@k, recall@k overall and per-family split on Pith
- [17] results/ablation_results.json logging each ablation (features/model) with config hash, metrics, and training time. Use uv for all Python workflows--run code with uv run, install dependencies with uv add, use uvx for tools. write your history log: write your plan, execution (or... on Pith
- [18] research_report.md as a conference-style paper (6-9 pages equivalent) describing dataset generation and validation on Pith
- [19] deliverables/index.json on Pith
- [20] deliverables/plots/: dataset_object_count_distribution.png, instruction_template_frequency.png, scene_relation_cooccurrence.png, executable_plan_rate_by_scene_complexity.png, example_scene_renders_grid.png on Pith
- [21] Reproducible code: scene generator; renderer; instruction generator; plan executor; dataset writer (JSONL); requirements.txt on Pith
- [22] results/metrics.json: n_scenes, n_instructions, unique_templates, avg_objects_per_scene, plan_executability_rate, diversity_entropy_measures on Pith
- [23] results/dataset_statistics.json with detailed counts and schema for the generated dataset (fields, value ranges, examples). 31 Preprint Use uv for all Python workflows--run code with uv run, install dependencies with uv add, use uvx for tools. write your history log: write you... on Pith
show 4 more
- [24] Check for NaN/Inf serialization. If you detect a subagent is stuck in a tool-call loop, flag`stall_detected: true`with `blocker_description`.", "input_dependencies": ["agent_data_pipeline.output_contract", "agent_feature_engineer.output_contract", "agent_modeling_specialist.ou... on Pith
- [2024] in three trials per model. Each instance provides a repository and a GitHub issue; the agent must produce a code patch. Runs use the benchmark’s per-instance container images through Har- bor, with a 50-minute agent limit, one CPU core, and 4 GB RAM. The official test suite ch... on Pith
- [2026] URLhttps://openai.com/index/ten-advances-in-mathematics/. Jongho Park, Vasilis Kontonis, Shivam Garg, Akshay Krishnamurthy, and Dimitris Papailiopoulos. Scaling discovery through test-time communication.arXiv preprint arXiv:2609.21032, 2026. Sebastian Risi, Yujin Tang, David H... on PithPith's reviewarXiv
- [5403] IEEE, 2024. Weizhe Yuan, Richard Yuanzhe Pang, Kyunghyun Cho, Xian Li, Sainbayar Sukhbaatar, Jing Xu, and Jason Weston. Self-rewarding language models.arXiv preprint arXiv:2401.10020, 2024. Eric Zelikman, Yuhuai Wu, Jesse Mu, and Noah Goodman. Star: Bootstrapping reasoning wit... on PithPith's reviewarXiv
Cited by 7 Pith papers
Reviewed papers on Pith that cite this one. The full citation record
- RSI Arena: Towards Recursive Self-Improvement with Human Feedback cs.CL · Oct 2026
- SciMARS: Multi-Agent Recursive Self-Improvement for Closed-Loop Scientific Discovery cs.AI · Nov 2026
- Auditing the Product, Not the Recursion: The Evaluation Evidence Behind Recursive Self-Improvement Claims cs.LG · Oct 2026
- From Recursion to Convolution: Parallel Self-Improvement for Multi-Agent Systems cs.AI · Nov 2026
- Toward Recursive Self-Improvement in Physical AI cs.RO · Oct 2026
- DiscoveryRSI: Recursively Learning to Discover Valuable Hypotheses cs.CL · Oct 2026
- SwarmRSI: Recursive Self-Improvement through Evolving Scientific Agent Swarm cs.AI · Oct 2026
Challenges and discussion
Disagree with the review, or know something it missed? Leave a comment, or challenge this review formally: a challenge becomes a permanent entry in this paper's record, and its decision is published here.
Come back by email
A short list of the week's newly reviewed papers. Nothing is sent until you confirm from your inbox, and every email has a link that stops it. No account.
No comments yet.
Sign in to comment