BACE: LLM-based Code Generation through Bayesian Anchored Co-Evolution of Code and Test Populations

Kaushitha Silva; Srinath Perera

cs.NEMar 30, 2026

BACE: LLM-based Code Generation through Bayesian Anchored Co-Evolution of Code and Test Populations

Authors: Kaushitha Silva, Srinath Perera

Organizations: WSO2 Santa Clara, CA, USA

Abstract

Large Language Models (LLMs) have demonstrated impressive capabilities in code generation. While an interactive feedback loop can improve performance, writing effective tests is a non-trivial task. Early multi-agent frameworks, such as AgentCoder, automated this process but relied on generated tests as absolute ground truth. This approach is fragile: incorrect code frequently passes faulty or trivial tests, while valid solutions are often degraded to satisfy incorrect assertions. Addressing this limitation, newer methods have largely abandoned test generation in favor of planning and reasoning based on examples. We argue, however, that generated tests remain a valuable signal if we model them as noisy sensors guided by bayesian updates. To this end, we introduce BACE (Bayesian Anchored Co-Evolution), a framework that reformulates synthesis as a Bayesian co-evolutionary process where code and test populations are evolved, guided by belief distributions that are reciprocally updated based on noisy interaction evidence. By anchoring this search on minimal public examples, BACE prevents the co-evolutionary drift typical of self-validating loops. Extensive evaluations on LiveCodeBench v6 (post-March 2025) reveal that BACE achieves superior performance across both proprietary models and open-weight small language models.

Figures & tables

Figure 1. Ancestral Lineage of a Solution. An illustrative visualization of the BACE co-evolutionary process, tracing the genesis of a candidate solution (

c_{4}

) A flowchart diagram illustrating the co-evolution of code candidates (blue nodes, top) and test cases (orange nodes, bottom). In the code evolution track, candidates

c_0

and

c_1

combine via "Semantic Crossover" to form

c_2

c_2

evolves via "Re-implement" into

c_3

c_3

evolves via "Debug" into the dark blue node

c_4

, labeled "Final Solution." In the test evolution track, tests

t_0

and

t_1

combine via "Complementary Crossover" to form

t_2

t_2

evolves via "Edge Case Gen" into

t_3

. Interactions between tracks are shown with dashed arrows: Code nodes

c_1

and

c_3

point to a test node

t_4

, labeled "Divergence Disc. (

c_1

c_3

)." Finally, feedback arrows labeled "Failure Feedback" point from test nodes

t_2

and

t_4

to the final debugging step that produces

c_4

Figure 2. Functional Equivalence (Blue): Candidates

c_{3}

and

c_{4}

produce identical pass/fail vector across all tests. Functional Redundancy (Orange): Tests

t_{4}

and

t_{5}

induce identical pass/fail vector across all code candidates. A 5x5 matrix where rows are labeled c1 through c5 and columns t1 through t5. Cells contain pass/fail binary data. Rows c3 and c4 are highlighted in blue as functionally equivalent. Columns t4 and t5 are highlighted in orange as functionally redundant. The intersection of the highlights is a darker mixed color.

	GPT-5-Mini				Qwen2.5-Coder:7b				GPT-OSS-120b
Method	Easy	Med	Hard	Overall	Easy	Med	Hard	Overall	Easy	Med	Hard	Overall
Direct	$83.3_{\pm 5.6}$	$48.0_{\pm 10.6}$	$24.3_{\pm 2.7}$	$45.0_{\pm 4.5}$	$38.9_{\pm 5.6}$	$5.3_{\pm 2.3}$	$1.8_{\pm 1.6}$	$11.3_{\pm 1.3}$	$96.3_{\pm 3.2}$	$76.0_{\pm 4.0}$	$26.1_{\pm 1.6}$	$57.5_{\pm 1.3}$
AgentCoder	$92.6_{\pm 3.2}$	$65.3_{\pm 14.1}$	$35.1_{\pm 2.7}$	$57.5_{\pm 4.5}$	$38.9_{\pm 5.6}$	$4.0_{\pm 4.0}$	$2.7_{\pm 2.7}$	$11.3_{\pm 3.3}$	$79.6_{\pm 12.8}$	$69.3_{\pm 2.3}$	$27.0_{\pm 4.7}$	$52.1_{\pm 5.8}$
MapCoder	$85.2_{\pm 3.2}$	$68.0_{\pm 4.0}$	$36.9_{\pm 8.3}$	$57.5_{\pm 4.3}$	–	–	–	–	$46.3_{\pm 11.6}$	$38.7_{\pm 9.2}$	$18.0_{\pm 1.6}$	$30.8_{\pm 5.2}$
CodeSIM	$92.6_{\pm 3.2}$	$77.3_{\pm 8.3}$	$41.4_{\pm 9.5}$	$64.2_{\pm 7.5}$	$64.8_{\pm 8.5}$	$20.0_{\pm 4.0}$	$7.2_{\pm 1.6}$	$24.2_{\pm 2.6}$	$90.7_{\pm 6.4}$	$82.7_{\pm 6.1}$	$46.0_{\pm 7.2}$	$67.5_{\pm 6.5}$
BACE (Ours)	96.3 ±3.2	78.7 ±6.1	44.1 ±10.2	66.7 ±4.4	72.2 ±0.0	26.7 ±2.3	10.8 ±5.4	29.6 ±1.9	100.0 ±0.0	86.7 ±2.3	49.6 ±5.6	72.5 ±2.5

Table 1. Comparison of Pass@1 (%) performance on LiveCodeBench v6 (Post-March 2025) across problem difficulty levels. Results are reported as Average

{}_{\pm\text{Std}}

over 3 runs.

