acceptodds
Under review as a conference paper at ICLR 2027

Solvita: Enhancing Large Language Models for Competitive Programming via Agentic Evolution

Abstract

Large language models (LLMs) still struggle with the rigorous reasoning demands of hard competitive programming. While recent multi-agent frameworks attempt to bridge this reliability gap, they remain fundamentally stateless: they rely on static retrieval and discard the valuable experience gained from solving previous problems and debugging their solutions. To address this, we present Solvita, an agentic evolution framework that enables continuous learning without requiring weight updates to the underlying LLM. Solvita coordinates the Planner, Solver, Oracle, and Hacker in a closed loop. Trainable knowledge networks use reinforcement learning from task feedback to improve the retrieval of prior experience. Solvita achieves the highest pass@3 in 14 of 15 combinations of models and benchmarks across CodeContests, APPS, and AetherCode. In paired comparisons, it performs comparably to commercial agents on their native backbones and achieves higher pass@3 in all 24 comparisons on other backbones. In controls using GPT-5.4 with matched budgets, learned Solver routing outperforms BM25 retrieval and LLM skill selection by 3.9 to 7.5 percentage points. On Codeforces, Solvita reaches a maximum rating estimate of 3394 using CodeElo, with gains of up to 526 points over matched bare backbones.

Primary area:
foundation or frontier models, including LLMs
Keywords:
multi-agent systems, large language models, code generation, continual learning, competitive programming

Reviews

Among:
Shape:
1234this paper, Top 49%
Figure 1. Mean review rating of the reviewed papers at ICLR 2027. This paper averages 2.33 over 3 reviews, above 51% of the others.
Reviewer_t7f4OpenReview ↗
Rating
3
Confidence
2
Informativeness
2
Presentation
2
Soundness
2
Read review
Paper summary

The paper proposes Solvita, a closed-loop four-agent framework with Planner, Solver, Oracle and Hacker for competitive programming. The LLM backbone stays frozen, and three trainable knowledge networks update their retrieval weights and memory contents from task feedback, a three-layer QMS graph for the Solver trained with contrastive REINFORCE and contextual bandits for the Oracle and Hacker. Evaluation covers CodeContests, APPS, and AetherCode across five backbones against commercial and open-source agents, plus component ablations, retrieval controls, patch-vs-regenerate, and a CodeElo-based Codeforces estimate.

Critical strengths
  • The evaluation is broad and fairly careful. All methods share the same five backbones, gateway, and decoding settings across three benchmarks. The paper reports paired bootstrap CIs with McNemar/BH correction and candidly states that Solvita is statistically indistinguishable from Codex CLI and Claude Code on their native backbones, and slightly worse in single-run success there.
  • The matched-budget controls in Tables 3–4 separate graph growth from weight learning and compare against BM25 and LLM skill selection. They give the most direct support for the central claim that learned routing beats static retrieval.
Critical weaknesses
  • The source of gains is unclear. Each Solvita run executes three branches and submits the one passing the most internal tests, while baselines submit one program per run. On native backbones Solvita shows no advantage, so its lead elsewhere may largely reflect commercial agents being tuned to their own models rather than experience learning. Further, the learning gain itself (scaffold-only → full system, about +14 points in Table 2) comes from single training runs with no variance estimates (acknowledged in App. J), and the QMS-over-LLM-pick margin (about 4–5 points) is shown only on GPT-5.4.
  • The paper does not state whether these contests (IDs 2219–2237) postdate each backbone’s training cutoff. APPS, CodeContests, and AetherCode 2024 face the same pretraining-contamination risk. The benchmark-isolation procedure covers the retrieval corpus but not the backbone itself.
  • Some pages show Solvita scoring below the bare model (e.g., GPT-5.4 on contest 2220), and per-page scores are nearly identical across backbones. Both of them need explanation.
Questions for authors
  • Figure 1 lists LeetCode, HackerRank, and 25 sites, while Section 2.1 says the corpus comes only from the APPS, CodeContests, and CodeContests+ training splits. How do these reconcile?
2 comments
AuthorsOpenReview ↗

Response to Reviewer t7f4

We thank the reviewer for the close reading of our benchmark comparisons and training data sources. We address the four questions in the order raised.

Q1 The source of gains is unclear. Each Solvita run executes three branches and submits the one passing the most internal tests, while baselines submit one program per run. On native backbones Solvita shows no advantage, so its lead elsewhere may largely reflect commercial agents being tuned to their own models rather than experience learning. Further, the learning gain itself (scaffold-only → full system, about +14 points in Table 2) comes from single training runs with no variance estimates (acknowledged in App. J), and the QMS-over-LLM-pick margin (about 4–5 points) is shown only on GPT-5.4.

