Solvita: Enhancing Large Language Models for Competitive Programming via Agentic Evolution
Summary
Solvita is an agentic evolution framework that enables continuous learning in code generation through reinforcement learning updates to graph-structured knowledge networks, achieving state-of-the-art performance on competitive programming benchmarks.
View Cached Full Text
Cached at: 05/18/26, 02:23 AM
Paper page - Solvita: Enhancing Large Language Models for Competitive Programming via Agentic Evolution
Source: https://huggingface.co/papers/2605.15301 Authors:
,
,
,
,
,
,
,
,
,
,
,
Abstract
Solvita is an agentic evolution framework that enables continuous learning in code generation through reinforcement learning updates to graph-structured knowledge networks, achieving state-of-the-art performance on competitive programming benchmarks.
Large language models(LLMs) still struggle with the rigorous reasoning demands of hard competitive programming. While recentmulti-agent frameworksattempt to bridge this reliability gap, they remain fundamentally stateless: they rely on static retrieval and discard the valuable problem-solving and debugging experience gained from previous tasks. To address this, we present Solvita, an agentic evolution framework that enablescontinuous learningwithout requiring weight updates to the underlying LLM. Solvita reorganizes problem-solving into a closed-loop system of strategy selection,program synthesis,certified supervision, andtargeted hacking, executed by four specialized agents: Planner, Solver, Oracle, and Hacker. Crucially, each agent is paired with a trainable, graph-structured knowledge network. As the system operates, outcome signals, such as pass/fail verdicts, test certification quality, and adversarial vulnerabilities discovered by the Hacker, are recast asreinforcement learningupdates to these network weights. This allows the agents to dynamically route future queries based on past successes and failures, effectively accumulating transferable reasoning experience over time. Evaluated acrossCodeContests,APPS,AetherCode, and liveCodeforcesrounds, Solvita establishes a new state-of-the-art among code-generation agents, outperforming existing multi-agent pipelines and nearly doubling the accuracy of single-pass baselines.
View arXiv pageView PDFAdd to collection
Get this paper in your agent:
hf papers read 2605\.15301
Don’t have the latest CLI?curl \-LsSf https://hf\.co/cli/install\.sh \| bash
Models citing this paper0
No model linking this paper
Cite arxiv.org/abs/2605.15301 in a model README.md to link it from this page.
Datasets citing this paper0
No dataset linking this paper
Cite arxiv.org/abs/2605.15301 in a dataset README.md to link it from this page.
Spaces citing this paper0
No Space linking this paper
Cite arxiv.org/abs/2605.15301 in a Space README.md to link it from this page.
Collections including this paper0
No Collection including this paper
Add this paper to acollectionto link it from this page.
Similar Articles
@rohanpaul_ai: Better self-improving agents need better solvers, not bigger update-writing models. This challenges the common habit of…
This paper disentangles the roles of evolver and agent in self-improving LLM agents, showing that a small evolver can write sufficiently good updates, while a mid-tier agent benefits most from using them. It recommends using the strongest model as the task executor, not the update writer.
Evolution through large models
This paper demonstrates that large language models trained on code can significantly enhance genetic programming mutation operators, enabling the generation of hundreds of thousands of functional Python programs for robot design in the Sodarace domain without prior training data. The approach, called Evolution through Large Models (ELM), combines LLMs with MAP-Elites to bootstrap new conditional models for context-specific artifact generation.
@qinzytech: https://x.com/qinzytech/status/2066585405479371092
A technical analysis of two approaches to building self-evolving AI agents: model-based (via architecture like SSMs or transformer with fast-weight updates, and training methods) and harness-based (via memory or meta harness that can rewrite itself). The author provides practical recommendations for different audiences.
PACE: Two-Timescale Self-Evolution for Small Language Model Agents
PACE introduces a two-timescale framework for self-evolution of small language model agents, coordinating low-risk prompt refinement with higher-risk control-logic updates, achieving up to +9.2% relative improvement across benchmarks.
EvoOptiGraph: Weakness-Driven Coevolution via Graph-Based Structural Generation for Optimization Modeling
EvoOptiGraph is a framework for automating optimization modeling from natural language using graph-based evolutionary generation to create diverse training data and co-evolve the model with weakness-driven reinforcement learning, achieving state-of-the-art results on multiple benchmarks.