MPCO: Meta-Prompted Code Optimization

• Meta-Prompted Code Optimization is a framework that treats prompt design as an optimization problem, enabling adaptive prompt synthesis for multi-LLM systems.
• It leverages methods like beam search, reinforcement learning, and evolutionary strategies to optimize prompt representations and workflows for automated code rewriting.
• Empirical studies show significant improvements in runtime and functional correctness, though challenges remain in evaluation cost and prompt transfer across models.

Searching arXiv for the cited MPCO-related papers and closely related prompt/code optimization work. Meta-Prompted Code Optimization (MPCO) denotes a family of methods in which prompt design for code generation or code optimization is itself treated as an optimization problem rather than a fixed prompt-engineering choice. In its explicit industrial formulation, MPCO is an end-to-end framework in which a meta-prompter LLM synthesizes model-adaptive optimization prompts from project, task, and model context, and those prompts are then used by downstream optimizer LLMs to rewrite profiled bottlenecks under automated compilation, testing, benchmarking, and statistical ranking (Gong et al., 2 Aug 2025). More broadly, adjacent work suggests a wider interpretation in which the optimized object may be a symbolic prompt program, a prompt sequence, a workflow in code space, a prompt-agent system prompt, or a reusable prompt codebook rather than a single flat instruction string (Schnabel et al., 2024, Yu et al., 8 Aug 2025, Zhu et al., 11 Aug 2025, Tao et al., 3 Jun 2026, Nath et al., 27 May 2026).

1. Definition and conceptual scope

In the narrow sense established by TurinTech AI’s Artemis deployment, MPCO addresses the cross-model prompt engineering challenge in industrial code optimization: prompts optimized for one LLM often fail with others, making manual prompt maintenance a scaling bottleneck in multi-LLM systems (Gong et al., 2 Aug 2025). The framework therefore separates a meta-prompter LLM, which generates a prompt, from a downstream optimizer LLM, which receives that generated prompt together with a target code snippet and produces optimized code. The optimized artifact is not the model weights, but the instruction that steers code rewriting.

The broader research context suggests that MPCO is not exhausted by one-step prompt synthesis. Several papers replace the view of a prompt as a monolithic string with richer abstractions: a prompt may be a symbolic metaprompt DAG optimized at compile time (Schnabel et al., 2024), a multi-step prompt sequence selected by Monte Carlo Tree Search for optimization-oriented code generation (Yu et al., 8 Aug 2025), an executable agentic workflow in Python forward() functions adapted by language-based meta-learning (Zhu et al., 11 Aug 2025), or a prompt-agent system prompt that is itself optimized through open-ended evolutionary search (Tao et al., 3 Jun 2026). This suggests a useful umbrella definition: MPCO concerns optimization of the prompted code-producing process, not only the final prompt text.

A common misconception is that MPCO is simply ordinary prompt engineering for coding tasks. The available work points in a different direction. The central move is to elevate prompts, prompt sequences, or prompt-conditioned workflows into first-class optimization variables with explicit search, evaluation, and update procedures (Ye et al., 14 Mar 2025, Esfahani et al., 18 May 2026). Another misconception is that MPCO necessarily means optimizing code directly. Several relevant systems instead optimize the prompt policy, workflow, or symbolic prompt representation that governs downstream code generation, repair, or performance optimization (Zhu et al., 11 Aug 2025, Nath et al., 27 May 2026).

2. Optimization targets and representations

A defining property of MPCO is the representation chosen for the object being optimized. In SAMMO, a metaprompt $\pi$ is represented as a directed acyclic function graph $G_\pi$ with node function types $\psi_v$, static parameters $\theta_v$, and render-time composition, so that prompt optimization becomes combinatorial search over graph structure, node parameters, and text content rather than over a flat string (Schnabel et al., 2024). The paper explicitly frames this as compile-time optimization of prompt programs and contrasts it with run-time adaptation. This is especially relevant to MPCO because code-generation prompts often contain instructions, few-shot examples, formatting directives, retrieved context, or DSL descriptions that are naturally modular.