A1 The comparison evaluates complete agent strategies. Generating several candidates and selecting one through internal tests is part of Solvita's strategy. Commercial agents retain their default workflows and can also generate multiple candidate programs, compile them, and run their own tests before choosing a solution. The rule of one program per run applies to the final submission, and our token accounting includes all Solvita branches. Solvita achieves comparable accuracy on the commercial agents' native models with lower reported token use. The contribution of learning is assessed separately in Table 2, where the backbone, branching, and selection rule remain fixed and training improves performance across three backbones. Across three independent GPT-5.4 training runs with different problem orders and policy sampling seeds, the gain over the scaffold, averaged across the three benchmarks, is 13.79 ± 0.40 percentage points (mean ± standard deviation across runs). The comparison with LLM skill selection in Table 4 isolates the retrieval mechanism on GPT-5.4 under matched corpus and retrieval budgets; the evidence that learning helps across backbones comes from Table 2.


Q2 The paper does not state whether these contests (IDs 2219–2237) postdate each backbone’s training cutoff. APPS, CodeContests, and AetherCode 2024 face the same pretraining-contamination risk. The benchmark-isolation procedure covers the retrieval corpus but not the backbone itself.

A2 The model versions used in our Codeforces experiments were released before or around the contest period; the DeepSeek results use the V4 Pro preview. For APPS, CodeContests, and AetherCode 2024, we use the datasets' designated test sets and exclude evaluation problems from Solvita's training corpus and memories. The underlying LLM weights remain frozen. Any inclusion of these public test sets in model pretraining would come from the provider's data collection, not from Solvita's training or retrieval pipeline. We additionally audited all 165 CodeContests and 1,000 APPS evaluation problems against the 12,017 problems used for initialization and online training. Semantic similarity ≥ 0.85 flagged 27 CodeContests pairs and 115 APPS pairs. Manual checks of sample inputs and outputs and abstract syntax trees found zero paraphrased duplicate problems among these candidates.


Q3 Some pages show Solvita scoring below the bare model (e.g., GPT-5.4 on contest 2220), and per-page scores are nearly identical across backbones. Both of them need explanation.

A3 GPT-5.4 on contest 2220 is the only lower score among the 36 displayed comparisons of model and contest page; Solvita scores higher in the other 35. Each method submits one independently generated program per problem. Retrieval and repair can sometimes steer a solution toward an unsuitable approach, as discussed in Appendix J, so improvements need not occur on every problem. Overall, Solvita with GPT-5.4 solves 72 of 79 distinct problems, compared with 50 for the bare model. The repeated scores largely reflect full marks: on contests 2224, 2231, 2232, and 2237, all three backbones solve every problem on the page. Our scoring sums the initial values of accepted problems and omits runtime, so identical solved sets yield identical scores, and different sets can also have the same total. CodeElo estimates can coincide even when scores differ because the scores produce the same inserted rank in the official standings.


Q4 Figure 1 lists LeetCode, HackerRank, and 25 sites, while Section 2.1 says the corpus comes only from the APPS, CodeContests, and CodeContests+ training splits. How do these reconcile?

A4 The “25 sites” label in Figure 1 refers to the programming websites we surveyed when looking for candidate training data. The final corpus draws only on the APPS and CodeContests training splits and the training split of CodeContests+, as described in Section 2.1. The website names identify where individual problems originated. For example, APPS includes problems from LeetCode and HackerRank. We will revise Figure 1 to distinguish the initial survey from the three dataset splits we used.

Thank you again for your thoughtful review. As the discussion period draws to a close, we wanted to ask whether our response addressed your concerns. If any questions remain, we’d be happy to discuss them further.

Reviewer_5LNSOpenReview ↗
Rating
2
Confidence
3
Informativeness
2
Presentation
2
Soundness
2
Read review
Paper summary

This paper proposes Solvita, a multi-agent continual learning framework designed for challenging competitive programming tasks. Its primary objective is to improve code generation quality through cross-task experience accumulation and reinforcement learning without updating the parameters of the underlying LLMs. Solvita consists of four agents: Planner, Solver, Oracle, and Hacker. The main technical contribution is the construction of three trainable knowledge networks. Specifically, the Solver employs a three-layer Query–Method–Skill graph to organize historical problems, solution methods, and coding skills, and updates retrieval weights using a paired-reward-based REINFORCE algorithm. Meanwhile, the Oracle and Hacker utilize contextual bandits to learn strategies for test generation and bug detection, respectively.

