MARS: Multi-Specialist LLM Relay System for Competitive Programming

Andrei Mikhailov; Mikhail Burtsev; Alsu Sagirova

cs.AIAug 24, 2026

MARS: Multi-Specialist LLM Relay System for Competitive Programming

Authors: Andrei Mikhailov, Mikhail Burtsev, Alsu Sagirova

Organizations: MIRAI · London Institute for Mathematical Sciences · AXXX

Abstract

Large Language Models excel at code generation, yet competitive programming exposes a persistent failure mode: existing multi-agent pipelines distribute work over generic planner, coder, and debugger roles and delegate the choice of algorithmic technique to the backbone alone. We present MARS (Multi-Agent Relay of Specialized LLMs), a prompt-only framework in which each agent is a topic specialist---dynamic programming, graphs, strings, geometry, and so on---grounded by retrieval-augmented generation over an algorithm-theory corpus. Given a problem, retrieval selects a small team of relevant specialists; a starter writes an initial C++17 solution, and each subsequent turn runs the candidate against public examples in a sandbox, lets the active specialist keep, repair, or hand off the draft, and forwards a structured packet to the next specialist. A single infrastructure-fixer pass normalizes boilerplate at the end. On the CodeContests test split with Gemma 4, MARS reaches $0.624 \pm 0.006$ pass rate at $2.3$ recorded pipeline stages per task ( $+14.4$ percentage points over direct prompting), closing most of the gap to CodeSIM ( $0.731$ ) at $3.3{\times}$ lower wall-clock cost and substantially smaller variance in per-task token spend. The source code is available on GitHub: https://github.com/fckand/mars.

Figures & tables

Figure 1: MARS relay pipeline. A task is routed from a pool of RAG-grounded topic specialists to a team of at most three agents. Each turn runs code generation, public-test execution, and self-check/handoff; repair code is rerun locally before the current code and relay packet move to the next specialist or final submission.

Method	Pass rate	Sec	Tokens	Calls
Direct	$0.48\,{\scriptstyle\pm\,0.02}$	$34.9\,{\scriptstyle\pm\,49.6}$	$1.8\,{\scriptstyle\pm\,1.2}$	$1.0\,{\scriptstyle\pm\,0.0}$
Single-RAG	$0.53\,{\scriptstyle\pm\,0.01}$	$59.8\,{\scriptstyle\pm\,21.2}$	$25.0\,{\scriptstyle\pm\,3.2}$	$12.0\,{\scriptstyle\pm\,0.0}$
Parallel ens.	$0.56\,{\scriptstyle\pm\,0.00}$	$360.9\,{\scriptstyle\pm\,172.9}$	$29.8\,{\scriptstyle\pm\,5.1}$	$17.6\,{\scriptstyle\pm\,0.8}$
Base relay	$0.55\,{\scriptstyle\pm\,0.00}$	$191.6\,{\scriptstyle\pm\,91.5}$	$34.1\,{\scriptstyle\pm\,10.2}$	$17.1\,{\scriptstyle\pm\,1.7}$
MARS	$\mathbf{0.62}\,{\scriptstyle\boldsymbol{\pm}\,\mathbf{0.01}}$	$244.3\,{\scriptstyle\pm\,154.4}$	$40.3\,{\scriptstyle\pm\,8.1}$	$16.6\,{\scriptstyle\pm\,1.3}$
CodeSIM ∗	$0.73\,{\scriptstyle\pm\,0.01}$	$817.5\,{\scriptstyle\pm\,1358.5}$	$32.2\,{\scriptstyle\pm\,54.8}$	$10.2\,{\scriptstyle\pm\,14.2}$

Table 1: Main results. Pass rate is solved-task fraction. Time in sec, tokens in thousands and number of calls are per-task. All values averaged across 3 runs. CodeSIM ∗ is our rerun on Gemma4.

Figure 2: Team-selection frequency per specialist. Fraction of tasks on which each specialist joins the team, averaged over runs. Base relay and MARS share a deterministic assessor and coincide; the Parallel ensemble uses an earlier, less selective prompt and spreads selections more widely, which does not translate into accuracy.

Figure 3: Average pass rate by Codeforces difficulty tier. MARS dominates prompt-only baselines on Medium and more than doubles Direct on Hard; CodeSIM ∗ leads on every tier. Tier sizes: Easy $n{=}56$ , Medium $n{=}39$ , Hard $n{=}70$ .