Other work pushes the representation even further away from a single string. AdaptFlow represents workflows directly in code space as executable programs, specifically Python forward() functions containing modules such as diverse agents, answer extraction, consensus, verification, clarification, synthesis, and task-specific checks (Zhu et al., 11 Aug 2025). In that setting, the optimized object includes prompt templates, tool invocations, control logic, and reflection routines. Prompt Codebooks (PCO) replaces a monolithic prompt with a finite codebook $\mathcal{C}=\{c_1,\dots,c_K\}$ of “natural-language instincts,” a router that selects $S$ entries per input, and a generator that composes them into a final prompt, making the deployed prompt an instance-conditional composition rather than a task-wide constant (Nath et al., 27 May 2026).

A different but related abstraction appears in “Prompt Less, Smile More,” where Meaning Typed Programming (MTP) and Semantic Context Annotations (SemTexts) shift prompt optimization upstream into the semantic representation of code (Dantanarayana et al., 24 Nov 2025). There the optimized object is not the prompt string directly, but the code semantics and enriched MT-IR$^*$ from which prompts are automatically generated. This suggests that MPCO can also operate through semantic source transformation: optimizing the substrate that deterministically or semi-deterministically generates prompts.

These representational choices matter because they determine what kinds of edits are possible. A flat-string optimizer can paraphrase or compress, but a structured representation can also change section format, data serialization, few-shot cardinality, routing policy, module order, or workflow architecture (Schnabel et al., 2024, Zhu et al., 11 Aug 2025).

3. Search, learning, and update mechanisms

MPCO methods use several distinct optimization regimes. SAMMO is black-box and gradient-free: it assumes a closed LLM API with no probabilities and no gradients, and searches over mutators that can act on text attributes, non-text attributes, and graph structure (Schnabel et al., 2024). When mutators are finite, it can use enumerative search; when they are infinite, it can use iterative procedures such as beam search, breadth-first search, or regularized evolutionary search. In prompt compression, SAMMO uses beam search “as the backbone,” with mutators sampled uniformly at random.

Prochemy uses an offline prompt-refinement loop for code generation and code translation. Starting from an initial prompt $S^{(0)}$, it generates mutated candidates $P^{(k)}$, evaluates each on a small training set using pass/fail execution feedback, scores prompts by a weighted sum $W_S(P_i^{(k)})=\sum_j w_j \cdot M_{ij}$, and iterates until score stagnation or a maximum iteration limit is reached (Ye et al., 14 Mar 2025). The output is a single final optimized prompt $G_\pi$0 reused at inference. This is task-level prompt compilation rather than per-instance adaptation.

MCTS-OPS treats prompt construction for code synthesis as a sequential decision process over decomposed problem sentences, with node selection governed by the UCT rule

$G_\pi$1

and reward determined by execution and evaluator scoring (Yu et al., 8 Aug 2025). The prompt units are generated online, stored as prompt-score pairs, and searched by Monte Carlo Tree Search rather than chosen from a fixed template set. This is especially relevant to optimization-code generation because correctness alone is insufficient; the reward incorporates executability, objective satisfaction, constraint satisfaction, and closeness to an optimal or expected value.

Reinforcement-learning formulations also appear. “Prompt Optimization for LLM Code Generation via Reinforcement Learning” models prompt refinement as a sequential decision-making problem with a PPO agent acting over three prompt-transformation operators: Direct Generation, Lexical Mutation, and Semantic Rewriting (Esfahani et al., 18 May 2026). State is a 384-dimensional MiniLM embedding of the current prompt, and reward is shaped from unit-test pass ratio:

$G_\pi$2

This formulation is narrower than full MPCO, but it shows that prompt-edit scheduling can be learned as a policy rather than hand-coded.

SePO adds a self-referential variant. It optimizes not only task-agent prompts but also the prompt agent’s own system prompt under open-ended evolutionary search with an archive of stepping stones (Tao et al., 3 Jun 2026). The parent prompt is sampled from the archive using a tempered, child-count-penalized softmax, children are admitted under a keep_better rule, and training is split into pre-training on a multi-task pool and fine-tuning on a target task. This suggests that MPCO can be recursive: the optimizer for coding prompts can itself become an optimization target.

4. Evaluation signals and objective functions

MPCO is distinguished from generic prompt engineering by its dependence on external evaluation rather than textual plausibility alone. In the industrial MPCO system on Artemis, generated repository variants are subjected to compilation, unit testing, repeated performance benchmarking, runtime metric collection, and statistical significance analysis (Gong et al., 2 Aug 2025). The main reported outcome is percentage runtime improvement, with ranking determined by descending mean \%PI and grouped by Mann-Whitney U significance or Cohen’s $G_\pi$3 thresholds. Only functionally correct, executable variants are retained.