Critical strengths

Strengths

  1. The authors propose a continual learning framework that integrates a three-layer QMS knowledge graph, Contrastive REINFORCE, and cross-agent experience sharing. By structurally organizing historical problem-solving experiences, dynamically optimizing skill retrieval strategies, and propagating failure feedback, the framework enables cross-task knowledge accumulation and performance improvement without updating the underlying LLM parameters.

  2. The authors conduct extensive evaluations on three public competitive programming benchmarks using five different backbone models. Through component ablations, retrieval strategy comparisons, knowledge base scaling analyses, and code repair efficiency evaluations, the experiments systematically demonstrate the framework's effectiveness, applicability across different models, and practical value.

Critical weaknesses

Weaknesses

  1. The proposed structured knowledge memory, reinforcement learning-based retrieval optimization, and multi-agent feedback mechanisms are all closely related to existing research. The main contributions of this work appear to be an integration and task-specific adaptation of established techniques rather than substantially novel algorithmic developments. Therefore, the paper lacks sufficiently distinctive methodological innovation.

  2. When independent reference programs are unavailable, the Oracle relies on automatically generated verification tools, which may introduce circular validation and unreliable supervision signals. These incorrect signals could propagate through the multi-agent feedback mechanism, potentially leading to the accumulation of erroneous knowledge over time.

  3. The paper lacks direct comparisons between the proposed three-layer QMS knowledge graph and simpler alternatives, such as two-layer graphs or trainable vector-based memory systems. Moreover, the independent contribution of the cross-agent failure experience propagation mechanism is not sufficiently investigated. Consequently, it remains unclear which components are primarily responsible for the observed performance improvements.

Questions for authors

See above

2 comments
AuthorsOpenReview ↗

Response to Reviewer 5LNS

We thank the reviewer for examining the design of Solvita’s knowledge retrieval system. We have grouped the related comments and respond to each concern below.

Q1 The proposed structured knowledge memory, reinforcement learning-based retrieval optimization, and multi-agent feedback mechanisms are all closely related to existing research. The main contributions of this work appear to be an integration and task-specific adaptation of established techniques rather than substantially novel algorithmic developments. Therefore, the paper lacks sufficiently distinctive methodological innovation.

A1 The central question we address is how to train external knowledge retrieval so that a fixed LLM can select reusable skills based on how much they help solve a problem. We learn the connections between problems, solution methods, and skills using the performance difference between matched runs with and without the retrieved skills. This training formulation depends on reusable skills and measurable outcomes, rather than rules specific to competitive programming. Programming provides a concrete setting where those outcomes can be checked through execution. We therefore believe the methodological contribution lies in how knowledge retrieval is represented and trained, with competitive programming serving as the setting in which we evaluate that contribution.


Q2 When independent reference programs are unavailable, the Oracle relies on automatically generated verification tools, which may introduce circular validation and unreliable supervision signals. These incorrect signals could propagate through the multi-agent feedback mechanism, potentially leading to the accumulation of erroneous knowledge over time.

A2 The Oracle used executable dataset reference solutions in 92.0% of training episodes (Tier 1). In the remaining 8.0%, the reference was missing or timed out on a stress input. For these episodes (Tier 2), we generated a brute-force reference or a property checker at low temperature without showing the model the Solver's candidate code. A generated reference must first pass the public samples. The Oracle counts a new test only if the input passes the validator and the reference produces a nonempty output that passes the judging procedure. At least 90% of the target number of tests must be certified. Problems with multiple valid outputs also require evidence from a custom checker (Eq. 3). We exclude unverified tests from candidate ranking and memory updates. The Solver updates its QMS edge weights using the difference in test-pass rates between paired runs with and without QMS augmentation. The Oracle updates its bandit from certification results and the Hacker from adversarial test outcomes (Table 17). Since generated tools can still share an error, we evaluated the GPT-5.4 Oracle and Hacker together on 500 held-out Codeforces problems without giving them official references. They preserved 95.4% of the 3,500 officially accepted submissions and rejected 90.6% of the 4,500 officially rejected submissions (Table 19). To check whether errors accumulated in memory, we audited persistent writes against ground-truth tests across the 5,318-problem training stream. The gated fallback caught genuine failures when dataset references timed out on stress inputs, giving Full Solvita a small advantage over Tier 1 alone. Removing the gate increased the share of episodes with a false write fivefold, from 0.5% to 2.5%, and lowered mean pass@3 to 63.67%. With all official references withheld, gated Tier 2 still finished 2.27 points above the frozen baseline.

