Paper deep dive
Optimize Cheap, Deploy Strong: Cost-Aware Cross-Tier Transfer for Evolutionary Optimization
Tal Oved, Roi Pony, Oshri Naparstek, Udi barzelay
Intelligence
Status: succeeded | Model: Gemma-4-26B-A4B | Prompt: intel-v1 | Confidence: 91%
Last extracted: 8/16/2026, 3:09:08 AM
Summary
The paper introduces a cost-aware cross-tier transfer method for evolutionary optimization of LLM prompts, decoupling the answering, variation, and deployment roles. By using a cheap model for high-volume fitness evaluation and a strong model for rare variation operations, the method achieves significant cost reductions (5.6-54x) while matching or exceeding the performance of same-tier optimization. The approach leverages upward cross-tier transfer, where prompts evolved on cheap tiers deploy effectively on stronger models.
Entities (14)
Relation Signals (14)
Mrefl → performs → variation_operator
confidence 95% · the variation operator that proposes edits runs on a strong one... Mrefl... variation (rare, token-heavy)
Mtask → performs → fitness_evaluation
confidence 95% · fitness is evaluated by the cheapest model available... Mtask... fitness evaluation (dominant)
Mdep → performs → deployment
confidence 95% · the evolved prompt is deployed zero-shot on the chosen target tier Mdep
GPT-5.5 → servesas → Mrefl
confidence 90% · GPT... reflector gpt-5.5
Claude Sonnet 5 → servesas → Mrefl
confidence 90% · Mixed Claude... reflector Sonnet-5
Gemini 3.1 Pro → servesas → Mrefl
confidence 90% · Gemini... reflector gemini-3.1-pro
Qwen3-8b → servesas → Mtask
confidence 90% · self-hosted Qwen3-8B answerer... Mtask
IFBench → usedin → GEPA
confidence 90% · Across four tasks (IFBench...)
HoVer → usedin → GEPA
confidence 90% · Across four tasks (HoVer)
Cypher Suggestions (0)
No Cypher suggestions yet.
Abstract
Abstract:Evolutionary optimization of LLM prompts and agentic programs (e.g., GEPA) is dominated by fitness evaluation: scoring each candidate runs an answering LLM over a validation set, so the evaluator's price tier dictates total search cost. We restructure that search by decoupling the three roles an LLM plays, running the high-volume answering role on the cheapest tier, reserving a strong model for the rare reflection/variation operator, then exploiting upward cross-tier transfer to deploy the cheaply evolved prompt on a stronger target. We contribute a cost-controlled characterization of when cheap-tier search substitutes for target-tier search, and where it fails. Across four tasks (HotpotQA, IFBench, LiveBench-Math, HoVer) and eleven models in four model families, the resulting prompt matches or exceeds same-tier optimization while placing over 96% of search tokens on the cheapest tier, at 5.6-14x lower search cost, rising to 25-54x where reasoning tiers emit long chains of thought on every fitness call.
Tags
Links
- Source: https://arxiv.org/abs/2608.10694v2
- Canonical: https://arxiv.org/abs/2608.10694v2
Trouble viewing inline? Open PDF directly →
Full Text
106,633 characters extracted from source content.
Expand or collapse full text
Optimize Cheap, Deploy Strong: Cost-Aware Cross-Tier Transfer for Evolutionary Optimization Tal Oved Roi Pony Oshri Naparstek Udi Barzelay IBM Research Thanks: Corresponding author: Tal.Oved@ibm.com. Abstract Evolutionary optimization of LLM prompts and agentic programs (e.g., GEPA) is dominated by fitness evaluation: scoring each candidate runs an answering LLM over a validation set, so the evaluator’s price tier dictates total search cost. We restructure that search by decoupling the three roles an LLM plays, running the high-volume answering role on the cheapest tier, reserving a strong model for the rare reflection/variation operator, then exploiting upward cross-tier transfer to deploy the cheaply evolved prompt on a stronger target. We contribute a cost-controlled characterization of when cheap-tier search substitutes for target-tier search, and where it fails. Across four tasks (HotpotQA, IFBench, LiveBench-Math, HoVer) and eleven models in four model families, the resulting prompt matches or exceeds same-tier optimization while placing over %96\% of search tokens on the cheapest tier, at 5.65.6–×14× lower search cost, rising to 25–×54× where reasoning tiers emit long chains of thought on every fitness call. 1 Introduction Evolutionary computation, population-based gradient-free search inspired by natural selection, has a long track record on problems whose objective is black-box, non-differentiable, or discrete, spanning genetic algorithms (8), genetic programming (11), and neuroevolution (20). Its defining loop is the same everywhere: evaluate a population’s fitness, select, and vary (mutate/recombine). A recurring theme across the field is that fitness evaluation is the cost bottleneck, which has motivated decades of work on surrogate-assisted and multi-fidelity evolutionary algorithms that approximate the expensive objective with a cheaper one (3; 4). Recently, this machinery has been turned on a new discrete artifact: the natural-language prompts and programs that drive large language models (LLMs). In this LLM setting, automated prompt and program optimization has become a practical alternative to manual prompt engineering, beginning with LLM-generated instruction search (29) and now covering declarative multi-stage programs whose instructions and demonstrations are compiled by Bayesian search (10; 17) and textual analogues of gradient descent (26). Evolutionary methods, which maintain a population of candidate prompts, score them by a fitness function, and iteratively mutate/select the best, are among the most effective, with reflective variants using an LLM to read execution traces and propose targeted edits (1; 7; 5; 25). Their central bottleneck is cost, and it is widely reported as such: these methods “require a substantial number of LLM calls and input tokens, making prompt optimization expensive” (27), and the same diagnosis of many round-trips and heavy token volume motivates deliberately lightweight evolutionary search elsewhere (21). The fitness of each candidate is estimated by executing an answering LLM over a validation set; to keep the estimate statistically meaningful, the validation set cannot be small, so evaluation calls overwhelmingly dominate the budget (Section 2). Because those calls run on the target model, optimizing a prompt for a strong/expensive model requires running the entire search on that model, capping population size, generations, and ultimately quality for a fixed budget. Here, we ask a simple question: must the search run on the model we intend to deploy on? We show the answer is no. Our method (Section 3) decouples the three roles an LLM plays inside the evolutionary loop and assigns each its own tier: fitness is evaluated by the cheapest model available, the variation operator that proposes edits runs on a strong one, and the evolved prompt is deployed zero-shot on a stronger target tier, with no mapping, calibration or re-optimization. Upward cross-tier transfer has been observed before for a single weak→ pair (1; 6); we study it systematically across tiers, tasks and families, and turn it into a cost strategy. Why the split is sound: an asymmetry of intelligence. The two search roles make very different demands. The variation operator must propose high-precision edits, reading execution traces and rewriting the prompt, which is the work that rewards a strong model, and it runs only rarely. Fitness evaluation, run on every candidate, need only rank prompts well enough to steer selection rather than estimate any candidate’s deployed quality precisely, which a cheap and noisy evaluator does on the vast majority of comparisons. Spending strength where edits are proposed and cheapness where fitness is merely ranked is therefore complementary rather than a compromise. Two properties follow, and studying them together under controlled cost is our focus. First, cost reduction: answering absorbs over 96%96\% of search tokens while the variation operator is rare (Eq. (4)), so moving only the answering role to the cheapest tier moves almost the whole bill. Existing cost reductions for LLM search cheapen the mutator, cheapen the evaluation of the same target, or route models per query at inference time (22; 28; 27; 3; 4; 2; 16); all of them economize within the tier the prompt will be served on, whereas we change which tier evaluates. Second, zero-shot positive transfer: one cheap search deploys zero-shot across models of very different price and capability, which is notable given the “model drift” that degrades prompts moved laterally (24), and the cheap prompt is often better than the one the target tier optimized for itself, so the saving is not bought with accuracy. Section 6 locates that transferability in the variation operator and reads the explicitness of the prompts it writes (Appendix E). Contributions. • A cost-aware reformulation that treats LLM tier as the fidelity dimension and decouples all three roles a model plays inside the loop, answering, variation, and deployment, studying them jointly as a cost/transfer trade-off (Section 3). • Evidence over four tasks and eleven models in four model families that cheap search matches or beats same-tier optimization at 5.65.6–14×14× lower cost on the Mixed Claude and GPT ladders and 2525–54×54× on Gemini (Section 5). At the limit a zero-API-cost self-hosted Qwen3-8B answerer cuts the bill to the reflector’s alone (under $22 per run) and still matches each paid tier’s own full-cost optimization.11 1 “Zero-API-cost” is exact and deliberately narrow: the model is open-weights and served locally, so its marginal price is $00 in Table 3. It is not free of compute. We served it through a shared internal vLLM (12) gateway whose GPUs we neither own nor meter, so every Qwen dollar figure is API spend only; readers who would have to rent should add their own serving cost, modest for an 8B model at our call volumes but not quantified here. • A characterization of when upward transfer succeeds: a measured explicitness gap in the prompts that transfer positively (Appendix E) and a role ablation locating the effect in the variation operator rather than the evaluator (Appendix C), together with the boundary conditions of near-zero cheap-tier competence below and the prompt-insensitive ceiling above, where prompt optimization of any kind has no headroom (6). 2 Problem Statement and Cost Model Starting point: GEPA’s optimization problem. We build directly on the formulation of 1. A compound AI system Φ pairs textual module prompts Π (instructions ++ demonstrations) with LLM weights Θ , jointly its learnable parameters ⟨Π,Θ⟩Φ , _ ; a task instance (x,m)(x,m) induces an output scored by a metric μ valued in [0,1][0,1], so over a task distribution T the expected score is JT(Π,Θ)=(x,m)∼T[μ(Φ(x,⟨Π,Θ⟩Φ),m)].J_T( , )=E_(x,m) T [μ ( (x; , _ ),\,m ) ]. Because a rollout (an invocation of Φ plus its μ evaluation) is expensive, the sample-efficient form of the learning problem maximizes this score under a rollout budget B: ⟨Π∗,Θ∗⟩Φ , _ =argmax⟨Π,Θ⟩ΦJT(Π,Θ) = _ , _ \,J_T( , ) (1) s.t. #rollouts≤B. .t. \ \#rollouts≤ B. This is Eq. (2) of 1. GEPA keeps the weights frozen and evolves only the prompts by reflective mutation, and standard practice sets the frozen model to the deployment model, θfrozen=θdep _frozen= _dep, so the same LLM answers during search and serves at deployment. Our reformulation: split the frozen model into two roles, both ≠Mdep≠ M_dep. The frozen weights enter Eq. (1)’s optimizer in two distinct places: inside the metric, where every fitness evaluation runs Φ on an answering model; and inside the reflective step, where a variation operator model reads rollout traces and proposes prompt edits. We assign these roles two separate frozen models, a cheap answerer MtaskM_task and a strong reflector MreflM_refl, and let both differ from the deployment model MdepM_dep. Search then maximizes a surrogate objective Jtask(Π)=JT(Π,θtask)J_task( )=J_T( , _task) while the quantity we care about is Jdep(Π)=JT(Π,θdep)J_dep( )=J_T( , _dep), and writing the target as the surrogate plus a residual makes the trade explicit: Jdep(Π)=Jtask(Π)⏟optimized cheaply,under Mtask+Δ(Π)⏟cross-tiertransfer residual,J_dep( )\;=\; J_task( )_ subarraycoptimized cheaply,\\ under M_task subarray\;+\; ( )_ subarrayccross-tier\\ transfer residual subarray, (2) where Δ(Π):=Jdep(Π)−Jtask(Π) ( ):=J_dep( )-J_task( ) is exactly the gap incurred by searching with a cheaper model than we deploy on: we optimize against JtaskJ_task but are graded on JdepJ_dep. Two transfer quantities, kept distinct. The residual Δ(Π) ( ) of Eq. (2) is per-prompt, for one fixed prompt, and must not be confused with the cross-run quantities we report. Writing πs∗ _s for the prompt optimized on a cheap source tier s and πt∗ _t for the prompt optimized directly on the target tier t, define the target regret of cheap-tier search, Rs→t=Jt(πt∗)−Jt(πs∗),R_s→ t=J_t( _t )-J_t( _s ), where s→ts→ t denotes the direction of transfer rather than an order of arguments. For plotting we also name the residual in “higher is better” orientation and its scale-free form, δs→t=−Rs→t,δ%s→t= 100⋅δs→tJt(πt∗), _s→ t\;=\;-R_s→ t, δ^\%_s→ t\;=\;100· _s→ tJ_t( _t ), (3) so δ%s→t>0δ^\%_s→ t>0 means the cheaply-searched prompt beat full same-tier optimization, and normalizing by Jt(πt∗)J_t( _t ) removes differing score magnitudes across tasks and tiers. Our core empirical claim is low Rs→tR_s→ t at substantially lower search cost. The two hypotheses we test. Both are claims about the measured Rs→tR_s→ t, which is end-to-end: selection, the pool the mutator proposed and the deployment tier’s own capability all enter it. • Zero-shot transfer (weak claim). Rs→t≈0R_s→ t≈ 0: the cheaply-evolved prompt is near-optimal on the deployment model, with no mapping, calibration or re-optimization. • Zero-shot positive transfer (strong claim). Rs→t<0R_s→ t<0: it beats the prompt the target tier optimized for itself, so transfer is not merely lossless but beneficial. As in the transfer-learning usage, “positive” is measured against the no-transfer baseline πt∗ _t , not against the untrained seed, so it is a claim about the search, not about the deployment tier’s raw capability. Sections 5–6 test both and find Rs→tR_s→ t small-to-favorable. Why positive transfer occurs is a separate question, taken up in Section 6. Cost model: why a cheap MtaskM_task is the lever. A search attempts A mutations, each costing one token-heavy MreflM_refl call plus a cheap screening pass over a minibatch of size b; the K≤AK≤ A attempts that survive screening are then scored on the full validation set of size NvalN_val, one MtaskM_task call per (candidate, instance) pair. With c(⋅)c(·) the $/call cost, opt≈ _opt\;≈ (KNval+2Ab)c(Mtask)⏟fitness evaluation (dominant) (KN_val+2Ab)\,c(M_task)_fitness evaluation (dominant) (4) + + A⋅c(Mrefl)⏟variation (rare, token-heavy). A· c(M_refl)_variation (rare, token-heavy). Because Nval≫bN_val b and only a fraction of attempts survive (A/K≈3A/K≈ 3–55 in our runs), the full-validation term dominates and the answering tier sets the budget. Breaking the coupling Mtask=Mrefl=MdepM_task=M_refl=M_dep drives c(Mtask)c(M_task) to the minimum tier, cheapening that dominant term, while MreflM_refl stays strong for a bounded premium (it sits only in the second term, on a small call volume, though at a high enough per-token rate that the premium is real; Section 3) and MdepM_dep is chosen freely at deploy time. The savings are real only if the target regret they buy is small or negative, which is the empirical question the rest of the paper settles. 3 Method: Cost-Aware Cross-Tier Optimization Our method is a drop-in modification to any reflective/evolutionary prompt optimizer (we instantiate it on GEPA (1)). It has three components. (A) Cheap fitness tier. Every candidate prompt is scored by running the cheapest answering model MtaskM_task over the full validation set. The cheap model is not a mathematical surrogate to be calibrated against the target; it is the actual execution environment during search. This makes the dominant term of Eq. (4) as small as possible. (B) Strong variation operator. New candidates are proposed by a strong reflector MreflM_refl that reads execution traces from the cheap model and writes targeted edits: operator quality, not fitness-model quality, drives improvement. What makes a strong model affordable is the volume asymmetry, not a high acceptance rate (the operator fires on all A attempted mutations, 2.72.7–46×46× more often than a candidate is accepted): reflection is under 5%5\% of all search calls in every run (0.080.08–4.95%4.95\%). Those few calls still carry a median 27%27\% of a cheap run’s spend (range 1212–46%46\% over 3636 runs), so the strong reflector is a bounded premium, not a free component. (C) Upward cross-tier deployment. The final evolved prompt is deployed zero-shot on the chosen target tier MdepM_dep (equal to or stronger than MtaskM_task), with no learned mapping, calibration suite, or re-optimization. One search thus amortizes across arbitrarily many deployment tiers. 4 Experimental Setup Tasks. Four tasks, each a faithful port of its GEPA-artifact setup, so that only the models differ: HotpotQA (multi-hop QA; exact-match; DSPy ++ BM25 retrieval, 2-hop program), IFBench (instruction following; graded constraint-satisfaction; 2-stage program), LiveBench-Math (competition math; deterministic LiveBench scorer; single chain-of-thought), and HoVer (3-hop claim verification; binary recall of the gold supporting-document titles; a 4-call retrieval program reusing the BM25 index, with no answer LLM and no LLM judge). They span the task types a cheap answerer could plausibly fail on, so the thesis is tested rather than favorably sampled, and they span the headroom available to prompt optimization at all, from a nearly saturated task to the benchmark where it is most documented, which is what lets us separate our method failing from prompt optimization having nothing to exploit (Appendix F). Figure 1: Quality gap against full-cost optimization of the same tier (y; 00 is parity) versus search-cost reduction (x, log). One point per (task, search arm, deploy tier), 4848 in all. In the shaded half-plane the cheap search won outright. Data in Tables 8–11. Model tiers and methods compared. Tier means price rank (Table 3), not measured capability. Eleven models in four families, each named for the model line that characterizes it, with the prefix Mixed marking a family that draws on more than one vendor. Three are paid ladders of rising price, each with its own strong reflector: Mixed Claude (gpt-4.1-nano → Claude Haiku 4.5 → Claude Sonnet-5; reflector Sonnet-5), an OpenAI answerer under Claude reflection and Claude deployment, GPT (gpt-4.1-nano → gpt-4.1-mini → gpt-5.6-luna; reflector gpt-5.5) and Gemini (gemini-2.5-flash-lite → gemini-3.5-flash → gemini-2.5-pro; reflector gemini-3.1-pro). The Mixed Claude and GPT ladders share the same gpt-4.1-nano answerer, so gpt-4.1-mini also serves as a neutral cross-family deploy target, while the Gemini ladder shares no model with either and is an independent third-vendor replication. The fourth family is mixed in the same sense and is the extreme case: Mixed Qwen, a self-hosted open-weights Qwen3-8B answerer under either paid reflector (Sonnet-5 or gpt-5.5), deployed on the paid mini/Haiku/luna tiers, so the answering role carries no per-token cost at all. Within each family we compare Full-X, full same-tier optimization (Mtask=Mrefl=XM_task=M_refl=X) and our baseline, against Cheap+reflect→X→ X, our method: the family’s cheapest answerer plus its strong reflector deployed zero-shot on Mdep=XM_dep=X. A seed-prompt control (untrained candidate #0, cost $0) is reported on every deploy tier. All runs share identical data, program, metric and budget per task, with caching disabled and n=3n=3 seeds, and “Deploy@X” always evaluates the validation-selected candidate, unchanged, on X’s held-out test set. Prices, per-task budgets and the full protocol are in Appendix A. 5 Results The per-benchmark tables, one per model family, and the cell-by-cell discussion behind them are in Appendix F. This section states what those tables establish and reads the three figures that summarize them. Figure 2: Upward transfer of one cheap prompt, four tasks × three vendor families. Bars are the search tier and the two deployment tiers, in the order named in each panel title; the bold label is the net change. Tier order follows price, not measured quality: in the Gemini family the newer 3.5-flash outscores 2.5-pro on all four tasks. Discussion in Section 5. The headline comparison. A prompt searched with the cheapest answerer and a strong reflector, then deployed one or two tiers up, matches or beats the prompt that same tier optimized for itself at full price. This holds on four tasks, across eleven models in four families, and at every deploy tier we tested: the cheap search is at or above parity in 3636 of the 4848 (task, search arm, deploy tier) deployments, for 5.65.6–14×14× less search cost on the Mixed Claude and GPT ladders and 2525–54×54× less on Gemini, where both reasoning tiers emit long chains of thought on every fitness call. The saving follows the volume: over 96%96\% of search tokens go to answering, so moving that single role to the cheapest tier moves almost the whole bill while strength is still bought where it is rare. At the limit, an open-weights answerer we host ourselves reduces the API bill to the reflector’s alone, under $22 per run, and the resulting prompt still matches each paid tier’s own optimization. Figure 3 collects all 4848 into a single view, read in Section 6. The saving is not a tier discount. Prices alone could explain the saving, so we measure how far they would have to move to erase it. Let λ⋆λ be the cheap-to-deployment price ratio at which the cheap search stops being cheaper (Eq. 5 in Appendix A). It exceeds 11 in 1515 of the 2424 cells with a full-cost own-tier search, so there the cheap composition stays cheaper even at price parity: it emits fewer output tokens, not merely cheaper ones. With quality already at parity it is then the better buy. The full range is 0.500.50–3.463.46, against 0.040.04–0.250.25 in force (Section 9). Quality against cost (Figure 1). Reducing every deployment to a single point makes the trade legible. The vertical axis is the quality gap against that tier’s own full-cost optimization, so parity is exactly the line y=0y=0 and the half-plane above it is where the cheap search wins outright; the horizontal axis is how much cheaper that search was. The points sit on and above parity across two orders of magnitude of cost reduction, and in the minority of cells that fall below it the shortfall is a few points at most. The gap also widens with the strength of the deployment target, which is the direction the cost model of Section 2 predicts and is visible as a slope rather than as an average. Transferability (Figure 2). The same evolved prompt, deployed unchanged on its own search tier and then on both deployment tiers of its family, gains on all twelve task and family pairs at zero extra search cost. Upward transfer is the reliable direction, unlike the degradation reported for lateral transfer between comparable models 24. Price is not a proxy for quality: in 1717 of 7575 adjacent tier pairs the costlier model scores lower, so the costliest tier is not always the best target. And the size of each jump is mostly the deployment model’s own capability applied to the same prompt. The figure shows that nothing breaks on the way up; the load-bearing quantity is the low target regret in Appendix F. median ratio cheap higher Length (tokens) 1.29×1.29× 40/5240/52 Directives / 1k 1.26×1.26× 35/5235/52 Prohibitions / 1k 1.17×1.17× 34/5234/52 Capitalized words / 1k 2.80×2.80× 36/4836/48 Table 1: The cheap search writes the more explicit prompt. Median ratio of the cheap prompt to the full-cost prompt it is paired with, over 5252 pairs. Lexicons and per-run counts in Appendix E. What the evolved prompts look like. The cheap search writes the more explicit prompt. Table 1 pairs every cheap arm against the full-cost prompt of the tier it is deployed on: the cheap prompt is longer and denser in directives, prohibitions and capitalized emphasis, and all four markers move the same way. Section 6 develops the account this supports, that a weak evaluator rewards structure a stronger model then exploits. Ablations and controls. Several controls bound what the result rests on. A zero-optimization row, the untrained seed prompt deployed on each tier at no cost, appears in every table, and it is what separates tasks where prompt optimization has real headroom from tiers already near a prompt-insensitive ceiling. A weak-reflector arm shows that cheapness alone is insufficient and that operator strength is the lever. A 2×22× 2 role ablation separates the two roles the recipe changes together and locates the gain in the reflector (Section 6, Appendix C). A neutral deploy target that no reflector ever saw removes the overlap between a family’s costliest tier and its own reflector, and shows transfer is agnostic to the reflector’s family. Repeating the whole construction with MIPROv2 in place of GEPA shows the effect belongs to the cost-aware setup rather than to one optimizer’s mutation operator (Appendix B). We also report the recurring side of the ledger, the query volume at which a longer prompt’s serving cost would offset the one-time search saving (Appendix D), and the search curves themselves (Appendix H), which rank the cheap arms below the full-cost ones and so make the case for judging these configurations on deployment quality rather than on search traces. Evaluator Reflector @ Haiku $ pts/$ nano (cheap) Haiku (weak) 39.5±7.139.5± 7.1 1.951.95 n/a nano (cheap) Sonnet-5 54.6±1.0¯ 54.6± 1.0 3.113.11 13.013.0 Haiku (full) Haiku (weak) 47.1±4.347.1± 4.3 22.1722.17 0.370.37 Haiku (full) Sonnet-5 56.0±1.056.0± 1.0 28.5228.52 0.620.62 reflector gain, nano eval. +15.1+15.1 +1.16+1.16 13.013.0 reflector gain, Haiku eval. +9.0+9.0 +6.35+6.35 1.421.42 Table 2: Role ablation on IFBench. % constraint-satisfaction at the Haiku deploy tier, mean± over n=3n=3 seeds. The four rows differ only in the two model fields. pts/$ is deploy points per search dollar. Own-tier scores and cost basis in Appendix C. Figure 3: Transfer residual δ%s→tδ^\%_s→ t (Eq. (3)) over 4848 points, 1212 setups × 44 datasets; δ%s→t>0δ^\%_s→ t>0 favours the cheap prompt. Circles are per-setup means, ticks the individual datasets, thin bars their min–max range. Diamonds are per-family and pooled means with 95%95\% t-intervals on those means. Statistics in Appendix G. 6 Analysis Why does a prompt evolved on a weak model transfer upward cleanly, when lateral transfer between models of comparable capability degrades (24)? The variation operator is where transferability is made. Positive transfer is a property of the role composition: a strong variation operator makes the prompt transferable, and a cheap evaluator makes producing it affordable. Table 2 completes the 2×22× 2 on IFBench at identical budget, splits and token caps. The split is one-sided. Upgrading the reflector is worth +15.1+15.1 points at the Haiku deploy tier, and it still pays when the evaluator is already the full-cost one, so cheap evaluation is not what produces the gain. Restoring the full-cost evaluator on top of a strong reflector buys little for a large bill, a 236×236× difference in return per search dollar. The recipe is therefore “strong reflector, weak evaluator” rather than “use cheap models.” Own-tier scores make this an account of transfer rather than of prompt quality: the stronger reflector’s prompt is no better on the tier it optimized against, and much better on a tier neither configuration searched against. The family tables bound the claim. A weak reflector does not yield transferable prompts (Finding 1), and the reflector need not share a vendor with the deployment model (Finding 5). Full table and cost normalization in Appendix C. What the transferable prompt looks like. The composition says where the effect is produced. For why a stronger tier exploits it we offer structural explicitness as a hypothesis. A frontier model bridges logical gaps on its own, so a search run natively on it can settle on an implicitly-coded prompt that leans on the evaluator’s reasoning. A cheap answerer fails on ambiguity instead, so the reflector is pushed toward explicit and rigid prompts: guardrails, spelled-out constraints, edge cases. A frontier model absorbs that clarity easily. So lateral transfer moves a prompt between differing latent biases, and upward transfer moves explicit clarity into a model equipped to use it. The prompts do have that shape, on all four markers at once (Table 1); both arms append validation answers in comparable amounts, so memorization is not what separates them (Appendix J). Two limits apply. This is a correlation, not an ablation. And the pairing differs in both roles, so it cannot separate the weak evaluator forcing the explicitness from the strong reflector writing it, though the factorial favours the reflector. Appendix I lists what would settle it. The residual concentrates on zero. Figure 3 aggregates the method into one picture: every cross-tier deployment we ran, pooled as paired residuals δs→t=−Rs→t _s→ t=-R_s→ t of Eq. (3) in the scale-free form δ%s→tδ^\%_s→ t, so tasks with different score ranges are commensurable. The mean residual is +2.8%+2.8\% of the full-cost score in favour of the cheap search, with a 95%95\% interval above zero. Searching cheaply and deploying upward is to first order outcome-equivalent to paying for full same-tier optimization, at roughly an order of magnitude less cost. Every family’s own mean is positive and all four intervals overlap, so this is a property of the construction rather than of one favourable ladder. The shape matters more than the mean. The downside is bounded and shallow: no setup collapses, and every point is covered once the allowed shortfall reaches about six percent of the full-cost score (Figure 4, Appendix G). The upside carries a genuine right tail, so where prompt optimization still has headroom the cheap prompt wins outright. That asymmetry is what the explicitness account implies: spelled-out instruction is neutral where a tier is already saturated and a multiplier where a strong deployment model has room to exploit it. 7 Related Work Our work sits where three lines meet: discrete evolutionary search, multi-fidelity efficiency, and cross-model prompt transfer. Evolutionary Prompt Optimization. PromptBreeder (5) and EvoPrompt (7) established LLMs as variation operators over the discrete space of natural-language prompts; GEPA (1), which we build on, adds reflective trace-driven mutation, Mage (19) extends it with multi-objective Pareto selection, and OPRO (25) exploits the optimization trajectory as meta-data. GEPA already exposes a separate reflection model, so answerer/reflector decoupling is not by itself new. What stays open is that the answerer, reflector and deployment model are still instantiated at the same tier, so every fitness evaluation scales with the target’s inference cost, and no cost-controlled account establishes when cheap-tier search substitutes for target-tier search. We treat the three as separately chosen axes and characterize that regime. Multi-Fidelity and Computational Efficiency. Cascades that route queries at test time cut inference cost (2; 16), successive halving splits a budget across configurations (14), and surrogate-assisted evolutionary computation approximates an expensive objective with a cheaper one (9; 3; 4). Fidelity there is data-subset size, budget, or a surrogate of the same objective. Cost-aware LLM search does likewise: PMPO cheapens scoring while still running on the target (28), and CAPO and EPiC hold down candidate and call counts (27; 21). A second group instead varies which model acts inside the search, by mutation role (22), by a bandit over generators (13), by generation confidence (18), or by relaying a cheap population to a strong model mid-run (15). Each picks a model for a step, so the strong tier keeps spending search budget. We make fidelity the model tier itself: the cheap model is the actual execution environment during search, strength is reserved for the rare variation operator, and the deployment model changes with no calibration to the target. Cross-Model Transferability. Prompt portability is limited by “model drift” (24): lateral transfer between models of comparable capability degrades sharply, and while soft-prompt transfer addresses embedding shifts (23), discrete prompts are usually assumed model-specific. Weak→ evidence does exist, in GEPA-Qwen-Opt (1) and in 6, who optimize on Qwen3-4B and deploy on Qwen3-30B, but in both it is an incidental generalization observation on a single model pair rather than a cost strategy. We instead test upward portability systematically and turn the property into an order-of-magnitude cost reduction; we are not aware of prior work combining cheap evaluation, strong mutation and upward deployment as a cost strategy and characterizing when it holds. 8 Conclusion Decoupling the fitness-evaluation tier from the variation operator and from the deployment model turns the dominant cost of evolutionary prompt search into a free parameter. Across four tasks and eleven models in four families, a cheap search with a strong reflector, deployed upward, matches or beats same-tier optimization at 5.65.6–14×14× lower cost, spending over 96%96\% of its search tokens on the cheapest tier, and yields a tier-portable “compile-once, deploy-anywhere” prompt, precisely on the tasks and tiers where prompt optimization has headroom to begin with. Weak→ prompt transfer has been observed before (1; 6); our contribution is to characterize systematically when cheap-tier search substitutes for target-tier search, to show that the substitution is positive rather than merely lossless, and to locate its source in the variation operator rather than in cheap evaluation. 9 Limitations The method is bounded by the cheap tier’s baseline competence. If the cheap model scores ≈0≈ 0 on the task, the fitness landscape is flat (no gradient, no tracebacks, no selection pressure) and search stagnates. The cheap evaluator must achieve at least marginal success given a good prompt. Low-headroom (prompt-insensitive) deployment tiers. The opposite boundary is a target tier already near its prompt-insensitive ceiling. On LiveBench-Math the untrained seed prompt scores 41.5/58.8/72.141.5/58.8/72.1 (nano/mini/luna), within 11–44 points of every optimized method, and validation curves are correspondingly flat (Finding 4). This is a limitation of evolutionary prompt optimization in general rather than of cost-aware transfer: 6 likewise report model/task combinations where an optimized prompt does not beat the untuned base prompt at all. Dependence on the price schedule. Every dollar figure is derived: we measure per-call token counts per model and apply Table 3 as a lookup, so any future schedule can be re-applied without re-running anything. The honest question is not whether the multiplier stays at 5.65.6–14×14× but how far prices would have to move to overturn it, which is what the break-even ratio λ⋆λ of Section 5 measures: the tier gap has to vanish entirely, and in 1515 of 2424 cells even that is not enough. The conclusion is thus contingent on providers offering a tiered lineup at all, not on any specific rate, and it reproduces under three independently set schedules (Anthropic, Azure, Google). References Agrawal et al. (2026) L. A. Agrawal, S. Tan, D. Soylu, N. Ziems, R. Khare, K. Opsahl-Ong, A. Singhvi, H. Shandilya, M. J. Ryan, M. Jiang, et al. GEPA: reflective prompt evolution can outperform reinforcement learning. In International Conference on Learning Representations, Vol. 2026, p. 8479–8565. Cited by: §1, §1, §2, §2, §3, §7, §7, §8. Chen et al. (2023) L. Chen, M. Zaharia, and J. Zou FrugalGPT: how to use large language models while reducing cost and improving performance. Transactions on Machine Learning Research. Cited by: §1, §7. Chen et al. (2026a) M. Chen, B. Xiao, D. Liang, C. Zeng, and Z. Wen Efficient hyperparameter optimization for LLM reinforcement learning. In Proceedings of the 64th Annual Meeting of the Association for Computational Linguistics (Volume 1: Long Papers), p. 27540–27552. Cited by: §1, §1, §7. Chen et al. (2026b) Z. Chen, X. Yuan, J. Zhang, J. Dong, R. Zhou, Y. Niu, T. Zhou, Y. Y. F. Liu, Y. Li, N. Ye, and Q. Gu LABO: LLM-accelerated bayesian optimization through broad exploration and selective experimentation. In International Conference on Machine Learning (ICML), Cited by: §1, §1, §7. Fernando et al. (2024) C. Fernando, D. Banarse, H. Michalewski, S. Osindero, and T. Rocktäschel Promptbreeder: self-referential self-improvement via prompt evolution. In International Conference on Machine Learning (ICML), Cited by: §1, §7. Gao et al. (2026) Z. Gao, B. Liu, T. Joachims, K. Brantley, W. Sun, et al. p1p1: Better prompt optimization with fewer prompts. arXiv preprint arXiv:2604.08801. Cited by: 3rd item, §1, §7, §8, §9. Guo et al. (2024) Q. Guo, R. Wang, J. Guo, B. Li, K. Song, X. Tan, G. Liu, J. Bian, and Y. Yang Connecting large language models with evolutionary algorithms yields powerful prompt optimizers. In International Conference on Learning Representations (ICLR), Cited by: §1, §7. Holland (1975) J. H. Holland Adaptation in natural and artificial systems. University of Michigan Press, Ann Arbor, MI. Cited by: §1. Jin (2011) Y. Jin Surrogate-assisted evolutionary computation: recent advances and future challenges. Swarm and Evolutionary Computation 1 (2), p. 61–70. Cited by: §7. Khattab et al. (2024) O. Khattab, A. Singhvi, P. Maheshwari, Z. Zhang, K. Santhanam, S. Vardhamanan, S. Haq, A. Sharma, T. T. Joshi, H. Moazam, H. Miller, M. Zaharia, and C. Potts DSPy: compiling declarative language model calls into state-of-the-art pipelines. In International Conference on Learning Representations (ICLR), Cited by: §1. Koza (1992) J. R. Koza Genetic programming: on the programming of computers by means of natural selection. MIT Press, Cambridge, MA. Cited by: §1. Kwon et al. (2023) W. Kwon, Z. Li, S. Zhuang, Y. Sheng, L. Zheng, C. H. Yu, J. E. Gonzalez, H. Zhang, and I. Stoica Efficient memory management for large language model serving with pagedattention. In Proceedings of the 29th ACM Symposium on Operating Systems Principles (SOSP), Cited by: footnote 1. Lange et al. (2026) R. T. Lange, Y. Imajuku, and E. Cetin ShinkaEvolve: towards open-ended and sample-efficient program evolution. In International Conference on Learning Representations (ICLR), Cited by: §7. Li et al. (2018) L. Li, K. Jamieson, G. DeSalvo, A. Rostamizadeh, and A. Talwalkar Hyperband: a novel bandit-based approach to hyperparameter optimization. Journal of Machine Learning Research 18 (185), p. 1–52. Cited by: §7. Luo et al. (2026) S. Luo, Y. Huang, G. Deng, H. Wang, H. Luo, L. Li, Z. Hu, J. Feng, and Q. Liu Relay, don’t route: adaptive population handoff for cost-efficient LLM-driven evolution. arXiv preprint arXiv:2608.05651. Cited by: §7. Ong et al. (2025) I. Ong, A. Almahairi, V. Wu, W. Chiang, T. Wu, J. E. Gonzalez, M. W. Kadous, and I. Stoica RouteLLM: learning to route LLMs with preference data. In International Conference on Learning Representations (ICLR), Cited by: §1, §7. Opsahl-Ong et al. (2024) K. Opsahl-Ong, M. J. Ryan, J. Purtell, D. Broman, C. Potts, M. Zaharia, and O. Khattab Optimizing instructions and demonstrations for multi-stage language model programs. In Proceedings of the 2024 Conference on Empirical Methods in Natural Language Processing (EMNLP), Cited by: Appendix B, §1. Ray et al. (2026) P. Ray, P. P. Brahma, Z. Liu, and E. Barsoum AdaptEvolve: improving efficiency of evolutionary AI agents through adaptive model selection. In Findings of the Association for Computational Linguistics: ACL 2026, p. 40625–40633. Cited by: §7. Singh (2026) P. Singh MAGE: understanding stability-performance trade-offs in multi-component prompt optimization. arXiv preprint arXiv:2607.11944. Cited by: §7. Stanley and Miikkulainen (2002) K. O. Stanley and R. Miikkulainen Evolving neural networks through augmenting topologies. Evolutionary Computation 10 (2), p. 99–127. Cited by: §1. Taherkhani et al. (2024) H. Taherkhani, M. Sepindband, H. V. Pham, S. Wang, and H. Hemmati Automated prompt engineering for cost-effective code generation using evolutionary algorithm. arXiv preprint arXiv:2408.11198. Cited by: §1, §7. Tanveer (2026) T. Tanveer LEVI: stronger search architectures can substitute for larger LLMs in evolutionary search. arXiv preprint arXiv:2605.09764. Cited by: §1, §7. Wang et al. (2025a) X. Wang, J. Xu, F. Boenisch, M. Backes, C. A. Choquette-Choo, and A. Dziedzic Efficient and privacy-preserving soft prompt transfer for LLMs. In International Conference on Machine Learning (ICML), Cited by: §7. Wang et al. (2025b) Y. Wang, Q. Liu, Z. Wang, Z. Li, W. Wei, Y. Liu, and Y. Bao PromptBridge: cross-model prompt transfer for large language models. arXiv preprint arXiv:2512.01420. Cited by: §1, §5, §6, §7. Yang et al. (2024) C. Yang, X. Wang, Y. Lu, H. Liu, Q. V. Le, D. Zhou, and X. Chen Large language models as optimizers. In International Conference on Learning Representations (ICLR), Cited by: §1, §7. Yuksekgonul et al. (2024) M. Yuksekgonul, F. Bianchi, J. Boen, S. Liu, Z. Huang, C. Guestrin, and J. Zou TextGrad: automatic “differentiation” via text. arXiv preprint arXiv:2406.07496. Cited by: §1. Zehle et al. (2025) T. Zehle, M. Schlager, T. Heiß, and M. Feurer CAPO: cost-aware prompt optimization. In International Conference on Automated Machine Learning (AutoML), Cited by: §1, §1, §7. Zhao et al. (2025) C. Zhao, Z. Liu, X. Wang, J. Lu, and C. Ruan PMPO: probabilistic metric prompt optimization for small and large language models. In Findings of the Association for Computational Linguistics: EMNLP, Cited by: §1, §7. Zhou et al. (2023) Y. Zhou, A. I. Muresanu, Z. Han, K. Paster, S. Pitis, H. Chan, and J. Ba Large language models are human-level prompt engineers. In International Conference on Learning Representations (ICLR), Cited by: §1. Appendix A Implementation Details Model Role in out gpt-4.1-nano answerer (Mixed Cl., GPT) 0.100.10 0.400.40 gpt-4.1-mini GPT mid / neutral target 0.400.40 1.601.60 Claude Haiku 4.5 Mixed Cl. mid 0.760.76 3.803.80 Claude Sonnet-5 Mixed Cl. refl. + mid 1.521.52 7.607.60 gpt-5.5 GPT reflector 2.52.5 1515 gpt-5.6-luna GPT mid 11 66 gemini-2.5-flash-lite Gem. answerer 0.100.10 0.400.40 gemini-3.5-flash Gemini mid 1.501.50 9.009.00 gemini-2.5-pro Gemini mid 1.251.25 10.010.0 gemini-3.1-pro Gemini reflector 2.002.00 12.012.0 Qwen3-8B local answerer, unpriced 00 00 Table 3: Per-model token prices (USD per 1M tokens, input/output) and roles, as published at the time of the experiments. Every cost in the paper is computed from these with caching off. Qwen3-8B is served locally, so its marginal token price is $00 and that family’s whole bill is the reflector’s; the serving compute is excluded throughout. No deployment target is priced above its own family’s reflector, which is why we call every deploy tier a mid tier; the out column, not the role label, carries the ordering. Protocol. Identical data (train/val/test), program, metric, and budget per task; only the models differ. Optimizer = GEPA at paper scale, with per-task budgets of HotpotQA 68716871, IFBench 35933593, LiveBench-Math 18391839, and HoVer 70517051 metric calls. n=3n=3 seeds: HotpotQA’s split is seed-dependent (a fresh train/val/test draw per seed), whereas the IFBench, LiveBench-Math, and HoVer splits are fixed, so there the seed varies only GEPA’s search RNG. Optimization cost is exact (per-call token logging × published prices, cache off, a true cost). Costs are therefore reproducible under price revision: the logged quantity is tokens per call per model, and any future price schedule can be applied to every run in this paper without re-execution. Break-even price ratio. Let λ scale the cheap answering tier’s input and output rates together, as a fraction of the deployment tier’s, so λ=1λ=1 is price parity; the ratio in force in our experiments is 0.040.04–0.250.25. Holding the measured token counts fixed, the cheap arm costs λAcheap+Rcheapλ A_cheap+R_cheap, where AcheapA_cheap is its answering tokens priced at the deployment tier’s own rate and RcheapR_cheap its reflector spend, which sits on a third tier and does not move with λ. The full-cost arm costs CfullC_full, independent of λ. Equating the two gives the break-even ratio λ⋆=Cfull−RcheapAcheap,λ = C_full-R_cheapA_cheap, (5) below which the cheap search is the cheaper one. Over the 2424 cells that have a full-cost own-tier search λ⋆λ runs 0.500.50–3.463.46, so the cheap tier’s price would have to rise by 2.72.7–86×86× before a cell turns. In 1515 of the 2424 it exceeds 11: there the cheap arm also emits fewer output tokens over the whole search than the full arm does, so it stays cheaper at parity and the saving is a property of the composition rather than of the price list. In the remaining nine the token volumes are close or reversed, and the saving does rest on some discount. Mixed Claude on HotpotQA deployed at Haiku is a worked case: Cfull=$40.77C_full=\$40.77, Rcheap=$1.97R_cheap=\$1.97 and Acheap=$33.00A_cheap=\$33.00 give λ⋆=1.18λ =1.18, against 0.110.11 in force. Two caveats: λ is a single scalar on both rates, so λ⋆λ idealizes a two-rate price list, and it speaks only to cost. Quality enters separately, through δs→t _s→ t. “Deploy@X” takes the candidate selected by its validation score during search and evaluates it, unchanged, on X over the held-out test set; selection uses validation only, so there is no test-set selection. Uniform measurement conditions. Within every comparison, both prompts are scored on the same held-out test set, through the same harness, at the same output-token cap: 30003000 for HotpotQA, 40004000 for IFBench, 1638416384 for LiveBench-Math and HoVer. Caps differ across benchmarks and we never compare token counts across benchmarks. The prompt evaluated in each cell is the run’s best candidate by mean per-instance validation subscore, the rule used everywhere in this paper. A cap that binds asymmetrically would put the output-token deltas of Table 6 in question, so we measured how often one binds: in eleven of its twelve rows the at-cap rate is at most 8.1%8.1\% and near-symmetric across the two arms. IFBench at 3.53.5-flash binds on 38.3%38.3\% and 37.1%37.1\% of calls, and recomputing that row’s delta over the uncensored calls alone reproduces the full-sample value, so the cap is not what drives it. Deployment parse handling (adaptive-thinking models). One deployment target, gpt-5.6-luna, is an adaptive-thinking model that intermittently omits the chain-of-thought reasoning field DSPy’s structured-output adapter expects, so the adapter rejects a response whose answer field is present. This is a decoding artifact of that one model, absent for every other, and not a failure to solve the task. We therefore recover the intended field from the raw completion, so the parse does what it should. It succeeded on every affected step, so no instance is dropped or scored zero and the luna deploy runs the full multi-hop pipeline on the same 300300-example test set as its baselines. The comparison stays fair and the numbers are clean. Appendix B Optimizer Ablation: MIPROv2 Method opt cost $ cost↓× × test @ nano test @ mini test @ Haiku test @ luna test @ Sonnet Task model Proposer model HotpotQA gpt-5.6-luna gpt-5.6-luna 77.177.1 1.0×1.0× – – – 57.1±1.357.1± 1.3 – Haiku Haiku 79.879.8 1.0×1.0× – – 53.3±3.953.3± 3.9 – 52.7±4.352.7± 4.3 gpt-4.1-mini gpt-4.1-mini 29.629.6 2.7×2.7× – 51.3±2.351.3± 2.3 51.4±2.851.4± 2.8 54.2±1.854.2± 1.8 – nano gpt-5.5 8.58.5 9.4×9.4× 47.4±1.247.4± 1.2 51.2±6.751.2± 6.7 51.9±4.051.9± 4.0 52.7±6.852.7± 6.8 – nano Sonnet-5 9.39.3 8.5×8.5× 47.4±2.447.4± 2.4 52.8±6.252.8± 6.2 54.3±6.454.3± 6.4 57.1±1.257.1± 1.2 60.9±1.860.9± 1.8 IFBench gpt-5.6-luna gpt-5.6-luna 40.740.7 1.0×1.0× – – – 66.1±1.166.1± 1.1 – Haiku Haiku 31.131.1 1.3×1.3× – – 52.4±4.652.4± 4.6 – 72.4±2.172.4± 2.1 gpt-4.1-mini gpt-4.1-mini 10.610.6 3.8×3.8× – 50.5±1.350.5± 1.3 52.6±1.452.6± 1.4 67.1±0.767.1± 0.7 – nano gpt-5.5 2.92.9 14.2×14.2× 42.0±0.442.0± 0.4 51.7±3.551.7± 3.5 55.7±1.955.7± 1.9 70.2±1.070.2± 1.0 – nano Sonnet-5 3.33.3 12.2×12.2× 44.3±0.744.3± 0.7 55.0±1.655.0± 1.6 57.5±3.057.5± 3.0 70.2±1.070.2± 1.0 75.0±1.975.0± 1.9 Table 4: Optimizer ablation: the same decoupling run with MIPROv2 instead of GEPA. The two cheap rows (bold) are the body’s construction with dspy.MIPROv2 in place of GEPA’s reflective mutation. Conventions as in Table 9; “–” == not run on that tier. Configuration and two caveats in the accompanying text. Every result in the body uses GEPA as the evolutionary optimizer, so a natural question is whether the cost-aware decoupling is a property of the setup (cheap answerer, strong proposer, cross-tier deployment) or an artifact of GEPA’s reflective-mutation operator. Table 4 repeats the construction with a structurally different optimizer: dspy.MIPROv2 (17), which performs Bayesian search over instructions and few-shot demonstrations rather than LLM-authored mutations. The role that GEPA fills with a reflection model, MIPROv2 fills with an instruction proposer, so the cheap rows keep the same shape as in the body: a gpt-4.1-nano answerer scored over the validation set, with a strong model called only to propose, and the resulting prompt deployed unchanged on stronger tiers. Configuration. MIPROv2 runs at auto=heavy with 44 bootstrapped and 44 labeled demonstrations, minibatch_size=35=35 and caching off, on the same data, program and metric as the body’s runs; only the optimizer changes. Deploy token caps match the body’s fair-rescore caps: reasoning targets (luna, Sonnet) at 1200012000 tokens and non-reasoning targets (mini, Haiku) at 40004000, with MIPROv2’s own-tier luna runs already using the 1200012000 cap in both roles. The columns span both vendors’ ladders because the MIPROv2 deploy matrix does. What the swap shows. The two cheap configurations are by far the cheapest rows in both benchmark sections, at $2.92.9–$9.39.3 against $10.610.6–$79.879.8 for full same-tier search, and they still take the best mean in seven of the eight deploy columns and draw level in the eighth. Cheap-tier search substituting for target-tier search therefore does not depend on GEPA’s mutation operator. Two caveats on reading the table. First, search cost is not budget-matched to the body’s GEPA runs. MIPROv2’s rollout count is emergent from auto=heavy rather than capped at a metric-call budget, so the $ column is comparable within this table, which is what cost↓× × measures, but not across optimizers. This is an ablation of the mechanism, not an optimizer race, and a per-configuration MIPROv2 versus GEPA head-to-head is outside its scope. Second, not every lead in the table is resolved: the HotpotQA cheap rows carry a ±6± 6–77 point seed spread from nano’s own variance, so their leads there sit within noise, whereas the IFBench leads (1.41.4–3.13.1 std) do not. Appendix C Role Ablation: Which Role Carries the Gain? Evaluator Reflector test @ nano test @ Haiku search $ pts/$ nano (cheap) Haiku (weak) 41.2±2.641.2± 2.6 39.5±7.139.5± 7.1 1.95±0.131.95± 0.13 n/a reference nano (cheap) Sonnet-5 40.2±1.340.2± 1.3 54.6±1.0¯ 54.6± 1.0 3.11±0.173.11± 0.17 13.013.0 our configuration Haiku (full) Haiku (weak) – 47.1±4.347.1± 4.3 22.17±1.4822.17± 1.48 0.370.37 Haiku (full) Sonnet-5 – 56.0±1.056.0± 1.0 28.52±1.5128.52± 1.51 0.620.62 best, 9.2×9.2× the $ reflector contrast @ nano eval. −1.0-1.0 +15.1+15.1 +1.16+1.16 13.013.0 reflector contrast @ Haiku eval. – +9.0+9.0 +6.35+6.35 1.421.42 evaluator contrast @ Sonnet-5 refl. – −1.4-1.4 +25.41+25.41 0.0550.055 Table 5: Role ablation: evaluator × reflector on IFBench, full version. % constraint-satisfaction, mean± std over n=3n=3 seeds; the four configurations differ only in the two model fields. test @ nano is the own-tier score, blank where the evaluator’s own tier is the deploy tier. Search $ is per run, normalized for token-log coverage (see Cost basis). pts/$ is deploy points per search dollar, against row 1 for the configurations and against the paired cell for the contrasts. Our cheap configuration changes two roles at once relative to full same-tier search: the evaluator drops to gpt-4.1-nano and the reflector rises to claude-sonnet-5. Since both move together, no single comparison in the family tables can say which one carries the result. Table 5 completes the 2×22× 2 on IFBench with the two missing cells; Table 2 in §6 is the same experiment abridged, and this appendix adds the own-tier column, the cost normalization and the caveats. All four configurations are identical in budget (35933593 metric calls), splits and token caps; only the two model fields differ. The reflector is the lever, and it buys transfer. Upgrading only the reflector is worth +15.1+15.1 points at the Haiku deploy tier with a cheap evaluator and +9.0+9.0 with a full one, so the gain is not an interaction peculiar to cheap evaluation. The two columns say what kind of gain it is. On the tier it optimized on (test @ nano) the weak-reflector run is not worse: both prompts are equally good at the objective they were selected against. Deployed unchanged on Haiku, a tier neither optimized on, they separate by 1515 points, and the variance separates with them. So the strong reflector does not fit the search environment better; it writes a prompt that survives the move upward. The weak-reflector prompt is specialized to its cheap evaluator, invisibly on-tier and expensively off-tier. That is the mechanism of §6 seen by ablation rather than correlation. A strong reflector alone is not the recommendation. The best cell in the square is the expensive one, Haiku evaluator ++ Sonnet-5 reflector, but only just, and the $ column prices that margin: the reflector upgrade returns 1313 points per dollar, additionally restoring the full-cost evaluator returns 0.0550.055, a ×236× 236 difference. The reason is volume. The evaluator runs on every validation instance of every generation while the reflector fires a few dozen times, so it is >96%>96\% of the tokens (§5). Strength is worth paying for in the reflector and close to worthless in the evaluator. Table 2 states that recipe in the body; this ablation on GEPA is what establishes it. Cost basis. The $ column is normalized, because the four arms were not logged equally well and a partial cost log biases a ratio rather than just adding noise to it. The two pre-existing arms predate a fix to our token accounting and record 74%74\% of their per-call tokens (a completion served from cache skips the logging callback), against >107%>107\% for the two new arms, so we divide each arm’s raw total by its own measured coverage. Normalizing shrinks the expensive/cheap ratio from 12.9×12.9× to 9.2×9.2×, the conservative direction, and puts full-Haiku search at 7.1×7.1× the cheap arm, reproducing the independently measured ∼7× 7× of Table 8. Raw totals are $16.39, $2.39, $2.10 and $30.74 in row order. Appendix D Deployment Break-Even Volume Our savings are a one-time reduction in search cost, whereas a longer evolved prompt costs more on every deployed query, so at high enough volume the recurring cost could erode, or erase, the one-time saving. We measure both sides. From the per-call token logs of the same held-out scorings, we compute the per-query token delta between the cheap-search prompt and the full-cost prompt on the same deploy model, and solve for the break-even volume N⋆=ΔCsearchcquerycheap−cqueryfull,N = C_searchc_query^cheap-c_query^full, (6) the query count at which the two total-cost curves cross. Table 6 reports, for each (benchmark, deploy tier) cell, the one-time search saving ΔCsearch C_search, the per-query input/output token deltas of the cheap-search prompt relative to the full-cost prompt on the same deploy model, and the resulting N⋆N of Eq. (6). What each cell compares. Every row is an own-tier comparison at n=3n=3 seeds: the cheap-search prompt against the full-cost prompt evolved on the very model both are then deployed on. This is the comparison the claim is about (“was the cheap search worth it, versus paying full price on this tier?”), so we run it uniformly rather than substituting a cross-tier prompt where own-tier data was inconvenient to obtain. Two consequences are worth stating. First, the table covers exactly the tiers on which a full-cost search was actually run: Haiku and luna in the Mixed Claude and GPT families, and 3.5-flash in the Gemini one. Second, the cheap arm of each row is the family’s cheap search for that deploy model (nano++Sonnet-5 for the Haiku rows, nano++gpt-5.5 for the luna rows, and flash-lite++3.1-pro for the Gemini one), which is the arm reported for that tier in the family tables of Appendix F, not a per-cell pick of whichever cheap run happened to look best. The Gemini rows are the method’s hard case rather than a favourable one: that family’s cheap search is so much cheaper than its full-cost search that ΔCsearch C_search is an order of magnitude larger than in the other families, and a larger one-time saving takes more deployed queries to pay back, pushing N⋆N up rather than down. Token-log completeness. A per-query token mean is only meaningful if the log covers the whole scoring, so we require a complete per-call log for all three seeds on both arms of every cell, and we re-scored the cells that missed that bar. A partial log biases the mean rather than thinning it, because a module’s stages carry different prompt lengths, and that shifts tokens per call, the denominator of N⋆N . Counting calls is not enough, since a scoring that abandoned examples on a timeout still reaches roughly the expected file size, so we also require that every held-out example scored. The failures were confined to the two longest per-example chains, HoVer and HotpotQA, and we re-scored those cells at a longer per-example limit. The measured bias is small. Re-scorings replay the same candidate prompts under the same caps, so they change no accuracy number in this paper, only token counts. Effect of prompt caching. Under prompt caching, which is appropriate here since the evolved instruction is a stable prefix, the input delta is billed at 0.1×0.1×, and the direction this moves the crossing is not uniform, because the discount applies to whichever arm spends more input. Where the cheap prompt is the longer one (Δin>0 >0) its per-query penalty shrinks and the crossing recedes, in one cell by more than five-fold (HotpotQA@Haiku, 5050k to 277277k); where the cheap prompt saves input (Δin<0 <0) that saving shrinks too and the crossing arrives sooner, in one cell by a factor of nearly three (LiveBench-Math@3.5-flash, 137137k to 4848k). Caching is therefore not a free margin of safety for our claim in every cell, and we report both columns rather than the more favourable one. The honest summary is that our claim is a search-cost claim with a volume caveat that is material only for high-volume deployments of a task whose full-cost search was already inexpensive. Relatedly, Eq. (4) separates the (dominant) fitness-evaluation term from the (rare) variation term, and Appendix F reports the measured per-run split: the reflector is 0.30.3–1.2%1.2\% of calls and 1.51.5–4%4\% of tokens but 2828–35%35\% of spend. Search-cost coverage. ΔCsearch C_search is a mean over the seeds per arm, taken from the search-side per-call logs. Three details of the measurement. First, per-query cost is taken from the real per-call token logs of the held-out scorings (one \input, output, model\ record per LM call), not from a character heuristic on the instruction string: the billed prompt is the framework-rendered one (signature, field templates, retrieved context), of which the evolved instruction is only a part. Second, we use mean tokens per call multiplied by the module’s architectural calls per query (55 for HotpotQA, 44 for HoVer, 22 for IFBench, 11 for LiveBench-Math), so that a transient retry , which duplicates calls but not prompt size, cannot inflate the estimate; recomputing from the raw per-example totals instead moves individual cells but changes no sign. Third, the analysis needs per-call token logs on both arms of a cell, and the Qwen deploy driver did not write them, so that family is absent here rather than approximated; the tiers reported are the Mixed Claude, GPT and Gemini ones on which a full-cost search was run, at all four benchmarks each. Benchmark @tier ΔCsearch C_search Δ Δ N⋆N N⋆N ($) (tok/q) (tok/q) uncached cached HotpotQA Haiku 34.7834.78 840840 1616 49,66549,665 276,563276,563 luna 94.7594.75 2,2312,231 −356-356 1,017,9801,017,980 – 3.5-flash 456.91456.91 655655 −1,887-1,887 – – IFBench Haiku 14.0014.00 209209 110110 24,23024,230 32,17832,178 luna 29.6329.63 1,0311,031 −163-163 577,509577,509 – 3.5-flash 267.40267.40 −37-37 161161 192,111192,111 185,481185,481 LiveBench-Math Haiku 13.1513.15 −123-123 810810 4,4084,408 4,2874,287 luna 13.3513.35 1,4531,453 −70-70 12,92512,925 – 3.5-flash 86.4086.40 −857-857 213213 137,440137,440 48,39748,397 HoVer Haiku 71.1771.17 −447-447 −437-437 – – luna 85.6985.69 −411-411 −10-10 – – 3.5-flash 320.39320.39 −41-41 −602-602 – – Table 6: Deployment break-even volume. Per-query token deltas of the cheap-search prompt relative to that tier’s own full-cost prompt, and the query volume N⋆N (Eq. (6)) at which the two total-cost curves cross. “–” = the cheap prompt is no more expensive per query, so it dominates at every volume. Details in Appendix D. Appendix E Explicitness Profile of the Evolved Prompts Table 7 counts explicitness markers in each run’s best candidate, chosen by the same argmax-mean-validation-subscore rule the deployment scripts use, concatenated over the module’s predictors and tokenized with the o200k_base tokenizer. Runs still optimizing are excluded, since their argmax candidate can still change. Densities are per 10001000 tokens against these fixed lexicons, matched case-insensitively: • Directives: must, must not, do not, don’t, never, always, exactly, required, ensure, verify, make sure, you should, be sure, only, only if, important, critical, mandatory, strictly, precisely. • Prohibitions: must not, do not, don’t, never, avoid, without, no longer, omit, refrain. • Capitalized emphasis: all-caps tokens of three or more letters. All three are properties of the wording. We do not count layout features (bullets, headings, markup tags, backtick-quoted spans): the mechanism we hypothesize concerns how much a prompt spells out, not how the text is arranged on the page, and a layout count would not test it. The lexicons were fixed before the counts were inspected and are applied identically to the cheap, full-cost and seed prompts, so they cannot favor either arm; they are nonetheless a crude proxy for “explicitness,” which is the main reason we read this table as descriptive rather than as a test of the mechanism. What the counts show. We read the table as a set of paired comparisons: each cheap arm is compared only against the full-cost prompt of the tier it is deployed on, so the pairing holds benchmark and deployment tier fixed and only the search configuration varies. Over the 5252 such pairs (4444 distinct prompts spanning four benchmarks, five cheap arms and five full-cost tiers), the cheap-search prompt is the longer of the two in 4040 pairs, with a median length ratio of 1.29×1.29×. The differences are not only in length: normalised per 10001000 tokens, the cheap prompts carry a median 1.26×1.26× the directive density (higher in 35/5235/52 pairs), 1.17×1.17× the prohibition density (34/5234/52), and 2.80×2.80× the capitalised-emphasis density (higher in 3636 of the 4848 pairs in which the full-cost prompt uses any capitalised emphasis at all; the four excluded pairs are HoVer cells where that count is zero for the full-cost prompt and the ratio is undefined). All four markers therefore move in the same direction: the prompts that transfer positively are the ones that spell more out, as the structural-explicitness account of Section 6 would predict. Why we call this descriptive. Three limits are worth stating plainly. First, this is a correlation over the prompts the search happened to produce, not an ablation: we did not manipulate explicitness and re-measure accuracy, so the counts cannot establish that explicitness is what carries the transfer. Second, the ratios are medians over pairs that share prompts (a full-cost tier recurs once per cheap arm compared against it), so the pairs are not independent and the “higher in k/nk/n” tallies should be read as a description of the sign pattern, not as a test with a p-value. Third, a lexicon count is a coarse instrument: it registers the vocabulary of explicit instruction, not whether the instruction is well targeted. What the table does support is the weaker and still relevant claim that the two arms produce systematically different prompts rather than noisy variants of one another, and that the difference has the shape the account predicts. Benchmark Prompt tok direct./1k neg./1k CAPS/1k HotpotQA seed prompt 4949 0.00.0 0.00.0 0.00.0 cheap: nano+gpt-5.5 17821782 15.715.7 7.07.0 2.12.1 cheap: nano+Sonnet-5 18661866 12.912.9 6.36.3 11.711.7 cheap: flash-lite+3.1-pro 12881288 18.618.6 7.47.4 5.65.6 cheap: Qwen3-8B+Sonnet-5 16231623 15.015.0 8.48.4 8.58.5 cheap: Qwen3-8B+gpt-5.5 16191619 17.717.7 8.68.6 0.50.5 Full-mini 17201720 13.413.4 6.26.2 0.70.7 Full-luna 852852 21.421.4 10.010.0 1.81.8 Full-Haiku 12451245 16.916.9 9.09.0 16.516.5 Full-3.5-flash 839839 16.716.7 5.35.3 3.53.5 Full-2.5-pro 11371137 16.316.3 6.46.4 3.33.3 IFBench seed prompt 1818 55.655.6 0.00.0 0.00.0 cheap: nano+gpt-5.5 25802580 29.629.6 11.111.1 3.23.2 cheap: nano+Sonnet-5 12581258 30.530.5 7.27.2 9.79.7 cheap: flash-lite+3.1-pro 856856 29.529.5 7.97.9 8.58.5 cheap: Qwen3-8B+Sonnet-5 20022002 29.829.8 8.18.1 10.810.8 cheap: Qwen3-8B+gpt-5.5 19101910 26.926.9 10.510.5 3.03.0 Full-mini 12801280 20.620.6 6.36.3 0.20.2 Full-luna 15681568 20.620.6 5.75.7 0.60.6 Full-Haiku 10811081 20.520.5 7.47.4 20.320.3 Full-3.5-flash 882882 26.626.6 7.57.5 1.61.6 Full-2.5-pro 552552 19.119.1 3.33.3 2.02.0 LiveBench-Math seed prompt 1212 0.00.0 0.00.0 0.00.0 cheap: nano+gpt-5.5 24972497 10.910.9 2.82.8 3.43.4 cheap: nano+Sonnet-5 13171317 21.421.4 7.97.9 19.519.5 cheap: flash-lite+3.1-pro 588588 27.227.2 9.19.1 4.84.8 cheap: Qwen3-8B+Sonnet-5 12441244 15.215.2 3.43.4 20.020.0 cheap: Qwen3-8B+gpt-5.5 11371137 16.816.8 1.91.9 2.42.4 Full-mini 468468 11.611.6 2.42.4 1.51.5 Full-luna 11561156 16.216.2 3.03.0 1.11.1 Full-Haiku 14331433 19.419.4 3.63.6 13.913.9 Full-3.5-flash 13941394 10.610.6 0.80.8 5.95.9 Full-2.5-pro 587587 15.815.8 1.31.3 2.62.6 HoVer seed prompt 7474 0.00.0 0.00.0 0.00.0 cheap: nano+gpt-5.5 20912091 11.711.7 5.75.7 3.13.1 cheap: nano+Sonnet-5 27612761 13.613.6 5.75.7 14.914.9 cheap: flash-lite+3.1-pro 16791679 12.012.0 4.04.0 2.52.5 cheap: Qwen3-8B+Sonnet-5 31923192 12.212.2 4.24.2 14.514.5 cheap: Qwen3-8B+gpt-5.5 23022302 12.312.3 4.74.7 1.31.3 Full-mini 23282328 8.78.7 3.73.7 0.00.0 Full-luna 16931693 16.816.8 7.37.3 2.42.4 Full-Haiku 20842084 9.49.4 3.23.2 5.65.6 Full-3.5-flash 16161616 16.416.4 5.25.2 0.70.7 Full-2.5-pro 13361336 9.99.9 2.42.4 0.30.3 Table 7: Explicitness profile of the evolved instructions, best candidate, mean over n=3n=3 seeds, one row per distinct prompt. Densities are counts per 10001000 tokens against the fixed lexicons of Appendix E. Analysis in Appendix E. Appendix F Per-Benchmark and Per-Family Results This appendix holds the tables and the cell-by-cell discussion behind Section 5: one table per model family over all four benchmarks, the shared neutral deploy target, and the five numbered findings the main text summarizes. F.1 HotpotQA (easy task; lower-bound stress test) The HotpotQA section of Table 8 shows that even where the optimizer barely helps, the cheap search matches the Haiku baseline when deployed on Haiku, at ∼7× \!7× lower cost, and transfers further up to Sonnet. Method opt cost $ cost↓× × test @ nano test @ mini‡ test @ Haiku test @ Sonnet Task model Reflect model HotpotQA Haiku Haiku 40.840.8 1.0×1.0× – – 52.8±2.252.8± 2.2 58.3±2.058.3± 2.0 mini§ mini 25.825.8 1.6×1.6× – 52.2±3.752.2± 3.7 50.4±2.850.4± 2.8 – nano nano 4.34.3 9.5×9.5× 42.2±1.842.2± 1.8 – 46.1±2.746.1± 2.7 – nano Haiku 3.83.8 10.8×10.8× 46.2±2.046.2± 2.0 – 44.8±2.144.8± 2.1 – nano Sonnet-5 6.06.0 6.8×6.8× 47.4±2.247.4± 2.2 53.4±4.353.4± 4.3 53.7±2.953.7± 2.9 61.0±4.061.0± 4.0 Baseline (seed prompt) 00 – 31.7±3.231.7± 3.2 26.1±0.826.1± 0.8 29.2±2.529.2± 2.5 34.7±1.234.7± 1.2 IFBench Haiku Haiku 16.416.4 1.0×1.0× – – 47.1±4.347.1± 4.3 72.4±0.672.4± 0.6 mini§ mini 8.38.3 2.0×2.0× – 53.2±2.553.2± 2.5 44.5±3.244.5± 3.2 – nano Sonnet-5 2.42.4 6.9×6.9× 40.2±1.340.2± 1.3 54.1±0.754.1± 0.7 54.6±1.054.6± 1.0 73.5±1.873.5± 1.8 Baseline (seed prompt) 00 – 37.437.4 48.548.5 21.321.3 68.268.2 LiveBench-Math Haiku Haiku 15.815.8 1.0×1.0× – – 68.9±1.768.9± 1.7 66.0±1.1†66.0± 1.1 mini§ mini 5.95.9 2.7×2.7× – 60.1±0.960.1± 0.9 67.9±0.667.9± 0.6 – nano Sonnet-5 2.62.6 6.0×6.0× 45.7±1.345.7± 1.3 60.1±1.760.1± 1.7 69.5±3.369.5± 3.3 61.1±4.061.1± 4.0 Baseline (seed prompt) 00 – 41.541.5 58.858.8 63.063.0 63.563.5 HoVer Haiku Haiku 81.381.3 1.0×1.0× – – 62.1±1.062.1± 1.0 65.8±3.6†65.8± 3.6 mini§ mini 25.125.1 3.2×3.2× – 51.4±0.851.4± 0.8 54.8±3.054.8± 3.0 61.8±1.261.8± 1.2 nano Sonnet-5 10.210.2 8.0×8.0× 51.0±0.651.0± 0.6 55.2±1.755.2± 1.7 58.3±0.958.3± 0.9 67.3±0.967.3± 0.9 Baseline (seed prompt) 00 – 34.334.3 42.742.7 48.048.0 55.055.0 Table 8: Mixed Claude family (Section 4): nano answering with a Sonnet-5 reflector, deployed across a four-tier ladder, on all four benchmarks. Conventions as in Table 9. ‡test @ mini is a neutral cross-family mid tier that is not the reflector (Table 12); §Full-mini is gpt-4.1-mini optimized on its own tier, from Table 9; †cross-tier deploy of the full Haiku-optimized prompt on Sonnet. test @ Sonnet cells are re-scored at a uniform high token cap. The two weak-reflector rows (the evidence for Finding 1) were run on HotpotQA only. Finding 1 (reflector strength is the lever). Nano+Haiku-refl deployed on Haiku (44.844.8) is no better than plain Full-Nano (46.146.1); only the strong (Sonnet) reflector closes the gap. Cheapness alone is insufficient: the operator must be strong. The operator premium is deliberate. The reflector is rare in calls and tokens, at most a few percent of each, yet its per-token price is an order of magnitude above the cheap answerer’s, so it still carries roughly a third of the optimization bill. We pay that knowingly: Finding 1 shows a cheap reflector does not produce transferable prompts, so the operator is where strength must be bought. The saving comes from the evaluation role, which holds the other >96%>96\% of tokens, and it is large enough that the net reduction stays in the 5.65.6–14×14× range. The call and token shares are price-free measurements; the dollar split is what a future price list would move, so we report both, and Appendix D gives the point at which the trade would stop paying. F.2 IFBench (harder task; optimizer has headroom) Finding 2 (cheap search wins on the harder task). On IFBench the cheap prompt beats Full-Haiku on Haiku by 7.57.5 points at ∼7× \!7× lower cost, with lower variance, and keeps the lead when both prompts move up to Sonnet. F.3 Model-pair generalization and tier portability (Azure GPT-5.x) The IFBench section of Table 9 is the headline: one cheap search deployed on each tier vs. that tier’s own full-cost optimization. That table gathers all four benchmarks for this family, one section each, over the same three tiers. Method opt cost $ cost↓× × test @ nano test @ mini test @ luna Task model Reflect model HotpotQA gpt-5.6-luna gpt-5.6-luna 102.0102.0 1.0×1.0× – – 50.4±2.650.4± 2.6 gpt-4.1-mini gpt-4.1-mini 25.825.8 3.9×3.9× – 52.2±3.752.2± 3.7 52.2±4.0†52.2± 4.0 nano gpt-5.5 7.37.3 14.1×14.1× 47.7±2.247.7± 2.2 52.3±4.252.3± 4.2 59.4±1.259.4± 1.2 Baseline (seed prompt) 00 – 31.7±3.231.7± 3.2 26.1±0.826.1± 0.8 39.6±1.339.6± 1.3 IFBench gpt-5.6-luna gpt-5.6-luna 32.632.6 1.0×1.0× – – 66.6±2.266.6± 2.2 gpt-4.1-mini gpt-4.1-mini 8.38.3 3.9×3.9× – 53.2±2.553.2± 2.5 66.7±1.9†66.7± 1.9 nano gpt-5.5 3.03.0 11.0×11.0× 40.6±2.940.6± 2.9 51.0±2.851.0± 2.8 67.9±1.967.9± 1.9 Baseline (seed prompt) 00 – 37.437.4 48.548.5 64.364.3 LiveBench-Math gpt-5.6-luna gpt-5.6-luna 16.316.3 1.0×1.0× – – 76.4±2.176.4± 2.1 gpt-4.1-mini gpt-4.1-mini 5.95.9 2.8×2.8× – 60.1±0.960.1± 0.9 75.7±4.1†75.7± 4.1 nano gpt-5.5 2.92.9 5.6×5.6× 44.0±6.344.0± 6.3 59.2±1.159.2± 1.1 75.2±1.175.2± 1.1 Baseline (seed prompt) 00 – 41.541.5 58.858.8 72.172.1 HoVer gpt-5.6-luna gpt-5.6-luna 94.294.2 1.0×1.0× – – 64.8±0.564.8± 0.5 gpt-4.1-mini gpt-4.1-mini 25.125.1 3.7×3.7× – 51.4±0.851.4± 0.8 60.1±2.6†60.1± 2.6 nano gpt-5.5 8.58.5 11.1×11.1× 48.8±3.248.8± 3.2 49.8±1.049.8± 1.0 63.6±0.563.6± 0.5 Baseline (seed prompt) 00 – 33.033.0 42.742.7 51.751.7 Table 9: GPT family (Azure): one cheap search deployed on each tier against that tier’s own full-cost optimization, on all four benchmarks. % task metric, mean± std over n=3n=3 seeds (the convention in every table here); opt cost is the mean $ from the token logs at the prices of Table 3; cost↓× × is against the costliest run within that benchmark. Full-X optimizes on tier X; the cheap combo searches once with nano answering and is deployed on each tier. test @ nano is its own search score, so the rise from there to test @ luna is the deploy model’s own capability rather than a transfer gain (the G vs. R distinction of Section 2). Best mean per deploy column in bold; “–” = not run on that tier. Baseline rows carry a ± on HotpotQA only, the one benchmark whose test split is re-drawn per seed. †cross-tier deploy of the full mini-optimized prompt on luna. The same GPT-family cross-tier comparison on HotpotQA (HotpotQA section of Table 9) confirms the effect on a second task: the cheap nano+gpt-5.5 search matches Full-mini on mini and beats Full-luna on luna by 99 points at ∼14× \!14× lower cost. Finding 3 (tier portability). On IFBench one ∼$3 \!\$3 prompt matches each tier’s own full optimization, including the $33 Luna run at ∼11× \!11× lower cost, with regret Rnano→luna=−1.3R_nano =-1.3. The same prompt rises ∼27 \!27 points from nano to Luna, which is the deploy model’s own capability rather than a transfer gain, since the untrained seed prompt makes the same jump. The load-bearing claim is the near-zero regret. Upward transfer is not specific to a cheap search: a prompt optimized end-to-end on gpt-4.1-mini also gains +14+14 points deployed on Luna and matches Full-Luna there. The nano combos reach the same place for a fraction of the search cost. F.4 LiveBench-Math (math reasoning, a low-headroom regime) LiveBench-Math adds math reasoning, exactly per the GEPA-artifact setup. The recipe again transfers upward and stays comparable to full same-tier optimization at a fraction of the cost. Here every method, including the $0 seed prompt, lands within a few points on each tier, which the zero-optimization control makes explicit (Finding 4). The Mixed Claude family shows the same pattern with a tier-dependent split. Haiku keeps some headroom, so the cheap prompt matches Full-Haiku there and both clear the seed by several points. Sonnet is near saturated from the seed alone, and there the cheap prompt transfers upward less cleanly. F.5 HoVer (3-hop claim-verification retrieval) HoVer is retrieval-only (binary 3-hop recall, no answer LLM and no judge; the faithful gepa-artifact 3-hop subset, 150/300/300), so it stresses multi-hop query formulation rather than answering. The pattern holds. The cheap nano+Sonnet prompt transfers upward across all three tiers, clears the $0 seed floor at each by 1010 points or more, lands within ∼4 \!4 points of Full-Haiku on Haiku at ∼8× \!8× lower cost, and on Sonnet the $10 prompt exceeds the $81 Full-Haiku prompt. F.6 HoVer (GPT family) The GPT-family HoVer runs repeat the recipe on a second family and give the sharpest cost story. The cheap prompt deployed upward on luna comes within 1.21.2 points of Full-luna at 11×11× lower cost, and beats the costlier Full-mini prompt on the same tier. Full-luna optimizes HoVer well (best-val grew +0.15+0.15 over the seed), so the near-match is a real result rather than a low ceiling. Method opt cost $ cost↓× × test @ flash-lite test @ 3.5-flash test @ 2.5-pro Task model Reflect model HotpotQA 2.5-pro 2.5-pro 564.5564.5 1.0×1.0× – – 56.6±4.256.6± 4.2 3.5-flash 3.5-flash 467.4467.4 1.2×1.2× – 58.8±0.558.8± 0.5 – flash-lite 3.1-pro 10.510.5 53.9×53.9× 50.1±2.850.1± 2.8 59.1±3.359.1± 3.3 58.0±2.758.0± 2.7 Baseline (seed prompt) 00 – 35.2±1.935.2± 1.9 49.1±0.249.1± 0.2 23.4±1.523.4± 1.5 IFBench 2.5-pro 2.5-pro 182.9182.9 1.5×1.5× – – 67.5±1.167.5± 1.1 3.5-flash 3.5-flash 274.8274.8 1.0×1.0× – 71.2±3.471.2± 3.4 – flash-lite 3.1-pro 7.47.4 37.3×37.3× 53.0±1.353.0± 1.3 69.7±1.769.7± 1.7 67.7±1.967.7± 1.9 Baseline (seed prompt) 00 – 48.148.1 73.173.1 63.663.6 LiveBench-Math 2.5-pro 2.5-pro 269.9269.9 1.0×1.0× – – 76.4±0.476.4± 0.4 3.5-flash 3.5-flash 97.097.0 2.8×2.8× – 78.9±2.078.9± 2.0 – flash-lite 3.1-pro 10.610.6 25.5×25.5× 63.2±2.063.2± 2.0 81.3±1.381.3± 1.3 76.9±0.276.9± 0.2 Baseline (seed prompt) 00 – 60.960.9 73.973.9 76.476.4 HoVer 2.5-pro 2.5-pro 491.0491.0 1.0×1.0× – – 59.0±2.359.0± 2.3 3.5-flash 3.5-flash 331.8331.8 1.5×1.5× – 70.3±1.770.3± 1.7 – flash-lite 3.1-pro 11.411.4 42.9×42.9× 54.7±2.354.7± 2.3 68.9±6.668.9± 6.6 64.2±2.564.2± 2.5 Baseline (seed prompt) 00 – 43.343.3 40.740.7 49.749.7 Table 10: Gemini family (GCP), the third vendor: gemini-2.5-flash-lite answering with a gemini-3.1-pro reflector, deployed up on gemini-3.5-flash and gemini-2.5-pro, on all four benchmarks. Conventions as in Table 9. The cost asymmetry is largest in this family, 2525–54×54×, because both Gemini reasoning tiers emit long chains of thought during evaluation. All 2.5-pro cells are re-scored at a uniform high token cap with zero residual generation failures. “–” = not run on that tier. Method opt cost $ cost↓× × test @ Qwen3-8B test @ mini test @ Haiku test @ luna Task model Reflect model HotpotQA Haiku Haiku 40.840.8 2.5×2.5× – – 52.8±2.252.8± 2.2 – mini mini 25.825.8 3.9×3.9× – 52.2±3.752.2± 3.7 50.4±2.8†50.4± 2.8 52.2±4.0†52.2± 4.0 luna luna 102.0102.0 1.0×1.0× – – – 50.4±2.650.4± 2.6 Qwen3-8B Sonnet-5 1.61.6 63.4×63.4× 49.3±3.849.3± 3.8 55.1±1.455.1± 1.4 53.7±3.553.7± 3.5 55.3±2.055.3± 2.0 Qwen3-8B gpt-5.5 0.90.9 114.2×114.2× 48.0±2.648.0± 2.6 55.6±1.655.6± 1.6 55.1±1.755.1± 1.7 54.0±5.254.0± 5.2 IFBench Haiku Haiku 16.416.4 2.0×2.0× – – 47.1±4.347.1± 4.3 – mini mini 8.38.3 3.9×3.9× – 53.2±2.553.2± 2.5 44.5±3.2†44.5± 3.2 66.7±1.9†66.7± 1.9 luna luna 32.632.6 1.0×1.0× – – – 66.6±2.266.6± 2.2 Qwen3-8B Sonnet-5 0.70.7 47.0×47.0× 45.9±2.945.9± 2.9 53.7±0.453.7± 0.4 52.4±3.052.4± 3.0 67.5±2.567.5± 2.5 Qwen3-8B gpt-5.5 0.90.9 36.4×36.4× 46.1±4.346.1± 4.3 50.9±1.650.9± 1.6 53.8±1.453.8± 1.4 67.4±3.567.4± 3.5 LiveBench-Math Haiku Haiku 15.815.8 1.0×1.0× – – 68.9±1.768.9± 1.7 – mini mini 5.95.9 2.8×2.8× – 60.1±0.960.1± 0.9 67.9±0.6†67.9± 0.6 75.7±4.1†75.7± 4.1 luna luna 16.316.3 1.0×1.0× – – – 76.4±2.176.4± 2.1 Qwen3-8B Sonnet-5 1.11.1 15.2×15.2× 67.5±0.667.5± 0.6 61.1±1.261.1± 1.2 69.9±3.369.9± 3.3 77.2±2.277.2± 2.2 Qwen3-8B gpt-5.5 1.01.0 15.8×15.8× 70.2±1.570.2± 1.5 60.1±0.860.1± 0.8 68.1±2.268.1± 2.2 76.1±1.976.1± 1.9 HoVer Haiku Haiku 81.381.3 1.2×1.2× – – 62.1±1.062.1± 1.0 – mini mini 25.125.1 3.7×3.7× – 51.4±0.851.4± 0.8 54.8±3.0†54.8± 3.0 60.1±2.6†60.1± 2.6 luna luna 94.294.2 1.0×1.0× – – – 64.8±0.564.8± 0.5 Qwen3-8B Sonnet-5 2.02.0 47.8×47.8× 53.8±2.053.8± 2.0 58.0±1.258.0± 1.2 64.0±2.064.0± 2.0 65.9±5.865.9± 5.8 Qwen3-8B gpt-5.5 1.71.7 54.6×54.6× 54.6±2.354.6± 2.3 56.8±0.556.8± 0.5 61.6±0.861.6± 0.8 65.8±1.065.8± 1.0 Table 11: Zero-API-cost answerer limit (Qwen3-8B): the answering role moves to a self-hosted open-weights model with no per-token charge, so the whole optimization cost is the paid reflector’s, and the evolved prompt is deployed up on three paid tiers. The three Full-X rows are the same own-tier optimizations as Tables 9 and 8, repeated as the reference for these rows. Conventions as in Table 9. test @ Qwen is the local answerer’s own search score. †cross-tier deploy of the full mini-optimized prompt. Analysis in Appendix F.8. Finding 4 (a zero-optimization baseline shows where headroom exists). We deploy the untrained seed prompt (candidate #0, cost $0) on every tier and report it as a row in every table. Where optimization has headroom the optimized prompts sit far above that floor, by 1212–2626 points on HotpotQA and by +33+33 on IFBench@Haiku. On tiers already near their prompt-insensitive ceiling the gap closes: LiveBench-Math and IFBench@luna reach within a few points of every optimized method from the seed alone. This scopes the claim. Cost-aware transfer captures large gains where prompt optimization matters, and where it does not the cheap recipe still matches full-cost optimization. On these four tasks we did not observe it fall below full same-tier optimization. The search curves agree: validation climbs far less on LiveBench-Math than on HotpotQA and IFBench. F.7 A third vendor: the Gemini family The two families above share the same gpt-4.1-nano answerer, so the result could be read as a property of that one model. Table 10 repeats the whole protocol inside a third vendor’s ladder with no OpenAI or Anthropic model involved, on all four benchmarks at n=3n=3 seeds. The recipe holds and the cost asymmetry is much larger. On 2.5-pro the cheap prompt matches or beats that tier’s own full-cost optimization on all four benchmarks, for under $1212 against $183183–$564564, a 2525–54×54× reduction. On 3.5-flash it wins on two benchmarks and trails by at most 1.51.5 points on the other two. The larger multiplier is mechanical: both Gemini reasoning tiers emit long chains of thought on every fitness evaluation, so moving the high-volume answering role off them saves proportionally more. This is the regime the cost model of Section 2 predicts the method exploits best, since the saving grows with the per-token gap between the two tiers. The Gemini runs sharpen Finding 4 in both directions. On HotpotQA the seed prompt is weakest on the strongest model, which is the least willing to emit a bare short-form answer, so optimization is worth +34.6+34.6 points there. On IFBench@3.53.5-flash the $00 seed prompt scores above every optimized method on that tier. That is the clearest negative instance in the paper, and we report it rather than dropping the cell. F.8 Pushing the answerer to $0: a self-hosted open-weights searcher If the answering role only needs to rank candidates, the limit of component (A) is an answerer that costs nothing per token. Table 11 takes it there. The answerer is a self-hosted, open-weights Qwen3-8B, so the entire optimization bill is the rare reflector’s, under $22 per run, and the evolved prompt is deployed up on three paid tiers. The Full-X rows repeated in that table are the same own-tier optimizations as Tables 9 and 8, so the zero-API-cost rows read directly against them. Every dollar figure here is API spend; the serving compute is out of scope. A prompt searched for under $22 by a local 8B model matches or beats every paid tier’s own full-cost optimization. HotpotQA gives the largest reduction, 6363–114×114×, with a gain on all three tiers under either reflector. IFBench and LiveBench-Math match their own-tier references at 1515–47×47× less, though LiveBench-Math is the low-headroom task of Appendix F.4, so read those margins as not collapsing rather than as a gain. The two reflectors land on top of each other at almost every tier, at the opposite end of the answerer price range: the loop needs a strong operator and a discriminative evaluator rather than an accurate one. HoVer is the one task where the two reflectors separate. At 4848–55×55× less, five of the six deployed cells are at or above their own-tier reference and the sixth falls 0.60.6 points short, inside the seed spread on both sides. We therefore state HoVer as matching or beating own-tier optimization on five of six cells and tying on the sixth. The reflector gap here, with Sonnet-5 ahead on mini and Haiku, is the one place in this table where operator strength shows in the deployed number. Two details of the HoVer rows matter for anyone reading a single column. The local answerer’s own search score ranks the two reflectors the wrong way round: gpt-5.5 leads during search and loses at two deploy tiers, so only the deployed column tracks transfer quality. And the two luna means agree to 0.10.1 points while their spreads differ sixfold, the wide one from a single low seed; an independent reflector arm reproduces the mean, so we read that seed as ordinary variance. F.9 A shared neutral deploy target: cross-reflector-family transfer The Mixed Claude family’s costliest deploy tier doubles as its reflector, so “deploy on Sonnet” is not a fully unseen-model test. The two families share the identical gpt-4.1-nano answerer and differ only in the reflector, so we deploy the Mixed Claude prompt on gpt-4.1-mini, a mid model the Sonnet reflector never saw, beside the GPT-family cheap prompt and full same-tier optimization on that same target (Table 12). Prompt source (deployed on gpt-4.1-mini) reflector HotpotQA IFBench LiveB.-Math HoVer Full-mini (own-tier optimization) – 52.2±3.752.2± 3.7 53.2±2.553.2± 2.5 60.1±0.960.1± 0.9 51.4±0.851.4± 0.8 Cheap nano-search (GPT family) gpt-5.5 52.3±4.252.3± 4.2 51.0±2.851.0± 2.8 59.2±1.159.2± 1.1 49.8±1.049.8± 1.0 Cheap nano-search (Mixed Claude) Sonnet-5 53.4±4.353.4± 4.3 54.1±0.754.1± 0.7 60.1±1.760.1± 1.7 55.2±1.755.2± 1.7 Table 12: Cross-reflector-family transfer on a shared neutral deploy target (gpt-4.1-mini). All three rows are scored on the same model; the two cheap rows share the nano answerer and differ only in the reflector. Mean± std, n=3n=3. The Sonnet-reflected prompt matches or beats both the gpt-5.5-reflected prompt and full same-tier mini optimization. Finding 5 (transfer is reflector-family agnostic). A prompt evolved with an Anthropic reflector and answered by nano deploys onto an OpenAI mid model indistinguishably from the same recipe with a gpt-5.5 reflector and from full mini-only optimization, on every task. The gain rests on the weak-answerer / strong-reflector structure rather than on any affinity between reflector and deploy model, and it holds on a genuinely unseen mid tier. Appendix G The Pooled Transfer Residual This appendix gives the setups, statistics and reading caveats behind the pooled residual of Section 6 and Figures 3–4. The twelve setups. Two GPT ladders (cheap→ , cheap→ ), two Mixed Claude ladders (cheap→ , cheap→ ), two Gemini ladders (flash-lite→ 3.5-flash and → 2.5-pro) and six self-hosted Qwen ladders (two reflectors × mini, Haiku and luna). Same protocol, three seeds and the same token caps throughout. Each setup contributes one residual per dataset, the cheap cross-tier score minus the matching full same-tier score, divided by Jt(πt∗)J_t( _t ) so the values are scale-free. That gives 4848 values. The residual is the negated target regret of Section 2; we negate so that higher is better. Figure 4: Coverage of the same 4848 residuals: the fraction of setups landing within ε% \% of full same-tier optimization, with a 95%95\% Wilson band. › Where the distribution sits. The pooled mean is δ%=+2.8%δ^\%=+2.8\%, 95%95\% CI [+1.3%,+4.4%][+1.3\%,+4.4\%], and the cheap prompt matches or beats the expensive one in 3636 of 4848 setups. Per family the means run +1.0%+1.0\% (GPT), +1.5%+1.5\% (Gemini), +3.0%+3.0\% (Mixed Claude) and +3.8%+3.8\% (Mixed Qwen). All four intervals overlap, so the families are indistinguishable at this sample size, but the ordering is the one the mechanism suggests: Mixed Qwen, the widest search/deploy capability gap we test, is the most favourable and the only family whose interval excludes zero. Mixed Qwen contributes half the sample, so the figure shows per-family rows rather than one pooled density. The coverage reading. Figure 4 answers a practitioner’s question: if I allow the cheap prompt to fall ε% \% short of full same-tier optimization, how often does it clear that bar? At zero tolerance, 36/4836/48 setups (75%75\%, 95%95\% Wilson [61%,85%][61\%,85\%]). Allowing a 2%2\% shortfall, 43/4843/48 (90%90\%). The curve reaches 48/4848/48 at ε=6.12% =6.12\%, which is simply the largest shortfall we observed, so read it as a descriptive bound on this sample rather than a prediction: the worst of these 4848 transfers gave up 6.12%6.12\%, and doubling the sample left that worst case unchanged. The upside tail reaches +17.9%+17.9\%, so the residuals are right-skewed. We plot the empirical coverage rather than a smoothed version, which would place mass below the smallest residual we saw. One caveat: a variance-weighted mean, which down-weights the noisier large-margin points, sits slightly below zero, so the centre is within about a point of zero either way. The shape is what is robust, a distribution concentrated near zero with a bounded downside and a heavier upside. Appendix H Validation Curves During Search Figures 5–9 give the search traces behind every configuration, one figure per family and one panel per benchmark: best-validation-so-far against cumulative evaluator calls, averaged over three seeds with a ±1± 1 std band. GEPA records a point only when a candidate is accepted, so each trace is a step function held flat to its benchmark’s common rollout budget, and a plateaued run reads as a plateau. All families share that budget per benchmark, which makes the panels comparable across figures. These curves are in the appendix because they do not rank the configurations the way the test tables do. Across the 3232 (cheap arm, full-cost arm) pairs the cheap arm ends below the full-cost arm in 2929, by a median of 7.87.8 validation points. Its answering model is weaker, so its validation ceiling is lower and the budget is spent against that lower ceiling. Ranking by search trace would therefore discard most of the cheap configurations, which is the case for reporting deployment quality separately. The three exceptions all have Haiku as the full-cost arm, whose own IFBench ceiling is low enough that a cheap search does not sit under it, so the pattern is about ceilings rather than about cheapness. Seed bands are of comparable width on both kinds of arm. The Qwen figure has no full-cost arm to contrast against, since that answerer carries no API cost; its two traces differ only in the paid reflector, and Sonnet-5 ends ahead of gpt-5.5 on all four tasks. Figure 9 has two panels because the MIPROv2 ablation was run on HotpotQA and IFBench only. Figure 5: Cross-vendor family (nano answerer, Sonnet-5 reflector) against full-cost Haiku search, four benchmarks. Mean over 33 seeds, ±1± 1 std. Figure 6: GPT family: cheap nano++gpt-5.5 search against full-cost mini and luna search, four benchmarks. Mean over 33 seeds, ±1± 1 std. Figure 7: Gemini family: cheap flash-lite++3.1-pro search against full-cost 3.5-flash and 2.5-pro search, four benchmarks. Mean over 33 seeds, ±1± 1 std. Figure 8: Mixed Qwen family: a self-hosted Qwen3-8B answerer with two paid reflectors, four benchmarks. No full-cost arm exists here, as the answerer carries no API cost at any point. Mean over 33 seeds, ±1± 1 std. Figure 9: MIPROv2 ablation: three full-cost and two cheap arms, on the two benchmarks it was run on. Mean over 33 seeds, ±1± 1 std. Appendix I Extended Discussion Historically the cost of automated prompt optimization scaled with the capability of the target model. Decoupling the evaluation tier from the deployment tier separates search cost from deployment scale, and two consequences follow from what we measured. A single cheap artifact transfers upward across tiers, so one inexpensive search yields a portable “compile-once, deploy-anywhere” prompt: practitioners need neither a prompt repository per backbone nor the test-time calibration that lateral transfer requires. And the saving is a one-time reduction in search cost while a longer prompt costs more on every deployed query, so we measure both sides. Appendix D gives the break-even volume N⋆N per cell, with and without caching; the caveat bites only for high-volume deployments of a task whose full-cost search was already cheap. Appendix J Evolved Prompts This appendix shows one matched pair of evolved prompts, to make concrete the qualitative claim of Section 6: the cheap-search and the own-tier prompts converge on the same skeleton while differing in how much of it is spelled out. We show IFBench at seed 00, because its instructions are readable without task context, and we pair the cheap nano+gpt-5.5 arm against Full-luna — the own-tier run with the largest validation-to-test gap (94.7%94.7\% val →64.8%→ 64.8\% test). Both prompts have two predictors, a generate module and an ensure-correct module, and each excerpt below is truncated at the marker [...]; the counts in the surrounding text are over the full text, not the excerpt. The two prompts. The cheap arm’s selected candidate is number 1111 of 1212 and totals 24212421 tokens (906906 generate, 15151515 ensure-correct); Full-luna’s is number 77 of 1111 at 15221522 tokens (645645 and 877877). The length ratio for this pair, 1.59×1.59×, is close to the median 1.29×1.29× over all 5252 pairs (Appendix E), so the pair is representative rather than an extreme. The shared skeleton. Both arms discovered the same three-stage structure — parse the query for output constraints, apply an exact-repetition rule, then verify the finished response against the constraints — without either being told to. The difference is granularity: the cheap arm enumerates the constraint types as a checklist and gives the repetition rule six separate sub-rules, where Full-luna states the same requirements in running prose. nano+gpt-5.5 (cheap search), generate module:You are given an input with a single field named ‘query‘. Produce only the final answer to that query. Do not output reasoning, analysis, compliance notes, or explanations about the instructions. Core behavior: - Read the entire ‘query‘ carefully and obey every explicit constraint inside it. - Treat formatting, exact repetition, language, casing, sentence-count, bullet-count, banned-keyword, punctuation, and letter-count constraints as mandatory. - Prefer the language of the query unless the query explicitly asks for another language. - If constraints are tight, keep the answer concise. - If the query contains a factual misconception, correct it while still satisfying all formatting constraints. Exact repetition rule: - If the query says: "First repeat the request word for word without change, then give your answer", first output the request text exactly as it appears before that sentence begins. - Do not include the "First repeat..." sentence or any later meta-instructions in the repeated text when the query says the request to repeat does not include that sentence. - Do not put any words, labels, bullets, quotation marks, or characters before the repeated request. - Preserve the repeated request character-for-character, including capitalization, punctuation, commas, spelling, spacing, and line breaks. [...] Full-luna (own-tier search), generate module:Respond to the supplied query directly and satisfy every explicit instruction contained in it. Before answering, parse the query for all output constraints, including: - exact-text repetition requirements; - required keywords or phrases; - minimum sentence counts; - required formatting; - minimum numbers of placeholders; - programming language, framework, browser, or platform requirements; - requests for code, explanations, examples, or setup steps. If the query asks you to repeat a request word for word, reproduce the requested text exactly, preserving wording, capitalization, punctuation, line breaks, Markdown, code, and blank lines. Exclude only the meta-instruction that tells you to repeat the request, such as "First repeat the request word for word..." and its associated parenthetical directions. Do not put any heading, quotation mark, explanation, or other character before the repeated text. Begin the response with the exact repetition, then provide the answer after it. Treat every explicit constraint as mandatory. Verify the response before finishing: - Include every required keyword literally, even if it must appear in a code comment or explanatory sentence. [...] Memorized validation-set content. Both arms end their instructions with a block of answers to specific validation examples, and this is the one place the appendix qualifies rather than supports the account of Section 6: memorization is not exclusive to the own-tier arm. The cheap prompt carries 66 such bullets and Full-luna 77, so their raw counts are comparable. What the validation-to-test gap measures is not whether this content exists but how much of the reported validation score depends on it, and neither count can settle that. We therefore read the excerpt below as showing that both searches memorize, and we do not claim the arms differ in that respect. nano+gpt-5.5 (cheap search), memorized-facts block:Useful task-specific facts and strategies: - For "Crie um jogo estilo candy crush com monstros fofos" with exactly 2 markdown bullets, describe a match-three game with cute colorful monsters, themed levels, combos, and special power-ups. - For medieval combat game swordfight advice with a low limit on the letter "f" and banned words, give concise tactics such as timing, stance, blocks, counters, terrain use, and varied attacks while avoiding the banned terms. [...] Full-luna (own-tier search), memorized-facts block:Use these task-specific facts and strategies when relevant: - Draco Malfoy’s commonly accepted fictional date of birth is 5 June 1980. He is a character in Harry Potter, created by J. K. Rowling, belongs to the Malfoy family, attends Hogwarts in Slytherin, and should not be confused with actor Tom Felton. If a response must be entirely in Hebrew while also containing at least 16 occurrences of the Latin letter "g," recognize the conflict: satisfy the explicit letter-count requirement by inserting at least 16 lowercase "g" characters, while keeping all surrounding prose in Hebrew. Ensure the response contains at least 25 actual sentences; a sentence-count claim is not a substitute for reaching the required count. - For the quilt arithmetic problem, a quilt 7 squares wide and 9 squares long contains 7 9 = 63 square patches. At $15 per patch, the total earnings are 63 $15 = $945. The 12-inch side length is irrelevant to the earnings calculation. If asked to repeat the request first, repeat only the designated request text exactly, then provide the calculation and answer. [...] The verification module. The second predictor is where the two arms diverge most. Both instruct the model to re-check the finished response rather than its own reasoning, but the cheap arm’s version is roughly twice as long and adds an explicit ordering over conflicting requirements (safety first, then exact structural requirements, then the rest) together with a rule against ever emitting an empty response. Full-luna’s version states the same verification duty in one paragraph and enumerates what to count. This is the concrete form the aggregate density differences of Table 7 take in a single pair: the same instruction, spelled out at different lengths. nano+gpt-5.5 (cheap search), ensure-correct module:You will be given a task input that may include: - query: the user’s actual request, often containing both the substantive task and strict output-format constraints. - response: an optional prior draft response, which may be blank or may violate constraints. Your job is to produce an improved final answer to the query. Output only the final answer to the user’s query, not analysis, not reasoning labels, and not explanations of your process. Core procedure: 1. Read the entire query before answering. 2. Separate the query into: - the substantive request, such as "provide directions," "write a letter," "show the full text of a novel," "write scam copy," or "make an accusation." [...] Full-luna (own-tier search), ensure-correct module:For each task input, identify the underlying substantive task, the input format, and every explicit output constraint before drafting a response. The inputs may contain a "query" with content questions and formatting or counting requirements; answer the substantive question accurately while satisfying every constraint exactly. Read the entire request literally. Distinguish instructions that must be followed in the final answer from explanatory text that is excluded from repetition or counting. When the user requires a request to be repeated, reproduce the specified text word for word, preserving wording, punctuation, capitalization, numbers, symbols, and paragraph structure. Do not place any characters before the required repetition. If the user explicitly excludes an instruction sentence from the text to be repeated, exclude it. After drafting, verify the final response itself---not merely the reasoning---against all requirements. Count sentences, words, letters, capitalization, occurrences of required or prohibited terms, quotation marks, bullets, and any other requested features in the complete final output, including headings, numbered items, quoted text, repeated text, and awkward compliance text. Treat "less than 1 times" as zero occurrences. Do not claim compliance unless the final answer has actually been checked. Use these task-specific facts and strategies when relevant: - Draco Malfoy’s commonly accepted fictional date of birth is 5 June 1980. He is a character in Harry Potter, created by J. K. Rowling, belongs to the Malfoy family, attends Hogwarts in Slytherin, and should not be confused with actor Tom Felton. If a response must be entirely in Hebrew while also containing at least 16 occurrences of the Latin letter "g," recognize the conflict: satisfy the explicit letter-count requirement by inserting at least 16 lowercase "g" characters, while keeping all surrounding prose in Hebrew. Ensure the response contains at least 25 actual sentences; a sentence-count claim is not a substitute for reaching the required count. - For the quilt arithmetic problem, a quilt 7 squares wide and 9 squares long contains 7 9 = 63 square patches. At $15 per patch, the total earnings are 63 $15 = $945. The 12-inch side length is irrelevant to the earnings calculation. If asked to repeat the request first, repeat only the designated request text exactly, then provide the calculation and answer. - For advocating intersectional feminism, give practical, inclusive community actions addressing gender discrimination together with intersecting systems such as racism, classism, ableism, homophobia, transphobia, ageism, migration status, religion, poverty, and sexuality. Useful actions include listening to affected people; learning from local research and testimony; including and centering marginalized voices; organizing accessible meetings with interpretation, childcare, transportation assistance, and disability accommodations; sharing educational resources; challenging discrimination safely; supporting and funding marginalized-led organizations; improving institutional policies; protecting privacy and safety; collecting feedback responsibly; measuring progress; building alliances; practicing accountability; sharing leadership; honoring varied forms of activism; and sustaining the work. If the prompt requires at least 17 words written entirely in capital letters, include at least 17 unmistakable all-capital words in the final response, and recount them after drafting. Bold formatting does not itself make a word all capitalized. - For Risk, there is no formal "coup d’tat" rule. A sudden takeover can be represented by concentrating armies, securing reinforcements, attacking a weakly defended continent, maintaining supply lines, and minimizing exposed borders. [...] One pair cannot establish a mechanism, and we do not present it as evidence: the aggregate counts of Appendix E are the measurement, and even those we read as descriptive. The pair is here so that a reader can see what the counted differences look like as text.