Several adjacent methods use explicit execution-based rewards. MCTS-OPS executes generated Python scripts and assigns reward $G_\pi$4 for syntax or runtime failure; otherwise an evaluator LLM returns a score from 0 to 10 based on executability, objective achievement, constraint satisfaction, and closeness to an optimal or expected value (Yu et al., 8 Aug 2025). The RL prompt-optimization paper computes pass ratio

$G_\pi$5

from unit tests and reports both strict Pass@1 and SoftPass@1 (Esfahani et al., 18 May 2026). SePO evaluates MBPP by executing predicted programs against hidden tests and scoring by pass@1 averaged across repeats (Tao et al., 3 Jun 2026).

Objective design varies by use case. Prompt compression in SAMMO uses a multi-objective formulation that reduces token cost while constraining accuracy degradation and parse error rate (Schnabel et al., 2024). Industrial MPCO focuses on runtime performance of optimized repository variants (Gong et al., 2 Aug 2025). AdaptFlow uses task metrics such as pass@1 for HumanEval and MBPP, F1 for HotpotQA and DROP, and solve rate for math (Zhu et al., 11 Aug 2025). These differences indicate that MPCO is not tied to a single metric; its essential property is that prompt or workflow changes are optimized against downstream code-relevant signals.

A plausible implication is that MPCO becomes stronger as evaluators become richer. Theoretical work on the Meta-Prompting Protocol proposes a Generator–Auditor–Optimizer topology in which the auditor produces both a scalar score $G_\pi$6 and a textual critique $G_\pi$7, yielding a semantic loss $G_\pi$8 that functions as a textual gradient (Fu, 17 Dec 2025). The paper is primarily theoretical, but it clarifies a general pattern already visible elsewhere: code-oriented MPCO benefits from execution-grounded scalar feedback plus localized natural-language critique.

5. Empirical evidence across coding and optimization tasks

The most explicit MPCO evaluation is the industrial study on five real-world codebases—BitmapPlusPlus, Llama.cpp, RPCS3, Faster-Whisper, and Langflow—using GPT-4o, Gemini 2.5 Pro, and Claude 3.7 Sonnet as optimizer LLMs (Gong et al., 2 Aug 2025). Across 50 optimization targets and 366 hours of runtime benchmarking, MPCO achieves the best average statistical rank across systems and reaches up to 19.06% mean runtime improvement on BitmapPlusPlus in the main comparison. It ranks first on all five systems, with mean improvements of 19.06%, 7.84%, 4.44%, 5.64%, and 9.01% respectively. The paper also reports that 96% of the top-performing optimizations stem from meaningful edits rather than trivial changes.

Closely related prompt-optimization systems show consistent benefits on code-generation benchmarks. Prochemy improves zero-shot baselines on HumanEval by 5.0% for GPT-3.5-Turbo and 1.9% for GPT-4o, and on AVATAR code translation boosts GPT-4o from 74.5 to 84.1 for Java-to-Python and from 66.8 to 78.2 for Python-to-Java (Ye et al., 14 Mar 2025). The PPO-based RL framework reports MBPP+ strict Pass@1 of 57.58%, 64.80%, and 85.50% for CodeT5+, CodeLLaMA, and DeepSeek-Coder, outperforming EPiC, Reflexion, and Random-Hybrid (Esfahani et al., 18 May 2026). SePO-Generalist reaches 96.20 on MBPP, compared with 91.20 for Manual-CoT, 90.15 for TextGrad, and 89.30 for MetaSPO (Tao et al., 3 Jun 2026).

Workflow-level optimization also shows strong coding results. AdaptFlow reaches 94.7 pass@1 on HumanEval and 84.0 on MBPP, tying AFlow on HumanEval and slightly exceeding it on MBPP while outperforming manually crafted and automatically searched baselines overall (Zhu et al., 11 Aug 2025). “Prompt Less, Smile More” shows that MTP plus SemTexts nearly closes or surpasses the gap to manual prompt engineering on code-centric tasks: on Aider Genius, GPT-4o rises from 9.667% with plain MTP to 18.667% with MTP+SemTexts, close to 19.667% with manual prompt engineering, while requiring far fewer lines of added or modified code (Dantanarayana et al., 24 Nov 2025).