Write policyEpisodes using Tier 2Episodes with false writesCCAPPSACAvg
Frozen cold-start baseline--78.1863.0044.5061.89
Tier-1 only0%0.0%81.8267.1048.5065.81
Full Solvita8.0%0.5%82.4267.7049.2566.46
Gated Tier-2 only100%6.0%80.0065.5047.0064.17
Ungated Tier-28.0%2.5%80.0064.5046.5063.67

Q3 The paper lacks direct comparisons between the proposed three-layer QMS knowledge graph and simpler alternatives, such as two-layer graphs or trainable vector-based memory systems. Moreover...Consequently, it remains unclear which components are primarily responsible for the observed performance improvements.

A3 In early experiments, we connected Q nodes directly to S nodes, but the paired reward stayed near zero after training, with little improvement over random initialization. This motivated the use of M nodes, which describe solution methods and connect them to reusable skills. Table 4 compares QMS with BM25 using the same corpus, retrieval slots, and inference budgets. With GPT-5.4, QMS improves pass@3 over BM25 by 6.67, 6.00, and 7.50 percentage points on CodeContests, APPS, and AetherCode, respectively.

Thank you again for your thoughtful review. As the discussion period draws to a close, we wanted to ask whether our response addressed your concerns. If any questions remain, we’d be happy to discuss them further.

Reviewer_oKRMOpenReview ↗
Rating
2
Confidence
3
Informativeness
1
Presentation
2
Soundness
2
Read review
Paper summary

Authors propose non-parametric a multi-agent framework for competitive programming called Solvita; in which learns across problems while keeping the LLM freezed. It includes 4 components as: a Planner structures the problem, a Solver writes and repairs code, an Oracle generates and checks tests, and a Hacker searches for counterexamples. Solver learns which skills to retrieve from a graph of past problems and solutions, while the Oracle and Hacker use contextual bandits to select strategies. According to the authors claim, across CodeContests, APPS, and AetherCode, Solvita achieves the highest observed performance in their setting.

Critical strengths
  • Authors evaluation setup covers five backbones and three benchmarks under a single shared setup, which makes the comparisons fair and the observations more generalizable.
  • Eventhough the reason why is not super clear in the current version of manuscript, proposed system uses fewer tokens than Codex CLI and Claude Code and documents its prompts, budgets, and evaluation protocol in detail, which makes it again both practical and realistically reproducible for other researchers.
Critical weaknesses
  • My main concern is that the paper never makes clear why the method works so well, which left me somewhat confused about where the gains actually come from. More specifically, I am not fully convinced the gains come from “evolution” neither. Starting from empty networks, full online training only moves CodeContests from 67.88 to 71.52 ( see Table 5), while adding the cold-start corpus brings it to 82.42, and APPS and AetherCode show a similar pattern. Also, every evaluation freezes the memories while training can use official solutions and hidden tests, so the results seems to show transfer from a separate training stream, not continued improvement from the feedback actually available at deployment. I think given how much the seed corpus matters, the isolation check for CodeContests and APPS should also be stronger than the exact ID matching used in the current version of the manuscript.
  • Related to first point above, learning mechanisms themselves are not well isolated which makes hard to interpret what makes it work why. No ablation separates learned routing from memory content for the Oracle and Hacker, or tests the cross-role failure sharing the paper emphasizes. Also the training dynamics of Reinforce are overlooked like the reward curves and entropy which would nice to check.
Questions for authors
  1. Could you show how performance evolves over the online training stream, ideally with several training seeds and a seeded-but-frozen condition (cold-start networks, no online updates)? This would help clarify whether online learning keeps improving the system or mostly plateaus on top of the cold-start corpus.
  2. How stable are the learned weights during training? For example, do the QMS edge weights and bandit preferences converge, and do they become sensitive to the order of training problems? It would also help to see how much the graph grows over training, and how often failures found by the Hacker actually change later Solver or Oracle behavior.
  3. On a chronological stream of unseen problems, how does a system that updates using deployment-time feedback compare with the same frozen checkpoint when each problem is scored before any update?
2 comments
AuthorsOpenReview ↗

Response to Reviewer oKRM

We thank the reviewer for asking how much Solvita gains from online learning after the cold start. We address the three questions in order, with each response immediately below its question.