Ablation Configuration	Pass@1 (%)
Direct Prompting (Single Solution)	$26.1_{\pm 1.6}$
Population Sampling (No Evolution):
Filtered Sampling ( $\mathcal{T}_{anc}$ Only)	$29.7_{\pm 0.0}$
Filtered Sampling ( $\mathcal{T}_{anc}$ + Static $\mathcal{T}_{unit}$ )	$33.3_{\pm 5.6}$
Population Evolution:
Code Evolution ( $\mathcal{T}_{anc}$ Only)	$41.4_{\pm 4.1}$

Table 2. Ablation study evaluating the impact of test case strategies on the Hard problem subset (

N=37

) using GPT-OSS-120b. Performance is measured as Pass@1 (%) reported as Average

{}_{\pm\text{Std}}

over 3 runs.

LLM Code Generation

Large language model code generation studies how models translate instructions and context into executable programs and how to make them reliable.

See all 309 papers

Apr 17, 2026

ACE: Self-Evolving LLM Coding Framework via Adversarial Unit Test Generation and Preference Optimization

Large Language Models (LLMs) excel at code generation but remain heavily reliant on large-scale annotated solutions and verification-based supervision, which constrains scalability and hinders sustained self-improvement. Recent solver--verifier frameworks exploit program execution as an automatic supervision signal, but their effectiveness degrades as solvers become moderately strong: verifier-generated tests increasingly confirm semantic correctness rather than exposing the remaining failure modes. We propose ACE, a self-evolving code generation framework based on a solver--adversary architecture that prioritizes active failure discovery through execution-centric supervision. A single LLM alternates between generating candidate programs and producing adversarial unit test inputs optimized to induce execution-level failures, such as runtime errors, exceptions, or non-termination. Supervision is derived solely from execution outcomes: robust programs are selected for supervised fine-tuning, while adversarial tests are optimized via Kahneman--Tversky Optimization using execution-derived preferences. Notably, the entire training loop requires no ground-truth code or external reward models. Experiments on CodeContests, MBPP, and LiveCodeBench demonstrate that ACE consistently outperforms strong solver--verifier baselines, achieving 3--7% absolute gains in pass@1, with larger improvements on out-of-distribution benchmarks, while maintaining competitive or improved inference efficiency.

Yixu Huang, Xinglei Yu, Zhongyu Wei

School of Data Science Fudan University Shanghai, China

Execution-Guided Code Generation Language Model Self-Improvement Automated Test Generation LLM Code Generation

Ask PDF

Mar 16, 2026

Code-A1: Adversarial Evolving of Code LLM and Test LLM via Reinforcement Learning

Reinforcement learning for code generation relies on verifiable rewards from unit test pass rates. Yet high-quality test suites are scarce, existing datasets offer limited coverage, and static rewards fail to adapt as models improve. Recent self-play methods unify code and test generation in a single model, but face a inherent dilemma: white-box access leads to self-collusion where the model produces trivial tests for easy rewards, yet black-box restriction yields generic tests that miss implementation-specific bugs. We introduce Code-A1, an adversarial co-evolution framework that jointly optimizes a Code LLM and a Test LLM with opposing objectives. The Code LLM is rewarded for passing more tests, while the Test LLM is rewarded for exposing more defects. This architectural separation eliminates self-collusion risks and safely enables white-box test generation, where the Test LLM can inspect candidate code to craft targeted adversarial tests. We further introduce a Mistake Book mechanism for experience replay and a composite reward balancing test validity with adversarial difficulty. Experiments on Qwen2.5-Coder models demonstrate that Code-A1 achieves code generation performance matching or exceeding models trained on human-annotated tests, while significantly improving test generation capability.

Aozhe Wang, Yuchen Yan, Nan Zhou +5

Zhejiang University

LLM Code Generation RL for Code Generation Automated Test Generation

Ask PDF

Aug 17, 2026

TDD-Agent: Test-Driven Reasoning for Code Generation

Large Language Models (LLMs) have achieved remarkable progress in code generation, yet ensuring correctness in complex, repository-level tasks remains challenging. Existing approaches often use generated tests as static post-hoc validators, which limits their ability to guide implementation and may introduce misleading feedback when the tests themselves are incomplete or incorrect. In this paper, we introduce TDD-Agent, which operationalizes the test-driven development paradigm for code generation. TDD-Agent first prompts the model to generate executable tests, encouraging it to clarify expected behaviors before implementation, and then performs iterative dual-track refinement over both the generated code and tests using execution feedback. We first isolate the effect of test-first reasoning through a prompt variant TDD-prompt on LiveCodeBench, where it consistently improves upon reasoning-based prompting baselines. Building on this finding, we evaluate the full TDD-Agent framework on RepoEval, a repository-level benchmark, and show that it consistently outperforms retrieval-based and agent-based baselines. Additional analyses show that iterative refinement improves not only code correctness but also the effectiveness of the generated tests, yielding higher pass rates, coverage, and mutation scores, suggesting that tests can serve as evolving reasoning artifacts rather than fixed validators. Our source code is available at https://anonymous.4open.science/r/TDD-Agent-Framework-6370/.

Hongyue Yu, Kefan Li, Jiakun Li +4

National College for Excellent Engineers, Beihang University · School of Computer Science and Engineering, Beihang University · Qingdao Research Institute and Hangzhou Innovation Institute, Beihang University +1

Code Generation Execution-Guided Code Generation Repository-Level Code Generation Automated Test Generation

Ask PDF

Abstract

LLM Code Generation

Explore similar work

ACE: Self-Evolving LLM Coding Framework via Adversarial Unit Test Generation and Preference Optimization

Code-A1: Adversarial Evolving of Code LLM and Test LLM via Reinforcement Learning

TDD-Agent: Test-Driven Reasoning for Code Generation