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

May 14, 2026

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

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.

Han Li, Jinyu Tian, Rili Feng +10

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

Ask PDF

May 18, 2026

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

Large Language Models (LLMs) demonstrate strong potential for automated code generation, yet their ability to iteratively refine solutions using execution feedback remains underexplored. Competitive programming offers an ideal testbed for this investigation, as it demands end-to-end algorithmic reasoning, precise implementation under strict computational constraints, and complete functional correctness with rigorous evaluation. In this paper, we present A-ProS, an autonomous AI agent that solves competitive programming problems through a hybrid multi-model feedback framework separating solution generation from specialized debugging. A-ProS combines ChatGPT-based generators (GPT-4 and GPT-5) with three debugging critics: Codestral-2508, Llama-3.3-70B, and DeepSeek-R1, under a 2 x 3 factorial design. We evaluate six workflows on 367 problems from ICPC World Finals (2011-2024) and Codeforces (rated 1200-1800). The results show that GPT-5 workflows improve from 39 initial accepted solutions to 85-90 after three refinement rounds, while GPT-4 improves from 15 to 31-38. A controlled ablation on 47 problems shows that stateful refinement outperforms stateless approaches by 8.5-10.6 percentage points and reduces repeated failures by up to 3.5x. Compared to baseline agent loops, A-ProS achieves over 2x greater gains, highlighting the importance of persistent context and multi-model feedback for reliable autonomous program synthesis.

Anika Tabassum, Md Sifat Hossain, Md. Fahim Arefin +2

Dept. of Computer Science and Engineering, University of Dhaka, Bangladesh · Dept. of Information Systems, University of Maryland, Baltimore County, USA

LLM Self-Refinement Execution-Guided Code Generation Program Synthesis Agentic Code Generation

Ask PDF

Apr 3, 2026

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

Competitive programming remains one of the last few human strongholds in coding against AI. The best AI system to date still underperforms the best humans competitive programming: the most recent best result, Google's Gemini3 Deep Think, attained 8th place even not being evaluated under live competition conditions. In this work, we introduce GrandCode, a multi-agent RL system designed for competitive programming. The capability of GrandCode is attributed to two key factors: (1) It orchestrates a variety of agentic modules (hypothesis proposal, solver, test generator, summarization, etc) and jointly improves them through post-training and online test-time RL; (2) We introduce Agentic GRPO specifically designed for multi-stage agent rollouts with delayed rewards and the severe off-policy drift that is prevalent in agentic RL. GrandCode is the first AI system that consistently beats all human participants in live contests of competitive programming: in the most recent three Codeforces live competitions, i.e., Round1087 (Mar 21, 2026), Round~~1088 (Mar 28, 2026), and Round~~1089 (Mar 29, 2026), GrandCode placed first in all of them, beating all human participants, including legendary grandmasters. GrandCode shows that AI systems have reached a point where they surpass the strongest human programmers on the most competitive coding tasks.

Ornith Team, Xiaoya Li, Guoyin Wang +3

DeepReinforce Team

RL for Code Generation Agentic RL Group Relative Policy Optimization Competitive Programming Multi-Agent Reinforcement Learning

Ask PDF

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