Q1 Could you show how performance evolves over the online training stream, ideally with several training seeds and a seeded-but-frozen condition (cold-start networks, no online updates)? This would help clarify whether online learning keeps improving the system or mostly plateaus on top of the cold-start corpus.

A1 Seeding the networks with 6,699 problems raised GPT-5.4's macro-average pass@3 from 52.46% with the empty scaffold to 61.89% with the seeded networks frozen (Step 0). Starting without a skill vocabulary may explain the smaller online gains in Table 5. From the seeded checkpoint, we trained on 5,318 problems in three independent runs with different problem orders and sampling seeds. Pass@3 continued to improve beyond 1,500 and 3,000 problems, reaching 66.25% on average, a further gain of 4.36 percentage points. Each row after Step 0 gives the mean and standard deviation across runs. As explained in A3, we froze memory during evaluation to prevent leakage between test problems. We also repeated the training stream using only feedback available at deployment. With public samples and tests run by the Oracle and Hacker, but no official solutions or hidden tests, GPT-5.4 reached 80.00% on CodeContests, 65.50% on APPS and 47.00% on AetherCode. The macro-average was 64.17%, 2.27 points above Step 0. We extended the overlap audit to all 165 CodeContests and 1,000 APPS test problems, comparing them against all 12,017 training problems. We manually reviewed every pair whose statement embeddings had a cosine similarity of at least 0.85. Across the 27 CodeContests pairs and 115 APPS pairs, we found no exact or rephrased duplicates after comparing sample inputs and outputs and the reference solutions' abstract syntax trees.

Online ProblemsCCAPPSACAvg
078.1863.0044.5061.89
1,50079.19 ± 0.9364.00 ± 0.7045.50 ± 1.0062.90 ± 0.60
3,00080.40 ± 0.7065.30 ± 0.6046.83 ± 0.8064.18 ± 0.47
4,50081.41 ± 0.7066.50 ± 0.5048.00 ± 0.6665.30 ± 0.41
5,31882.22 ± 0.7067.53 ± 0.5049.00 ± 0.7566.25 ± 0.40

Q2 How stable are the learned weights during training? ... and how often failures found by the Hacker actually change later Solver or Oracle behavior.

A2 We evaluated memory growth and routing updates separately for Oracle and Hacker using GPT-5.4, with the same cold-start memories, training stream, and pipeline budgets. The four conditions freeze both content and weights (A), update weights only (B), grow memory only (C), or enable both (D). Adding routing updates to memory growth improves pass@3 by 3.50–4.24 percentage points for Oracle and 1.40–2.42 for Hacker. Compared with routing updates alone, adding memory growth improves pass@3 by 2.25–2.60 and 1.00–1.25 points, respectively. The table reports pass@3 (%).

ConfigurationOracle CCOracle APPSOracle ACHacker CCHacker APPSHacker AC
A: Initial memory, no updates68.4855.6035.5068.4855.6035.50
B: Routing learning only72.7358.1039.7570.9157.2037.50
C: Memory growth only70.9157.2038.0069.7056.8037.00
D: Both75.1560.7042.0072.1258.2038.75

Also, we trained the GPT-5.4 system three times, randomly permuting the same 5,318 training problems and changing the policy sampling seed. The standard deviations of final pass@3 were 0.70, 0.50, and 0.75 percentage points on CodeContests, APPS, and AetherCode respectively with a macro average standard deviation of 0.40 points. Final performance varied little across the tested training orders and sampling seeds.


Q3 On a chronological stream of unseen problems, how does a system that updates using deployment-time feedback compare with the same frozen checkpoint when each problem is scored before any update?

A3 Solvita learns reusable strategies through optimization on a large, separate training set, while the benchmark test sets are reserved for assessing how well those strategies generalize. Keeping the knowledge networks fixed during testing preserves this separation. These benchmarks were prepared for evaluation rather than continued training, with limited numbers of problems and no checks for repeated or nearly identical problems across the sets. Even when each problem is scored before an update, information from an earlier overlapping problem could still affect a later score, making the results less informative about generalization. For these reasons, we believe that learning on the designated training set and evaluating with fixed knowledge networks is the appropriate protocol here.

Thank you again for your thoughtful review. As the discussion period draws to a close, we wanted to ask whether our response addressed your concerns. If any questions remain, we’d be happy to discuss them further.

From OpenReview, CC BY 4.0. Authors as signed there; shown unedited.

Related papers

Loading the map…

Discussion (0)

Sign in to comment.