Qwen3.5-27B, C++17
Method	Pass rate	Sec	Tokens	Calls
Direct	$0.192\,{\scriptstyle\pm 0.018}$	$27.2\,{\scriptstyle\pm 74.6}$	$1.7\,{\scriptstyle\pm 2.2}$	$1.0\,{\scriptstyle\pm 0.0}$
Single-RAG	$0.264\,{\scriptstyle\pm 0.004}$	$71.0\,{\scriptstyle\pm 57.1}$	$26.5\,{\scriptstyle\pm 4.0}$	$12.0\,{\scriptstyle\pm 0.0}$
MARS	$\mathbf{0.297}\,{\scriptstyle\pm\mathbf{0.012}}$	$109.7\,{\scriptstyle\pm 99.7}$	$40.5\,{\scriptstyle\pm 18.7}$	$15.3\,{\scriptstyle\pm 3.3}$
GPT-5.4-mini, C++17
Direct	$0.149\,{\scriptstyle\pm 0.019}$	$3.4\,{\scriptstyle\pm 2.3}$	$1.2\,{\scriptstyle\pm 0.5}$	$1.0\,{\scriptstyle\pm 0.0}$

Table 2: Backbone and language transfer. The same

165

tasks and final harness as Table 1 , using recorded model- and method-specific decoding. Time is in seconds, tokens in thousands, and calls per task; PairCoder includes embedding traffic.

Configuration	Pass rate	$\Delta$
MARS (full)	$0.624\,{\scriptstyle\pm 0.006}$	—
w/o RAG grounding	$0.604\,{\scriptstyle\pm 0.007}$	$-0.020$
Generalists, no RAG	$0.615\,{\scriptstyle\pm 0.013}$	$-0.009$
Earlier Base relay	$0.552\,{\scriptstyle\pm 0.000}$	$-0.072$
Parallel manager	$0.564\,{\scriptstyle\pm 0.000}$	$-0.060$

Table 3: Ablations and protocol variants on Gemma 4. The generalist variant also disables RAG; the last two rows are the broader Base relay and Parallel ensemble comparisons from Table 1 .

Appendix figures & tables1 asset

Supplementary material from the paper’s appendix.

Appendix

Figure 8: Example MARS trace for Codeforces 1620_B with three contributing specialists. Step 1 includes a within-step self-check repair loop: the first draft fails the public sample, the same specialist consumes the test report and emits a corrected draft before handing off. Later steps show the specialist contribution, public-test outcome, and structured handoff to the next agent.

LLM-Based Program Synthesis

Large language model (LLM)-based program synthesis turns natural-language goals and examples into executable programs, often using tests or formal constraints.

See all 309 papers

Solvita: Enhancing Large Language Models for Competitive Programming via Agentic Evolution
May 14, 2026Han Li, Jinyu Tian, Rili Feng +10RL for Code Generation Continual Learning for LLM Agents
Nanjing University · Independent Researcher · Tsinghua University
A-ProS: Towards Reliable Autonomous Programming Through Multi-Model Feedback
May 18, 2026Anika Tabassum, Md Sifat Hossain, Md. Fahim Arefin +2LLM Self-Refinement Execution-Guided Code Generation
Dept. of Computer Science and Engineering, University of Dhaka, Bangladesh · Dept. of Information Systems, University of Maryland, Baltimore County, USA
GrandCode: Achieving Grandmaster Level in Competitive Programming via Agentic Reinforcement Learning
Apr 3, 2026Ornith Team, Xiaoya Li, Guoyin Wang +3RL for Code Generation Agentic RL
DeepReinforce Team

May 14, 2026J/K move · Enter open · S save

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

Han Li, Jinyu Tian, Rili Feng, Yuqiao Du+9

Nanjing University · Independent Researcher · Tsinghua University

RL for Code Generation Continual Learning for LLM Agents Competitive Programming Multi-Agent Coding Memory-Augmented Language Model Agents

Open paper AskPDF arXiv

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 problem-solving and debugging experience gained from previous tasks. To address this, we present Solvita, an agentic evolution framework that enables continuous learning without requiring weight updates to the underlying LLM. Solvita reorganizes problem-solving into a closed-loop system of strategy selection, program synthesis, certified supervision, and targeted 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 as reinforcement learning updates 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 across CodeContests, APPS, AetherCode, and live Codeforces rounds, 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.

Abstract

LLM-Based Program Synthesis

Explore similar work

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

A-ProS: Towards Reliable Autonomous Programming Through Multi-Model Feedback

GrandCode: Achieving Grandmaster Level in Competitive Programming via Agentic Reinforcement Learning