How Code Intelligence Is Evolving: From Foundation Models to Repository‑Level Agents

Background: Evolution of Code Foundation Models

Since 2021 code‑generation models have progressed from early completion tools such as CodeBERT, Code‑GPT and OpenAI CodeX to a rapid expansion period (2022‑2023) that introduced StarCoder, CodeLlama, Magicoder and WizardCoder. From 2024 onward large‑scale models (Qwen, DeepSeek, GLM, Kimi K2) dramatically increased parameter counts and achieved breakthroughs in logical reasoning and long‑context handling, even spawning diffusion‑based code generators and domain‑specific agents.

Core Technical Optimizations

Verifiable‑Reward Reinforcement Learning (Dr. GRPO)

Standard GRPO applies length‑normalisation, which dilutes updates for long answers and biases the model toward short responses. Dr. GRPO removes length normalisation and corrects standard‑deviation normalisation, giving equal weight to updates regardless of answer length and stabilising reward scaling. Experiments show improved token efficiency and higher reward scores.

Policy Entropy in Inference

Policy entropy quantifies uncertainty in the action distribution. High entropy encourages exploration of diverse code‑generation paths, while low entropy focuses on the current best action. Maintaining moderate entropy prevents premature convergence to local optima and balances exploration‑exploitation during reasoning.

Off‑Policy Learning and SFT+RL Synergy

To mitigate RL’s weakness on extremely hard problems, a small amount of supervised fine‑tuning (SFT) is interleaved with RL. When RL fails to find a solution, high‑quality Chain‑of‑Thought (CoT) answers are stored in a buffer and used for additional SFT, forming a “hard‑problem SFT” loop that guides the model past reasoning bottlenecks.

Scaling Laws and Multilingual Pre‑training

Over 1,000 experiments reveal a scaling‑law matrix across programming languages. The loss for a target language can be expressed as:

Loss_target = f(ModelSize, α_language, Σ_{source} β_{source→target})

where α_language is a language‑specific scaling exponent and β_{source→target} are cross‑language transfer coefficients. Python provides universal positive transfer to most languages; object‑oriented languages such as Java and C# exhibit strong mutual transfer. This formula enables precise data‑allocation strategies for future training.

LoopCoder: Architecture Innovation

LoopCoder introduces a “Dense‑to‑Loop” technique that iterates the entire weight set twice, effectively doubling logical depth without a proportional increase in parameters. The 40B‑Loop variant demonstrates “over‑thinking” capabilities: it dynamically verifies and optimises generated code, converging faster and achieving higher scores on benchmarks such as SWE‑bench Verified compared with static dense architectures.

Rigorous Evaluation Frameworks

Beyond function‑level tests (HumanEval), the team built multi‑dimensional industrial‑grade benchmarks:

IFEvalCode : Enforces strict generation constraints across eight programming languages and bilingual prompts (e.g., palindrome variable names, prohibited loop constructs).

M²G‑Eval : Provides line, block, function, class, file, and cross‑file level assessments, reflecting real‑world software‑engineering challenges.

CodeSimpleQA : A 6.69 M‑instruction dataset covering OS, networking, databases, etc., to evaluate factual correctness and mitigate hallucinations.

Code‑MT‑Bench : Extends single‑turn generation with beam‑search to test multi‑turn dialogue, bug‑fixing, and logical optimisation capabilities.

Code Agents: Repository‑Level Intelligence

Two paradigms are explored:

Workflow‑based agents : Fixed pipelines with low inference cost but limited intelligence.

Autonomous agents : Flexible tool calls and self‑planning, offering higher capability ceilings.

For repository‑level tasks such as error localisation and cross‑file modifications, the model is trained with SFT/RL integrated via mechanisms like RepoReflection , enabling self‑feedback and iterative improvement. Multi‑language collaboration is achieved by assigning each agent a specific language and allowing discussion and voting, transferring knowledge from high‑resource languages (e.g., Python) to low‑resource ones (e.g., HarmonyOS language).

Multimodal Simulation and Visual Evaluation

The V‑GameGym framework evaluates generated code on three axes: code correctness, visual aesthetics, and interactive dynamics. For example, a model can generate a fully functional “Flappy Bird” game, which is then judged by a multimodal model for visual quality.

Open‑Source Contributions and Outlook

The Qwen‑Coder series (including Qwen2.5‑Coder with 18 T tokens and 128 K context) leads multiple leaderboards. The OpenCoder project releases the entire data‑processing pipeline, 130 filtering rules, 75 B webpages, and 4.5 M high‑quality fine‑tuning samples, lowering the barrier for training code models. These advances demonstrate a shift from simple completion to logical reasoning, multi‑language collaboration, and repository‑scale agents, driven by RL optimisation, scaling laws, architectural innovations, and comprehensive evaluation.