From LLMs to Agents in Programming: The Impact of Providing an LLM with a Compiler

TL;DR

This study probes whether giving LLMs access to a compiler turns them into active, iterative agents capable of producing runnable C programs. By evaluating 16 LMs (135M–70B) on 699 RosettaCode tasks and enabling up to five compiler-guided iterations with gcc, it shows compiler feedback raises executable-program generation by 5.3–79.4 percentage points while largely preserving semantic and textual similarity to ground-truth solutions. Notably, smaller models like Qwen 3 (4B) can outperform larger counterparts when paired with compilation feedback, suggesting tool-assisted approaches can reduce the need for very large models and lower energy footprint. The results emphasize the value of integrating software-engineering tools into LLM workflows and outline patterns in errors that are most amenable to correction through explicit compiler feedback.

Abstract

Large Language Models have demonstrated a remarkable capability in natural language and program generation and software development. However, the source code generated by the LLMs does not always meet quality requirements and may fail to compile. Therefore, many studies evolve into agents that can reason about the problem before generating the source code for the solution. The goal of this paper is to study the degree to which such agents benefit from access to software development tools, in our case, a \texttt{gcc} compiler. We conduct a computational experiment on the RosettaCode dataset, on 699 programming tasks in C. We evaluate how the integration with a compiler shifts the role of the language model from a passive generator to an active agent capable of iteratively developing runnable programs based on feedback from the compiler. We evaluated 16 language models with sizes ranging from small (135 million) to medium (3 billion) and large (70 billion). Our results show that access to a compiler improved the compilation success by 5.3 to 79.4 percentage units in compilation without affecting the semantics of the generated program. Syntax errors dropped by 75\%, and errors related to undefined references dropped by 87\% for the tasks where the agents outperformed the baselines. We also observed that in some cases, smaller models with a compiler outperform larger models with a compiler. We conclude that it is essential for LLMs to have access to software engineering tools to enhance their performance and reduce the need for large models in software engineering, such as reducing our energy footprint.

Figures (7)

• Figure 1: Three examples of tasks found in RosettaCode
• Figure 2: The number of tasks in each category in our subset of RosettaCode
• Figure 3: The flow of content through the Agent system from the task description to the LM to the compiler (left). An example conversation with two iterations with the agent (right). Where the first iteration starts with the role description given by the system, followed by the task description and the generated program from the LM. The second iteration starts with the description of the errors given by the compiler. Each interaction and related step in the agent flow is mapped with a number. (1) The initial role and task description, (2, 4) the generated program from the LM, (3) feedback from the compiler with an error message.
• Figure 4: Rate of programs that would successfully compile by all models per iteration.
• Figure 5: The difference in tasks that the agents generated executable programs for compared to the baselines.