For optimization-code generation specifically, LLaMoCo shows that moving knowledge into model weights can reduce prompt fragility. A fine-tuned CodeGen 350M model achieves optimization performance 81.843%, outperforming GPT-4 Turbo at 74.248% on the authors’ evaluation set, and the framework reports a final instruction dataset of 32,570 prompt/code pairs built from synthetic and diversified optimization instances (Ma et al., 2024). Although LLaMoCo is not itself an MPCO method, it establishes that code-to-code optimizer synthesis is highly sensitive to prompt formulation and domain knowledge.

6. Limitations, design trade-offs, and research directions

The literature identifies several recurring limitations. First, evaluation cost is high. Industrial MPCO depends on repeated compilation, testing, benchmarking, and significance analysis (Gong et al., 2 Aug 2025). MCTS-OPS incurs large token costs because each simulation requires decomposition, prompt generation, prompt scoring, code generation, execution, and possibly revision (Yu et al., 8 Aug 2025). RL-based prompt optimization repeatedly calls frozen code models and executes test suites (Esfahani et al., 18 May 2026). Search-based systems therefore require enough downstream reuse to amortize the optimization budget.

Second, transfer is uneven. The industrial MPCO paper explicitly shows that prompts optimized for one model may degrade badly on another; for Llama.cpp, GPT-4o achieves 116.1s with its own prompt template but worsens to 143.4s with Claude’s template and 149.8s with Gemini’s template (Gong et al., 2 Aug 2025). SAMMO’s RAG experiments likewise find only weak correlation of candidate scores across LLMs, suggesting target-specific compilation (Schnabel et al., 2024). This argues against assuming prompt portability across model backends.

Third, representation and feedback quality constrain what can be optimized. Some systems operate only on flat prompts and cannot express instance-conditional behavior. Prompt Codebooks argues that monolithic, instance-blind methods are “structurally inexpressible” for tasks requiring different prompt compositions for different inputs (Nath et al., 27 May 2026). Other systems optimize workflows but rely on free-form textual critique, which may be vague or unstable (Zhu et al., 11 Aug 2025). Theoretical work on adversarial prompt protocols suggests that blind auditing, critique clustering, regression testing, and version control are needed to keep prompt optimization observable and resistant to failure accumulation (Fu, 17 Dec 2025).

Fourth, current coding objectives are usually narrow. MBPP and HumanEval focus on functional correctness under tests; industrial MPCO focuses on runtime performance; prompt compression focuses on token cost; optimization-code generation focuses on solver quality (Gong et al., 2 Aug 2025, Esfahani et al., 18 May 2026, Ma et al., 2024). A plausible implication is that mature MPCO systems will need composite objectives over correctness, speed, robustness, safety, maintainability, and cost. Some precursor ideas already exist: SAMMO scalarizes metrics such as accuracy and token cost (Schnabel et al., 2024), and the Meta-Prompting Protocol explicitly allows rule sets $G_\pi$9 to include correctness, style, safety, and efficiency criteria (Fu, 17 Dec 2025).

Finally, there is a historical analogue outside LLM prompting. “Learning to superoptimize programs” shows that code optimization improves when the proposal distribution over rewrites is learned from prior optimization trajectories rather than fixed by hand (Bunel et al., 2016). MCompiler similarly demonstrates that a meta-controller choosing different optimizers for different loop nests can outperform any single compiler, with learned routing coming within 4% for auto-vectorized code and 8% for auto-parallelized code of profiling-based oracle search (Shivam et al., 2019). These systems do not optimize prompts, but they reinforce a general principle central to MPCO: optimizing the optimizer’s search bias or routing policy can be as important as optimizing the final artifact itself.

Taken together, these works define MPCO less as a single algorithm than as a systems paradigm. Prompts, prompt programs, prompt sequences, workflow code, and prompt-agent instructions become programmable optimization objects; code generation and code optimization become downstream behaviors measured by execution, benchmarking, or structured evaluation; and meta-level controllers search, learn, or evolve better instruction policies under task-specific objectives (Gong et al., 2 Aug 2025, Schnabel et al., 2024, Zhu et al., 11 Aug 2025, Tao et al., 3 Jun 2026).