Paper deep dive
Verifier-Harness Co-Evolution for Training-Free Self-Improvement on Open-Ended Tasks
Tianyi Xu, Yaolun Zhang, Yiran Wu, Joe Nguyen, Shengyu Dai, Saba Moeinizade, Zhenwen Shao, Qingyun Wu, Huazheng Wang
Intelligence
Status: not_run | Model: - | Prompt: - | Confidence: 0%
Entities (0)
Relation Signals (0)
No relation signals yet.
Cypher Suggestions (0)
No Cypher suggestions yet.
Abstract
Abstract:Training-free self-improvement lets an agent use feedback to revise the response it is about to return and to update the harness state that shapes how it handles later tasks. On open-ended tasks that feedback rarely comes from reference answers or executable tests, so the agent has to rely on a model-based verifier. When the verifier is wrong, the current response can get worse, and misleading experience can persist across the task stream. A verifier that never changes also grows stale as the agent's responses improve and task demands shift. We introduce Unified Co-Evolution (UCoE), a training-free method that evolves an executable verifier program together with the agent's harness state while all model parameters stay fixed. UCoE synthesizes candidate verifier programs and tests them on response contrasts, pairs of responses that differ in one declared property and have a known preferred side. It selects the candidate whose discrimination on its weakest contrast family is highest, a quantity we call driving capacity. The selected verifier diagnoses one weakness in each draft, guides a single repair, decides which response is served, and determines whether the accepted repair may enter the harness state. As tasks complete, their diagnostics seed new candidate verifiers, which must beat the current verifier on the same contrasts before adoption. Across six open-ended benchmarks, UCoE averages 59.00% preference against matched direct generation with Qwen3-8B and 57.19% with Qwen3.8-27B, margins of 9.00 and 7.19 percentage points. On three verifiable benchmarks, the same method raises the mean from 36.06% for direct generation to 38.48%. Code is available at this https URL.
Tags
Links
- Source: https://arxiv.org/abs/2610.17609v1
- Canonical: https://arxiv.org/abs/2610.17609v1
Trouble viewing inline? Open PDF directly →
Full Text
168,996 characters extracted from source content.
Expand or collapse full text
Verifier–Harness Co-Evolution for Training-Free Self-Improvement on Open-Ended Tasks Tianyi Xu1 Yaolun Zhang1,4* Yiran Wu2,4* Joe Nguyen1 Shengyu Dai3 Saba Moeinizade3 Zhenwen Shao3 Qingyun Wu2,4 Huazheng Wang1,4 1Oregon State University 2Pennsylvania State University 3Johnson & Johnson 4AG2 AI †thanks: Equal contribution. Correspondence to Tianyi Xu and Huazheng Wang (xut2@oregonstate.edu, huazheng.wang@oregonstate.edu). Abstract Training-free self-improvement lets an agent use feedback to revise the response it is about to return and to update the harness state that shapes how it handles later tasks. On open-ended tasks that feedback rarely comes from reference answers or executable tests, so the agent has to rely on a model-based verifier. When the verifier is wrong, the current response can get worse, and misleading experience can persist across the task stream. A verifier that never changes also grows stale as the agent’s responses improve and task demands shift. We introduce Unified Co-Evolution (UCoE), a training-free method that evolves an executable verifier program together with the agent’s harness state while all model parameters stay fixed. UCoE synthesizes candidate verifier programs and tests them on response contrasts, pairs of responses that differ in one declared property and have a known preferred side. It selects the candidate whose discrimination on its weakest contrast family is highest, a quantity we call driving capacity. The selected verifier diagnoses one weakness in each draft, guides a single repair, decides which response is served, and determines whether the accepted repair may enter the harness state. As tasks complete, their diagnostics seed new candidate verifiers, which must beat the current verifier on the same contrasts before adoption. Across six open-ended benchmarks, UCoE averages 59.00%59.00\% preference against matched direct generation with Qwen3-8B and 57.19%57.19\% with Qwen3.8-27B, margins of 9.009.00 and 7.197.19 percentage points. On three verifiable benchmarks, the same method raises the mean from 36.06%36.06\% for direct generation to 38.48%38.48\%. Code is available at https://github.com/tianyi0216/Unified-Co-Evolution. 1 Introduction Self-improving agents use feedback in two ways. They revise the response they are about to return (Madaan et al., 2023), and they retain experience that shapes how they handle later tasks (Shinn et al., 2023; Zhao et al., 2024). Recent work extends the second use to the prompt-level harness that surrounds the model (Lee et al., 2026a). In mathematics and programming, exact answers or executable tests can ground this feedback, as in Figure 1a. Open-ended tasks offer no such anchor. As Figure 1b shows, the agent sees only the public requirements of a request and must judge correctness, coverage, relevance, and style on its own. Because the same judgment decides which response is served and which experience enters the harness state, a single mistaken judgment can harm the current task and then persist across the stream. Figure 1: Feedback for open-ended self-improvement. (a) On verifiable tasks, a known answer marks each response right or wrong and guides agent improvement. (b) On open-ended tasks there is no ground truth, so the agent must judge for itself which response is better, and a wrong judgment harms both the served response and the experience kept for later tasks. (c) UCoE mines quality cues from blinded response pairs, builds response contrasts in which a base response is preferred over an edited copy that lacks one property, tests candidate verifier programs on them, and uses the selected verifier to guide revision while experience from completed tasks updates it over time. Existing methods obtain open-ended feedback from holistic LLM judges, natural-language rubrics, executable reward programs, or learned verifiers. A holistic judge gives a convenient overall score or preference, but the contribution of each quality dimension stays implicit (Gunjal et al., 2026; Shen et al., 2026), and judge accuracy alone is not a reliable predictor of downstream selection gain (Lu et al., 2026). Rubrics make those dimensions explicit, yet generated criteria can be incomplete, conflated, or redundant (Shen et al., 2026), so an aggregate score can still hide a blind spot. Executable reward programs expose the evaluation path (Anonymous, 2026b; Li et al., 2026), but explicit structure does not guarantee behavior, since the selector a program induces still has to be tested across failure families. Training-based methods learn generative reward models, rubric generators, rubric-conditioned judges, or verifier capabilities within the policy (Jia et al., 2025; Xu et al., 2026a; Chen et al., 2026; Pan et al., 2026), at the cost of a model-training stage and its compute. Training-free pipelines that use prompted rubric-guided refinement or aggregate several aspect judgments (Wan et al., 2026; Lifshitz et al., 2025) avoid that cost but keep the verifier fixed during deployment, where it can become stale as responses improve and task demands shift (Anonymous, 2026b; Li et al., 2026; Iacob et al., 2026). To address these weaknesses, we introduce Unified Co-Evolution (UCoE), a training-free method that evolves an executable verifier program alongside the harness state with model parameters fixed. The program keeps every criterion explicit, contrast testing measures its behavior on each failure family, and evolution during deployment keeps it from going stale. UCoE synthesizes candidate verifier programs and tests them on response contrasts, pairs of responses that differ in one targeted property with a declared preference (Gardner et al., 2020; Sai et al., 2021), grouped by property into families. It selects the candidate with the highest driving capacity, its discrimination on the family where it is weakest, so that strength on easy properties cannot mask a blind spot. During deployment the selected verifier diagnoses one weakness in the draft and guides one local repair. It then chooses between draft and revision and decides whether the repair may enter the harness state. Diagnostics from completed tasks seed new candidates, which replace the current verifier only after meeting the update criteria on the same contrasts. Figure 1c sketches this loop. We evaluate UCoE on six open-ended benchmarks and three benchmarks with verifiable endpoints using Qwen3-8B and Qwen3.8-27B actors. UCoE has the highest preference against matched direct generation of all compared feedback methods on every open-ended benchmark at both actor sizes, averaging 59.00%59.00\% and 57.19%57.19\%, and it improves every available native metric. On the verifiable tasks it raises the mean from 36.06%36.06\% to 38.48%38.48\% without a loss on any benchmark. Ablations attribute most of the gain to current-task repair, with verifier selection, verifier evolution, and retained procedures each adding to it. Our contributions are: • We introduce UCoE, a training-free method that evolves an executable verifier program with the harness state, so feedback keeps pace with the agent it guides. • We propose driving capacity, a verifier’s discrimination on its weakest contrast family, and show that it bounds achievable selection gain, giving a safe criterion for verifier updates. • We show state-of-the-art training-free self-improvement on nine benchmarks, with gains that carry over to GPT-5.4 actors and a Codex agent harness on SpreadsheetBench-2. 2 Related work Training-free self-improvement. Training-free methods improve the current response or retain non-parametric state that shapes future behavior. Self-Refine revises responses within a task (Madaan et al., 2023), while Reflexion, ExpeL, Dynamic Cheatsheet, and A-MEM retain or organize reusable experience across trials and tasks (Shinn et al., 2023; Zhao et al., 2024; Suzgun et al., 2026; Xu et al., 2025). ACE and Recursive Harness Self-Improvement extend adaptation to the agent’s context or prompt-level harness (Zhang et al., 2026a; Lee et al., 2026a). Test-time scaling allocates additional inference computation to sampling and verification, including in agentic workflows (Snell et al., 2025; Zhu et al., 2025). All of these methods take the feedback or selection process as given. UCoE adapts that process too: its verifier program evolves alongside the harness state, and together they determine which response is served and which experience is kept. Open-ended rewards and verification. For tasks without exact answers, prior work constructs model-based evaluation signals from generated rubrics, rubric anchors, recursively decomposed and reweighted criteria, or pairwise generative rewards (Gunjal et al., 2026; Huang et al., 2025; Shen et al., 2026; Jia et al., 2025). Other methods combine supplied verifiers, elicit rubric-guided or aspect-specific judgments, or construct self-verifiable proxy tasks (Lee et al., 2026b; Wan et al., 2026; Lifshitz et al., 2025; Wang et al., 2026). CoNL evaluates critiques by the improvements they induce (Sui and Hooi, 2026), and Eureka expresses feedback as executable reward code for simulated control (Ma et al., 2024). The reliability of generated evaluators also needs testing: EvalResearchBench measures how well agent-designed evaluators reproduce the model rankings of target benchmarks (Zhang et al., 2026c). UCoE tests whole verifier programs, criteria and aggregation included, on response contrasts with declared preference directions, and it lets the diagnostics of completed tasks motivate later changes to the program. Co-evolution. Prior co-evolution methods update feedback mechanisms alongside the systems they guide. Rubric-centered work co-evolves rubrics with responses or research policies, adjusts rubric complexity during training, or jointly learns rubric generators, judges, and verifier capabilities (Guan et al., 2026; Shao et al., 2026; Anonymous, 2026a; Xu et al., 2026a; Chen et al., 2026; Pan et al., 2026). DREAM-RL and EvoRS evolve executable Reward-DAGs from rollout diagnostics or on-policy response traces (Anonymous, 2026b; Li et al., 2026). Other work pairs task generators with solvers, compares changing evaluators with fixed anchors, adapts multi-agent organization at test time, or evolves programmatic annotators from labeled validation data (Kwan et al., 2026; Iacob et al., 2026; Zhang et al., 2026b; Xu et al., 2026b). Most of these methods rely on parameter training, on-policy reward traces, or labeled anchors. UCoE keeps the co-evolutionary view but moves all adaptation outside the model parameters. The criteria and aggregation of an executable verifier program change together with the agent’s harness state, diagnostics from completed tasks suggest those changes, and response contrasts with declared preferences give a common basis for judging them. 3 Method We introduce UCoE in this section. Figure 2 gives an overview of the method. See App. B for the complete algorithm. Figure 2: UCoE workflow. Top, the verifier side: (1) Synthesize proposes candidate verifier programs from the task requirements and from quality cues discovered in blinded response pairs. (2) Select edits calibration responses one property at a time to form response contrasts and deploys the candidate that is strongest on its weakest family. (3) Evolve combines the current verifier with diagnostics from completed tasks into a refined candidate, which is re-tested on the same contrasts before it can replace the current verifier. Bottom, the agent side: the fixed actor drafts with the current harness state, the deployed verifier guides one revision and chooses between draft and revision, and accepted repairs are distilled into experience that the updated harness state reuses on later tasks. 3.1 Problem setup Let x1,…,xTx_1,…,x_T be an ordered task stream and Fθ0F_ _0 a fixed actor. Each method A processes the same stream with its own harness state HtH_t, and no method changes any model parameter. What HtH_t contains, and how the actor reads it, depends on the agent system. It may hold instructions, plans, tools, skills, or memory that shape later behavior. In the main experiments it is a bounded procedural memory, and every adaptive method receives an isolated instance that starts empty and follows the same capacity, retrieval, and update rules. All methods follow the same per-task lifecycle. Given HtH_t, the actor first generates a draft yt0=Fθ0(xt,Ht)y_t^0=F_ _0(x_t;H_t). The method then applies its own feedback and selection rules, which may produce at most one revision ytRy_t^R, and returns yt∈yt0,ytRy_t∈\y_t^0,y_t^R\. Only after yty_t has been returned does the method apply its harness update Ht+1=U(Ht,τt)H_t+1=U_A(H_t, _t^A), where τt _t^A is the completed task trace. This ordering lets feedback revise the current response while task-derived state affects only later tasks. Let ℐ⊆1,…,TI \1,…,T\ denote the tasks included in final evaluation. We score each method prequentially: Spreq()=1|ℐ|∑t∈ℐQt(xt,yt),θt=θ0,S_ preq(A)= 1|I| _t Q_t(x_t,y_t), _t= _0, (1) where QtQ_t is the final evaluator’s score for task t. Throughout the stream, methods see public task requirements and their own model-generated artifacts, never benchmark answers or final-evaluator feedback. The score is prequential because each yty_t is produced from the state inherited from earlier tasks, before task t contributes to Ht+1H_t+1. 3.2 Verifier synthesis and contrast-based selection Initial verifier synthesis. UCoE represents a verifier as a program that maps a task x and a response y to a vector of criterion scores and a scalar reward: =(Φ,A,D),(x,y)=(ϕ1(x,y),…,ϕM(x,y)),r(x,y)=A((x,y)),V=( ,A,D), _V(x,y)= ( _1(x,y),…, _M(x,y) ), r_V(x,y)=A\! (s_V(x,y) ), (2) where Φ is the set of criterion scorers, A combines their scores into a reward in which higher is better, and D turns the weakest participating criterion into repair feedback. Semantic criteria are scored by a fixed language model that we call the verifier model, which also proposes programs and diagnoses weaknesses. Evolution may add criteria to Φ and change A. The diagnosis procedure, the program interpreter, and the parameters of the verifier model never change. Public task metadata states broad requirements but can miss domain-specific qualities that recur in real responses. UCoE therefore begins with relation discovery. On a separate development set, the actor and a larger frozen comparison model answer the same prompts, and the verifier model reads each pair in random order with system identities hidden and turns differences that recur across prompts into general criteria together with targeted edits that later serve contrast construction. These fixed relations form ℛR. Using the task metadata, the shared criteria, and ℛR, the verifier model then proposes candidate programs. Each candidate specifies how to combine the criterion scores and may add up to two criteria of its own. A lightweight validity check removes malformed or non-executable programs, and the surviving pool 0K_0 is scored on separate response contrasts, where driving capacity picks the initial verifier. Response-contrast construction. Candidate verifiers need a common behavioral test that shows whether their scores respond to intended changes in quality and which candidate tracks those changes most reliably. Arbitrary response pairs differ in many ways at once, so UCoE instead constructs controlled contrasts that isolate one property at a time (Gardner et al., 2020; Sai et al., 2021). Each contrast starts from a calibration response, written by the actor for a public prompt that is disjoint from deployment, and applies one targeted edit that breaks a single property while leaving everything else in place. The base response y+y^+ and the degraded response y−y^- then differ only in that property, and the declared preference for y+y^+ concerns that property alone. Three general families cover omitted required content, unsupported claims, and irrelevant material. Relation discovery adds benchmark-specific families under the same rule: a relation is kept only if it recurs in at least three development prompts and can be expressed as one binary criterion with one edit that breaks only that property. The resulting pairs form the response contrasts ℬB and are split by source before any verifier is scored. The selection split ranks candidates, and the held-out split later compares a candidate with the current verifier. See App. D.5 for construction details. Driving capacity and selection. Static validation only establishes that a program runs. Choosing among valid programs at random ignores how they behave on the contrasts, and ranking them by mean accuracy lets strong performance on easy families hide a blind spot on a hard one. UCoE therefore ranks candidates by their weakest family. Each verifier V induces a strict-margin selector h=h,ϵh_V=h_V,ε on each contrast, which picks y+y^+ over y−y^- only when the reward of y+y^+ exceeds that of y−y^- by more than ϵε. A tie or a sub-margin lead counts as a failure. For a contrast family j, let pj(h)p_j(h) be the probability that selector h picks y+y^+, and define its centered accuracy as Jj(h)=2pj(h)−1=2Pr[h(x,y+,y−)=y+∣j]−1.J_j(h)=2p_j(h)-1=2 [h(x,y^+,y^-)=y^+ j]-1. (3) Chance-level selection gives Jj=0J_j=0, and positive or negative values mean above- or below-chance selection. The signed driving capacity of V on the response contrasts ℬB is one quarter of its worst family value, and the nonnegative driving capacity clips it at zero: ~ℬ()≔14minjJj(h),ℬ()≔max0,~ℬ(). C_B(V) 14 _jJ_j(h_V), _B(V) \0, C_B(V)\. (4) The factor of one quarter gives the quantity a covariance meaning. For valid contrasts, if one of the two response positions is drawn uniformly at random, Jj/4J_j/4 is the covariance between the selector choosing that position and that position holding the targeted property, so driving capacity is the smallest such selection covariance over the tested families. See Proposition 1 in App. C.1 for the precise statement. The minimum also has a robustness meaning. Suppose the m tested families are mixed with weights w∈Δm=w:wj≥0,∑jwj=1w∈ _m=\w:w_j≥ 0, _jw_j=1\, so that the selector succeeds with probability pw(h)=∑jwjpj(h)p_w(h_V)= _jw_jp_j(h_V). The least favorable mixture puts all of its mass on a weakest family, and Theorem 1 in App. C.2 shows that infw∈Δmpw(h)=minjpj(h)=1/2+2~ℬ() _w∈ _mp_w(h_V)= _jp_j(h_V)=1/2+2 C_B(V). Maximizing signed driving capacity therefore maximizes the worst-case probability of selecting the preferred response over every mixture of the tested families. UCoE optimizes the signed value rather than the clipped one because clipping would make all below-chance candidates look alike. Its empirical objective at checkpoint k, with k=0k=0 denoting initialization, is ^∈argmax∈kminjJ^j(h), V∈ *arg\,max_V _k _j J_j(h_V), (5) where kK_k is the candidate pool at that checkpoint and J^j J_j is centered accuracy on the selection split. Proposition 3 bounds how far the empirical maximizer can fall short of the best candidate in the pool. The winner from 0K_0 becomes the initial verifier 0V_0. Later pools also contain the current verifier, and their winner must meet the update criteria of Section 3.3 before it replaces the current verifier. Driving capacity measures discrimination, and discrimination pays off only when the compared responses differ in quality. Let Zi∈0,1Z_i∈\0,1\ mark whether response i of a pair is adequate under the final evaluation, let Sh∈1,2S_h∈\1,2\ be the index that h selects, and let q=Pr(Z1≠Z2)q= (Z_1≠ Z_2) be the fraction of pairs on which the choice matters. For q>0q>0, the mixed-pair centered accuracy Jmix(h)=2Pr(ZSh=1∣Z1≠Z2)−1J_ mix(h)=2 (Z_S_h=1 Z_1≠ Z_2)-1 measures how often the selector picks the adequate response when the two differ. Pairs of equal adequacy contribute nothing, so for two selectors h and h′h on the same fixed pairs, [ZSh′−ZSh]=q2Jmix(h′)−Jmix(h).E[Z_S_h -Z_S_h]= q2\J_ mix(h )-J_ mix(h)\. (6) Proposition 2 records this decomposition: the actor supplies the opportunity q, the selector supplies the ability JmixJ_ mix to use it, and when q=0q=0 no selector can change expected adequacy. Whether gains on constructed contrasts carry over to the actor’s natural revisions depends on how well the contrast families represent the errors those revisions contain. 3.3 Response revision and co-evolution Response revision and selection. Let kV_k be the verifier active at task t. It scores the draft yt0y_t^0, and from that fixed score vector and its weakest participating criterion the diagnosis procedure returns a target criterion ctc_t, localized evidence wtw_t, and a repair instruction utu_t, written (ct,wt,ut)=Dk(xt,yt0)(c_t,w_t,u_t)=D_V_k(x_t,y_t^0). Conditioned on this feedback and on HtH_t, the fixed actor makes one local repair while preserving unrelated content: ytR=Fθ0(xt,yt0,ct,wt,ut,Ht).y_t^R=F_ _0(x_t,y_t^0,c_t,w_t,u_t;H_t). (7) The same kV_k then scores the draft and the revision, and the revision is served only when its reward lead exceeds a margin ϵ≥0ε≥ 0: yt=ytR,rk(xt,ytR)>rk(xt,yt0)+ϵ,yt0,otherwise.y_t= casesy_t^R,&r_V_k(x_t,y_t^R)>r_V_k(x_t,y_t^0)+ε,\\ y_t^0,&otherwise. cases (8) Whenever the comparison cannot be made, because the feedback was unusable, the revision is missing, or a score is invalid, and whenever the lead is a tie or falls below the margin, the draft is served. We write at∈0,1a_t∈\0,1\ for this acceptance decision. Harness update. After the response is returned, a system-specific operator updates the harness state: Ht+1=UpdateHarness(Ht,xt,yt0,ytR,ct,wt,at).H_t+1=UpdateHarness (H_t,x_t,y_t^0,y_t^R,c_t,w_t,a_t ). (9) Only an accepted repair, at=1a_t=1, may add task-derived content to Ht+1H_t+1. In our bounded procedural-memory implementation, an accepted revision yields at most one generalized trigger–action procedure once task-specific content has been removed, and a rejected revision may update metadata only. See App. D.2 for the retrieval, deduplication, and eviction rules. Verifier evolution. As task demands and HtH_t change, the draft and revision pairs that the actor produces can drift away from the contrasts on which the initial verifier was selected, and its criteria or aggregation can go stale. Equation (6) makes the cost concrete: the selection gain on the pairs the actor now produces depends on how well the current selector discriminates on exactly those pairs. UCoE therefore revisits the verifier at scheduled checkpoints, after yty_t and Ht+1H_t+1 have been finalized. The verifier model synthesizes new candidates from the current verifier’s definitions and from unlabeled summaries of the completed tasks, namely how often revisions were accepted, which criteria were repeatedly the weakest, and how the harness state has grown. A candidate may append criteria or change the aggregation. After validation, UCoE adds the current verifier to the pool and repeats the maximin selection of Section 3.2 on the fixed contrast families. The winner replaces the current verifier only if it meets the update criteria: it must improve worst-family discrimination on the selection split, win more held-out contrasts than it loses against the current verifier, and stay within a fixed regression tolerance on every existing family. Otherwise the current verifier is retained. Any adoption takes effect on the next task. See App. C.3 for the formal update criteria and App. D.6 for implementation details. 4 Experimental setup Table 1: Open-ended preference against matched direct generation. Each entry is the tie-adjusted percentage of tasks on which a method’s response is preferred to the Direct Generation response of the same actor, as judged by Qwen3.5-397B-A17B in both presentation orders with ties given half credit, so 5050 is parity and higher is better. All methods share the actor, the task order, and the fixed-model, one-revision protocol. Overall is the unweighted mean over the six benchmarks, and bold marks the best method in each column. Method Arena- Hard Writing Prompts WildBench Writing Bench Multi Challenge Refine Bench Overall Qwen3-8B Direct Generation 50.0050.00 50.0050.00 50.0050.00 50.0050.00 50.0050.00 50.0050.00 50.0050.00 LLM as a Judge 50.6050.60 50.5450.54 46.3446.34 49.5049.50 38.8738.87 51.9851.98 47.9747.97 RaR (Gunjal et al., 2026) 51.2051.20 50.5450.54 48.5448.54 51.9051.90 38.4838.48 51.2651.26 48.6548.65 DREAM (Anonymous, 2026b) 45.6045.60 43.9043.90 43.1243.12 52.6052.60 31.0531.05 53.7853.78 45.0145.01 SpyRL (Wang et al., 2026) 51.1051.10 49.2749.27 35.7435.74 47.0047.00 33.9833.98 53.0653.06 45.0345.03 UCoE 58.3058.30 62.7962.79 57.4257.42 56.9056.90 57.4257.42 61.1561.15 59.0059.00 Qwen3.8-27B Direct Generation 50.0050.00 50.0050.00 50.0050.00 50.0050.00 50.0050.00 50.0050.00 50.0050.00 LLM as a Judge 49.5049.50 48.0048.00 48.4948.49 50.3050.30 36.3336.33 48.7448.74 46.8946.89 RaR (Gunjal et al., 2026) 51.6051.60 50.4950.49 47.5647.56 50.6050.60 43.3643.36 44.7844.78 48.0748.07 DREAM (Anonymous, 2026b) 53.8053.80 59.9659.96 48.4448.44 52.1052.10 46.4846.48 48.3848.38 51.5351.53 SpyRL (Wang et al., 2026) 43.4043.40 58.8458.84 41.8941.89 48.6048.60 36.3336.33 42.9942.99 45.3445.34 UCoE 59.7059.70 63.9263.92 55.4255.42 54.4054.40 51.9551.95 57.7357.73 57.1957.19 Benchmarks and models. Our open-ended evaluation spans six benchmarks. Arena-Hard (Li et al., 2025) and WildBench (Lin et al., 2025) test general assistance on challenging user requests. WritingPrompts (Fan et al., 2018) tests story generation, and WritingBench (Wu et al., 2025) covers writing across diverse domains. MultiChallenge (Deshpande et al., 2025) targets multi-turn instruction following, and the Free-Form split of RefineBench (Lee et al., 2026c) tests response refinement. To check whether the same method transfers beyond model-judged evaluation, we add three benchmarks with objective endpoints. IFBench tests compliance with verifiable instruction constraints (Pyatkin et al., 2025), Hard-MATH is our competition-mathematics stream drawn from MATH-500 and AIME 2022–2025 (Hendrycks et al., 2021; Lightman et al., 2024), and BigCodeBench-Hard tests code generation through execution (Zhuo et al., 2025). We run Qwen3-8B and Qwen3.8-27B (Yang et al., 2025) as actors and use Qwen3.6-35B-A3B as the fixed verifier model for program synthesis, semantic criterion scoring, and diagnosis. In relation discovery, the larger comparison model is Qwen3.8-27B for the Qwen3-8B actor and Qwen3.5-397B-A17B for the Qwen3.8-27B actor. See App. D.1 for splits and sizes and App. D.4 for default hyperparameters. Baselines. We compare UCoE with common baselines for open-ended self-improvement, chosen to cover different forms of feedback. Direct Generation uses no feedback and provides the raw-response reference. LLM as a Judge makes a fixed holistic judgment of response quality (Zheng et al., 2023). RaR scores responses against task-specific flat rubrics (Gunjal et al., 2026). DREAM organizes dependent criteria into a Reward-DAG (Anonymous, 2026b). SpyRL derives feedback from a task-transformation game with self-verifiable rewards (Wang et al., 2026). We adapt all four feedback baselines to the same fixed-model, one-revision protocol: each method uses its own feedback to guide at most one revision, scores the draft and the revision with its own signal, and returns the revision only when it passes the method’s acceptance rule. Stateful methods receive separate procedural memories with the same capacity and update rules, and all implementations transfer the feedback mechanisms without reproducing the original parameter-training pipelines. See App. D.3 and Table 5 for each baseline’s implementation and acceptance rule. Evaluation. Open-ended benchmarks do not share an exact notion of correctness, and their native scores are not directly comparable, so our primary endpoint is tie-adjusted pairwise preference against the matched Direct Generation response. This follows established pairwise evaluation protocols for open-ended model outputs (Zheng et al., 2023; Li et al., 2025) and places every method on the same relative scale. Qwen3.5-397B-A17B judges each pair of full responses in both presentation orders without receiving method identities. We merge the two judgments at the task level and assign half credit to ties, so values above 50%50\% favor the evaluated method over Direct Generation. We also report the native benchmark-specific metrics wherever they exist, together with accuracy or Pass@1 on the verifiable tasks. See App. D.7 for the full evaluation protocols. 5 Results Table 2: Verifiable tasks with Qwen3-8B. Accuracy for IFBench and Hard-MATH, Pass@1 for BigCodeBench-Hard. Method IFBench Hard-MATH BigCodeBench-Hard Overall Direct Generation 30.0030.00 56.5456.54 21.6221.62 36.0636.06 LLM as a Judge 33.3333.33 55.2455.24 16.8916.89 35.1535.15 RaR 32.0032.00 57.3357.33 18.9218.92 36.0836.08 DREAM 28.6728.67 59.4259.42 18.2418.24 35.4435.44 SpyRL 30.6730.67 58.1258.12 18.2418.24 35.6835.68 UCoE 34.6734.67 59.1659.16 21.6221.62 38.4838.48 UCoE wins on every open-ended benchmark. Table 1 shows that UCoE is preferred over matched direct generation in all twelve benchmark and actor settings, and that its preference is the largest of any feedback method in every one of them. It averages 59.00%59.00\% with Qwen3-8B and 57.19%57.19\% with Qwen3.8-27B, gains of 9.009.00 and 7.197.19 points over direct generation, and the gains span general assistance, writing, multi-turn instruction following, and refinement. The other feedback methods often fail to improve on direct generation. Even the best baseline on each benchmark averages only 49.26%49.26\% at 8B and 51.60%51.60\% at 27B, and none exceeds parity on WildBench at 8B. Every baseline receives feedback and one revision under the same protocol, so the gap reflects the feedback signal itself rather than the opportunity to revise. We also evaluate under each benchmark’s native metric, and the same picture holds, with UCoE improving over direct generation in every setting. See App. E.1, E.2, E.3, E.5, and E.6 for native-metric results, listed-price cost, backbone transfer, pointwise intervals for Table 1, and an independent-critic audit of the WritingBench revisions. UCoE also improves verifiable tasks. The same lifecycle helps where correctness can be checked. In Table 2, UCoE raises the three-benchmark mean from 36.06%36.06\% to 38.48%38.48\%. It improves IFBench by 4.674.67 points and Hard-MATH by 2.622.62 points while matching direct generation on BigCodeBench-Hard. On code, every other feedback method lowers Pass@1 below direct generation, and UCoE is the only method that preserves it, while on Hard-MATH DREAM edges it by 0.260.26 points. Table 3: Arena-Hard ablations with Qwen3-8B. Tie-adjusted preference against direct generation. Configuration vs. direct % UCoE 58.3058.30 Random initial verifier 56.7056.70 Fixed verifier 56.6056.60 Harness-state updates only 50.8050.80 No memory updates 56.7056.70 Every component contributes. Table 3 removes one component of UCoE at a time on Arena-Hard, and every removal lowers preference. Removing current-task repair, so that the verifier only updates the harness state, costs the most, from 58.30%58.30\% to 50.80%50.80\%. Replacing driving-capacity selection with a random initial verifier, freezing the verifier instead of updating it at checkpoints, and disabling harness-state updates from accepted repairs each lower preference to between 56.60%56.60\% and 56.70%56.70\%. The ablations confirm each part of the design: verifier-guided repair, verifier selection by driving capacity, verifier updates at checkpoints, and harness-state updates from feedback all contribute. See App. E.4 for the sensitivity study. Figure 3: UCoE inside the Codex agent harness on SpreadsheetBench-2. Exact-match accuracy on a 75-task stream, overall and by task category, with GPT-5.6-luna as the actor. UCoE transfers to a Codex agent harness. The main experiments wrap a bare actor in a prompt-level harness with procedural memory. To test whether UCoE also works inside a full coding-agent harness, we run it in the Codex harness on SpreadsheetBench-2 (Zhu et al., 2026), where the agent edits real workbooks with its tools and the benchmark’s checker scores each result after recalculating every formula. The harness state here is the agent’s own context, its tools, a task skill file, and an experience block in the prompt, so the study also tests whether UCoE’s harness-state updates transfer beyond the procedural memory of the main experiments. GPT-5.6-luna is the actor and GPT-5.6-sol the verifier model, and Figure 3 reports a 75-task stream with checkpoints after tasks 34 and 67. UCoE reaches 22.7%22.7\% exact-match accuracy against 17.3%17.3\% for both Direct Generation and LLM as a Judge. The gain comes from financial-model and debugging tasks, where the fixed judge matches or trails direct generation, while on template tasks LLM as a Judge leads. See App. D.8 for details. (a) Repair-target distributions (b) Verifier evolution (c) Fixed-proposal score shifts (d) Procedure reuse Figure 4: Mechanism diagnostics. (a) Share of repair targets per criterion group. Gray marks groups absent from the deployed verifier. (b) Two verifier updates in WritingPrompts. Each arrow runs from the current verifier to the candidate selected by driving capacity, in signed driving capacity against selection gain on frozen response pairs. (c) Reward margins of 360 Arena-Hard proposals under the initial and updated verifier. Dashed lines mark the acceptance margin, and colors give the external judgment for the 94 proposals the updated verifier selects. (d) Reuse lag of stored procedures at 381 Arena-Hard tasks, colored by outcome. The dashed line marks the switch to mathematics tasks. Verifier updates and stored procedures behave as intended. Figure 4(a) shows which criterion the verifier targets when it diagnoses a draft. Correctness receives 78.9%78.9\% of Arena-Hard repairs, requirements lead on WritingBench at 42.5%42.5\%, coherence on RefineBench at 36.5%36.5\%, and emotion on WritingPrompts at 53.0%53.0\%, so the deployed verifier directs repairs at the qualities each task type demands. Figure 4(b) shows two verifier updates in WritingPrompts. Each candidate selected by driving capacity raises signed driving capacity on the contrasts, from −0.0625-0.0625 and −0.0208-0.0208 to 0.250.25, and also raises selection gain on separate frozen response pairs, by 10.1610.16 and 4.694.69 points, so gains on constructed contrasts carry over to natural pairs. Figure 4(c) rescores 360 Arena-Hard proposals under the initial and the updated verifier. The update widens some reward margins and narrows others, which changes the set of accepted revisions, and among the 94 proposals it selects, external judgments favor 7373 over the draft, 77 favor the draft, and 1414 tie. The updated verifier therefore accepts mostly real improvements. Figure 4(d) tracks when stored procedures are retrieved. Of 639 retrieval events, 76 reuse a procedure after at least ten intervening tasks, and on the 70 retrieving tasks with external judgments the served revision beats the draft 5454 times, loses 55, and ties 1111, so experience in the harness state is reused long after it was stored and the tasks that reuse it are mostly judged better than their drafts. 6 Conclusion We introduced UCoE, a training-free framework in which an executable verifier program and the harness state around a fixed actor evolve together. Response contrasts choose the verifier and test every candidate that would replace it, and the verifier in turn shapes each response and the experience the agent keeps. On six open-ended benchmarks, UCoE improves on matched direct generation at both Qwen actor sizes, and on three verifiable benchmarks it raises the mean while preserving Pass@1 on BigCodeBench-Hard. Repairing the current task contributes most of the gain, verifier updates measurably change selection behavior, and procedures stored from accepted repairs are reused many tasks later. Training-free self-improvement has so far adapted responses and harness state around a fixed feedback process. UCoE extends that adaptation to the feedback process itself, without touching model parameters. See App. A for limitations. AI use statement Generative AI tools assisted with writing assistance and polishing of the manuscript. The authors take responsibility for the full content of this work. Ethics statement This work does not recruit human subjects or collect new personal data. It evaluates language models on existing research benchmarks. An evolving verifier can nevertheless reinforce its own errors or biases through revision and persistent harness state, which may retain sensitive information without appropriate filtering. Improved generation may also amplify misinformation or other harmful content, while additional inference consumes computational resources. Response contrasts do not establish safety, fairness, or privacy. Consequential deployments should therefore use independent safety evaluation, human oversight, explicit retention and deletion rules, and rollback mechanisms. Reproducibility statement Algorithm 1 specifies the full lifecycle and update order. App. C states the assumptions and gives complete proofs. App. D documents benchmark splits, models, baseline implementations, hyperparameters, contrast construction, verifier rules, and the procedural-memory implementation. App. E reports native-metric results, cost, cross-backbone transfer, hyperparameter sensitivity, the intervals behind the main tables, a natural-revision audit, and qualitative examples. References Anonymous (2026a) Anonymous CARE: curriculum-aware rubric evolution for open-ended text generation. In Submitted to ACL Rolling Review - March 2026, Note: under review External Links: Link Cited by: §2. Anonymous (2026b) Anonymous DREAM-RL: dynamic reward-system evolution with an agentic meta-judge for reinforcement learning on open-ended tasks. In Submitted to ACL Rolling Review - May 2026, Note: under review External Links: Link Cited by: §1, §2, Table 1, Table 1, §4. Chen et al. (2026) Y. Chen, H. Li, Q. Ai, F. Zhu, T. Chua, M. Zhang, and Y. Liu GenRubric: self-evolving rubric generation for scalable llm evaluation. External Links: 2608.29856, Link Cited by: §1, §2. Deshpande et al. (2025) K. Deshpande, V. Sirdeshmukh, J. B. Mols, L. Jin, E. Hernandez-Cardona, D. Lee, J. Kritz, W. E. Primack, S. Yue, and C. Xing MultiChallenge: a realistic multi-turn conversation evaluation benchmark challenging to frontier LLMs. In Findings of the Association for Computational Linguistics: ACL 2025, W. Che, J. Nabende, E. Shutova, and M. T. Pilehvar (Eds.), Vienna, Austria, p. 18632–18702. External Links: Link, Document, ISBN 979-8-89176-256-5 Cited by: §4. Fan et al. (2018) A. Fan, M. Lewis, and Y. Dauphin Hierarchical neural story generation. In Proceedings of the 56th Annual Meeting of the Association for Computational Linguistics (Volume 1: Long Papers), p. 889–898. Cited by: §4. Gardner et al. (2020) M. Gardner, Y. Artzi, V. Basmov, J. Berant, B. Bogin, S. Chen, P. Dasigi, D. Dua, Y. Elazar, A. Gottumukkala, N. Gupta, H. Hajishirzi, G. Ilharco, D. Khashabi, K. Lin, J. Liu, N. F. Liu, P. Mulcaire, Q. Ning, S. Singh, N. A. Smith, S. Subramanian, R. Tsarfaty, E. Wallace, A. Zhang, and B. Zhou Evaluating models’ local decision boundaries via contrast sets. In Findings of the Association for Computational Linguistics: EMNLP 2020, T. Cohn, Y. He, and Y. Liu (Eds.), Online, p. 1307–1323. External Links: Link, Document Cited by: §1, §3.2. Gazoni and Clark (2024) E. Gazoni and C. Clark Openpyxl: a Python library to read/write Excel 2010 xlsx/xlsm files. Note: https://openpyxl.readthedocs.io Cited by: §D.8. Guan et al. (2026) X. Guan, X. Hu, S. Huang, Z. Wang, B. Zhang, Z. Li, P. Xie, B. Liu, and J. Cao EvoRubric: self-evolving rubric-driven rl for open-ended generation. External Links: 2605.29847, Link Cited by: §2. Gunjal et al. (2026) A. Gunjal, A. Wang, E. Lau, V. Nath, Y. He, B. Liu, and S. M. Hendryx Rubrics as rewards: reinforcement learning beyond verifiable domains. In The Fourteenth International Conference on Learning Representations, External Links: Link Cited by: §1, §2, Table 1, Table 1, §4. Hendrycks et al. (2021) D. Hendrycks, C. Burns, S. Kadavath, A. Arora, S. Basart, E. Tang, D. Song, and J. Steinhardt Measuring mathematical problem solving with the MATH dataset. In Thirty-fifth Conference on Neural Information Processing Systems Datasets and Benchmarks Track (Round 2), External Links: Link Cited by: §4. Hoeffding (1963) W. Hoeffding Probability inequalities for sums of bounded random variables. Journal of the American statistical association 58 (301), p. 13–30. Cited by: §C.2. Holm (1979) S. Holm A simple sequentially rejective multiple test procedure. Scandinavian journal of statistics, p. 65–70. Cited by: §E.5. Huang et al. (2025) Z. Huang, Y. Zhuang, G. Lu, Z. Qin, H. Xu, T. Zhao, R. Peng, J. Hu, Z. Shen, X. Hu, X. Gu, P. Tu, J. Liu, W. Chen, Y. Fu, Z. Fan, Y. Gu, Y. Wang, Z. Yang, J. Li, and J. Zhao Reinforcement learning with rubric anchors. External Links: 2508.12790, Link Cited by: §2. Iacob et al. (2026) A. Iacob, A. Jovanović, W. F. Shen, D. Burkhardt, M. Kurmanji, N. Tastan, L. Sani, N. A. E. Venanzi, A. Odonnat, Z. Cao, B. Marino, X. Qiu, and N. D. Lane The red queen gödel machine: co-evolving agents and their evaluators. External Links: 2606.26294, Link Cited by: §1, §2. Jia et al. (2025) R. Jia, Y. Yang, Y. Gai, K. Luo, S. Huang, J. Lin, X. Jiang, and G. Jiang Writing-zero: bridge the gap between non-verifiable tasks and verifiable rewards. External Links: 2506.00103, Link Cited by: §1, §2. Kwan et al. (2026) W. Kwan, A. P. Gema, J. O. J. Leang, and P. Minervini SCOPE: self-play via co-evolving policies for open-ended tasks. External Links: 2605.31433, Link Cited by: §2. Lee et al. (2026a) H. Lee, J. Xu, J. Seely, D. Lee, M. Zaharia, and Y. Tang Recursive harness self-improvement. External Links: 2607.15524, Link Cited by: §1, §2. Lee et al. (2026b) J. Lee, V. Ma, S. Zhao, Y. Nair, A. Spector, R. Cohen, and E. J. Candès FUSE: ensembling verifiers with zero labeled data. External Links: 2604.18547, Link Cited by: §2. Lee et al. (2026c) Y. Lee, S. Kim, B. Lee, M. Moon, Y. Hwang, J. M. Kim, G. Neubig, S. Welleck, and H. Choi RefineBench: evaluating refinement capability of language models via checklists. In The Fourteenth International Conference on Learning Representations, External Links: Link Cited by: §4. Li et al. (2025) T. Li, W. Chiang, E. Frick, L. Dunlap, T. Wu, B. Zhu, J. E. Gonzalez, and I. Stoica From crowdsourced data to high-quality benchmarks: arena-hard and benchbuilder pipeline. In Forty-second International Conference on Machine Learning, External Links: Link Cited by: §4, §4. Li et al. (2026) W. Li, A. Chen, X. Wang, Y. Zhang, Q. Dong, J. Xu, H. Hou, W. Zhao, C. Lang, J. Gao, Y. Guo, H. Guo, Y. Xiao, and D. Yang EvoRS: on-policy self-evolution of reward systems for open-ended reinforcement learning. External Links: 2609.12459, Link Cited by: §1, §2. Lifshitz et al. (2025) S. Lifshitz, S. A. McIlraith, and Y. Du Multi-agent verification: scaling test-time compute with multiple verifiers. In Second Conference on Language Modeling, External Links: Link Cited by: §1, §2. Lightman et al. (2024) H. Lightman, V. Kosaraju, Y. Burda, H. Edwards, B. Baker, T. Lee, J. Leike, J. Schulman, I. Sutskever, and K. Cobbe Let’s verify step by step. In The Twelfth International Conference on Learning Representations, External Links: Link Cited by: §4. Lin et al. (2025) B. Y. Lin, Y. Deng, K. Chandu, A. Ravichander, V. Pyatkin, N. Dziri, R. Le Bras, and Y. Choi Wildbench: benchmarking llms with challenging tasks from real users in the wild. In International Conference on Learning Representations, Vol. 2025, p. 47852–47870. Cited by: §4. Lu et al. (2026) J. Lu, R. Teehan, J. Jin, and M. Ren When does verification pay off? a closer look at llms as solution verifiers. External Links: 2512.02304, Link Cited by: §1. Ma et al. (2024) Y. J. Ma, W. Liang, G. Wang, D. Huang, O. Bastani, D. Jayaraman, Y. Zhu, L. Fan, and A. Anandkumar Eureka: human-level reward design via coding large language models. In The Twelfth International Conference on Learning Representations, External Links: Link Cited by: §2. Madaan et al. (2023) A. Madaan, N. Tandon, P. Gupta, S. Hallinan, L. Gao, S. Wiegreffe, U. Alon, N. Dziri, S. Prabhumoye, Y. Yang, S. Gupta, B. P. Majumder, K. Hermann, S. Welleck, A. Yazdanbakhsh, and P. Clark Self-refine: iterative refinement with self-feedback. In Thirty-seventh Conference on Neural Information Processing Systems, External Links: Link Cited by: §1, §2. McNemar (1947) Q. McNemar Note on the sampling error of the difference between correlated proportions or percentages. Psychometrika 12 (2), p. 153–157. Cited by: §E.5. OpenAI (2025a) OpenAI Codex CLI: lightweight coding agent that runs in your terminal. Note: https://github.com/openai/codex Cited by: §D.6, §D.8. OpenAI (2025b) OpenAI GPT-5 system card. Note: https://openai.com/index/gpt-5-system-card/Model documentation for the GPT-5 series, including the GPT-5.4 and GPT-5.6 models used in this work Cited by: §D.6, §E.3. Pan et al. (2026) T. Pan, Y. Yan, Z. Wang, R. Zhang, G. Hou, W. Zhang, W. Lu, J. Xiao, and Y. Shen CoVerRL: breaking the consensus trap in label-free reasoning via generator-verifier co-evolution. External Links: 2603.17775, Link Cited by: §1, §2. Price (1970) G. R. Price Selection and covariance. Nature 227 (5257), p. 520–521. Cited by: §C.1. Pyatkin et al. (2025) V. Pyatkin, S. Malik, V. Graf, H. Ivison, S. Huang, P. Dasigi, N. Lambert, and H. Hajishirzi Generalizing verifiable instruction following. In The Thirty-ninth Annual Conference on Neural Information Processing Systems Datasets and Benchmarks Track, External Links: Link Cited by: §4. Sagawa* et al. (2020) S. Sagawa*, P. W. Koh*, T. B. Hashimoto, and P. Liang Distributionally robust neural networks. In International Conference on Learning Representations, External Links: Link Cited by: §C.2. Sai et al. (2021) A. B. Sai, T. Dixit, D. Y. Sheth, S. Mohan, and M. M. Khapra Perturbation CheckLists for evaluating NLG evaluation metrics. In Proceedings of the 2021 Conference on Empirical Methods in Natural Language Processing, M. Moens, X. Huang, L. Specia, and S. W. Yih (Eds.), Online and Punta Cana, Dominican Republic, p. 7219–7234. External Links: Link, Document Cited by: §1, §3.2. Shao et al. (2026) R. Shao, A. Asai, S. Z. Shen, H. Ivison, V. Kishore, J. Zhuo, X. Zhao, M. Park, S. G. Finlayson, D. Sontag, T. Murray, S. Min, P. Dasigi, L. Soldaini, F. Brahman, W. Yih, T. Wu, L. Zettlemoyer, Y. Kim, H. Hajishirzi, and P. W. Koh DR tulu: reinforcement learning with evolving rubrics for deep research. In Forty-third International Conference on Machine Learning, External Links: Link Cited by: §2. Shen et al. (2026) W. F. Shen, X. Qiu, C. Whitehouse, L. Alazraki, S. Goel, F. Barbieri, T. Willi, A. Mathur, and I. Leontiadis Rethinking rubric generation for improving llm judge and reward modeling for open-ended tasks. External Links: 2602.05125, Link Cited by: §1, §2. Shinn et al. (2023) N. Shinn, F. Cassano, A. Gopinath, K. R. Narasimhan, and S. Yao Reflexion: language agents with verbal reinforcement learning. In Thirty-seventh Conference on Neural Information Processing Systems, External Links: Link Cited by: §1, §2. Snell et al. (2025) C. Snell, J. Lee, K. Xu, and A. Kumar Scaling llm test-time compute optimally can be more effective than scaling parameters for reasoning. In International Conference on Learning Representations, Vol. 2025, p. 10131–10165. Cited by: §2. Sui and Hooi (2026) Y. Sui and B. Hooi Conversation for non-verifiable learning: self-evolving large language models through meta-evaluation. In Forty-third International Conference on Machine Learning, External Links: Link Cited by: §2. Suzgun et al. (2026) M. Suzgun, M. Yuksekgonul, F. Bianchi, D. Jurafsky, and J. Zou Dynamic cheatsheet: test-time learning with adaptive memory. In Proceedings of the 19th Conference of the European Chapter of the Association for Computational Linguistics (Volume 1: Long Papers), V. Demberg, K. Inui, and L. Marquez (Eds.), Rabat, Morocco, p. 7080–7106. External Links: Link, Document, ISBN 979-8-89176-380-7 Cited by: §2. The Document Foundation (2024) The Document Foundation LibreOffice. Note: https://w.libreoffice.org Cited by: §D.8. Wan et al. (2026) Y. Wan, T. Fang, Z. LI, Y. Huo, W. Wang, H. Mi, D. Yu, and M. R. Lyu Inference-time scaling of verification: self-evolving deep research agents via test-time rubric-guided verification. In Findings of the Association for Computational Linguistics: ACL 2026, M. Liakata, V. P. Moreira, J. Zhang, and D. Jurgens (Eds.), San Diego, California, United States, p. 24822–24835. External Links: Link, Document, ISBN 979-8-89176-395-1 Cited by: §1, §2. Wang et al. (2026) Q. Wang, J. Shi, H. Wang, K. Wan, Y. Wu, B. Liu, Q. Wu, H. H. Li, Y. Chen, H. Zhao, and W. Zhao From rlvr to rlsvr: task transformation induces self-verifiable rewards for open-ended llm self-improvement. External Links: 2607.23802, Link Cited by: §2, Table 1, Table 1, §4. Wu et al. (2025) Y. Wu, J. Mei, M. Yan, C. Li, S. Lai, Y. Ren, W. Zijia, J. Zhang, M. Wu, Q. Jin, and F. Huang WritingBench: a comprehensive benchmark for generative writing. In The Thirty-ninth Annual Conference on Neural Information Processing Systems Datasets and Benchmarks Track, External Links: Link Cited by: §4. Xu et al. (2026a) R. Xu, T. Liu, Z. Dong, T. Yu, I. Hong, C. Yang, L. Zhang, T. Zhao, and H. Wang Alternating reinforcement learning for rubric-based reward modeling in non-verifiable LLM post-training. In Forty-third International Conference on Machine Learning, External Links: Link Cited by: §1, §2. Xu et al. (2026b) T. Xu, Y. Zhang, X. Ouyang, and H. Wang EvoPool: evolutionary programmatic annotation for label-efficient specialized supervision. External Links: 2606.01617, Link Cited by: §2. Xu et al. (2025) W. Xu, Z. Liang, K. Mei, H. Gao, J. Tan, and Y. Zhang A-mem: agentic memory for LLM agents. In The Thirty-ninth Annual Conference on Neural Information Processing Systems, External Links: Link Cited by: §2. Yang et al. (2025) A. Yang, A. Li, B. Yang, B. Zhang, B. Hui, B. Zheng, B. Yu, C. Gao, C. Huang, C. Lv, C. Zheng, D. Liu, F. Zhou, F. Huang, F. Hu, H. Ge, H. Wei, H. Lin, J. Tang, J. Yang, J. Tu, J. Zhang, J. Yang, J. Yang, J. Zhou, J. Zhou, J. Lin, K. Dang, K. Bao, K. Yang, L. Yu, L. Deng, M. Li, M. Xue, M. Li, P. Zhang, P. Wang, Q. Zhu, R. Men, R. Gao, S. Liu, S. Luo, T. Li, T. Tang, W. Yin, X. Ren, X. Wang, X. Zhang, X. Ren, Y. Fan, Y. Su, Y. Zhang, Y. Zhang, Y. Wan, Y. Liu, Z. Wang, Z. Cui, Z. Zhang, Z. Zhou, and Z. Qiu Qwen3 technical report. External Links: 2505.09388, Link Cited by: §4. Youden (1950) W. J. Youden Index for rating diagnostic tests. Cancer 3 (1), p. 32–35. Cited by: §C.1. Zhang et al. (2026a) Q. Zhang, C. Hu, S. Upasani, B. Ma, F. Hong, V. Kamanuru, J. Rainton, C. Wu, M. Ji, H. Li, U. Thakker, J. Zou, and K. Olukotun Agentic context engineering: evolving contexts for self-improving language models. In The Fourteenth International Conference on Learning Representations, External Links: Link Cited by: §2. Zhang et al. (2026b) Y. Zhang, T. Xu, S. Dai, Z. Shao, Q. Wu, and H. Wang EVOCHAMBER: test-time co-evolution of multi-agent system at individual, team, and population scales. External Links: 2605.11136, Link Cited by: §2. Zhang et al. (2026c) Y. Zhang, T. Xu, Y. Zhao, J. Zhao, Q. Wu, and H. Wang EvalResearchBench: can AI agents design their own evaluations?. External Links: 2610.04184, Link Cited by: §2. Zhao et al. (2024) A. Zhao, D. Huang, Q. Xu, M. Lin, Y. Liu, and G. Huang Expel: llm agents are experiential learners. In Proceedings of the AAAI Conference on Artificial Intelligence, Vol. 38, p. 19632–19642. Cited by: §1, §2. Zheng et al. (2023) L. Zheng, W. Chiang, Y. Sheng, S. Zhuang, Z. Wu, Y. Zhuang, Z. Lin, Z. Li, D. Li, E. Xing, et al. Judging llm-as-a-judge with mt-bench and chatbot arena. Advances in neural information processing systems 36, p. 46595–46623. Cited by: §4, §4. Zhu et al. (2026) J. Zhu, Y. Zhang, Z. Ma, B. Zhang, A. Schoepf, D. Woloch, P. Y. Wang, G. R. Yang, S. Jacob, S. Nagisetty, A. Chundru, J. Lin, S. Mateega, and J. Zhang SpreadsheetBench 2: evaluating agents on end-to-end business spreadsheet workflows. External Links: 2606.29955, Link Cited by: §D.8, §5. Zhu et al. (2025) K. Zhu, H. Li, S. Wu, T. Xing, D. Ma, X. Tang, M. Liu, J. Yang, J. Liu, Y. E. Jiang, C. Zhang, C. Lin, J. Wang, G. Zhang, and W. Zhou Scaling test-time compute for llm agents. External Links: 2506.12928, Link Cited by: §2. Zhuo et al. (2025) T. Y. Zhuo, V. M. Chien, J. Chim, H. Hu, W. Yu, R. Widyasari, I. N. B. Yusuf, H. Zhan, J. He, I. Paul, S. Brunner, C. GONG, J. Hoang, A. R. Zebaze, X. Hong, W. Li, J. Kaddour, M. Xu, Z. Zhang, P. Yadav, N. Jain, A. Gu, Z. Cheng, J. Liu, Q. Liu, Z. Wang, D. Lo, B. Hui, N. Muennighoff, D. Fried, X. Du, H. de Vries, and L. V. Werra BigCodeBench: benchmarking code generation with diverse function calls and complex instructions. In The Thirteenth International Conference on Learning Representations, External Links: Link Cited by: §4. Appendix A Limitations UCoE measures driving capacity on declared families of local edits, so passing the response contrasts does not guarantee reliable discrimination on natural revisions, on interacting errors, or on task properties that no family covers. Broader contrasts with independently checked preference directions would give verifier selection a stronger test. The deployed verifier also carries a coupled risk: because it diagnoses weaknesses, selects the served response, and decides which repairs enter the harness state, one mistaken judgment can accept a harmful repair and store a misleading procedure. Independent checks or rollback rules would reduce that risk. Finally, open-ended evaluation still relies on model judges, and repeated semantic scoring makes UCoE more expensive than the simpler feedback baselines, so validation with diverse evaluators or humans and cheaper verifier execution are the next steps. Appendix B Algorithm Algorithm 1 gives the complete lifecycle. Initialization runs at t=0t=0, and every later checkpoint synthesizes candidates from the diagnostics of completed tasks only. H denotes the harness state, E the diagnostic history, and ℛR the fixed relation inventory mined from the development pairs devP_ dev. The main experiments instantiate H as a bounded procedural memory, and the agent-harness study of App. D.8 instantiates it as the context of a coding agent. Algorithm 1 Unified Co-Evolution 1: Public requirements R, optional development response pairs devP_ dev, actor Fθ0F_ _0, verifier model, initial harness state HinitH_ init, and task stream x1:Tx_1:T 2: Calibration source reservoir S and checkpoint set T 3: Candidate budget L, contrast families, comparison budgets, margin ϵε, harness-update rules 4: Returned responses y1:Ty_1:T, harness state H, and verifier-decision history 5: H←HinitH← H_ init, E←∅E← , and ←⊥V _ 6: ℛ←MineRelations(dev)R (P_ dev) if supplied; otherwise ℛ←∅R← 7: for t=0,…,Tt=0,…,T do 8: if t>0t>0 then 9: yt0←Fθ0(xt,H)y_t^0← F_ _0(x_t;H) through the configured harness interface 10: (yt,ytR,at,ct,wt,ut)←(yt0,⊥,0,⊥,⊥,⊥)(y_t,y_t^R,a_t,c_t,w_t,u_t)←(y_t^0, ,0, , , ) 11: if ≠⊥V _ then 12: (ct,wt,ut)←D(xt,yt0)(c_t,w_t,u_t)← D_V(x_t,y_t^0) 13: ytR←Fθ0(xt,yt0,ct,wt,ut,H)y_t^R← F_ _0(x_t,y_t^0,c_t,w_t,u_t;H) 14: if r(xt,ytR)>r(xt,yt0)+ϵr_V(x_t,y_t^R)>r_V(x_t,y_t^0)+ε then 15: (yt,at)←(ytR,1)(y_t,a_t)←(y_t^R,1) 16: end if 17: end if 18: Return yty_t; subsequent updates derived from task t affect only later tasks 19: if ≠⊥V _ then 20: H←UpdateHarness(H,xt,yt0,ytR,ct,wt,at)H (H,x_t,y_t^0,y_t^R,c_t,w_t,a_t) ⊳ new state content only if at=1a_t=1 21: end if 22: Append the completed task and available verifier diagnostics to E 23: end if 24: if t=0t=0 or t∈t then 25: d←Summarize(E)d (E), with d=∅d= at initialization 26: ←GenerateVerifiers(R,ℛ,d,L)K (R,R,d,L) using the verifier model 27: Include V in K if ≠⊥V _ and discard non-executable candidates 28: Freeze all candidate programs and the scoring, diagnosis, and selection conventions 29: if ≠∅K≠ then 30: (Bsel,Bval)←Contrasts(,ℛ)(B_ sel,B_ val) (S,R) ⊳ source-disjoint within checkpoint 31: ^∈argmax′∈round4(minjJ^sel,j(h′)) V∈ _V round_4( _j J_ sel,j(h_V )) 32: Fix V before evaluating any required held-out comparisons 33: if =⊥V=V_ then 34: b←1b← 1 ⊳ adopt the initial selected candidate 35: else 36: b←UpdateCriteria(^,,Bsel,Bval)b ( V,V,B_ sel,B_ val) ⊳ Eq. (19) 37: end if 38: if b=1b=1 then 39: ←^V← V ⊳ affects only tasks after t 40: end if 41: end if 42: Record the selection, held-out comparison, and adopt-or-retain decision 43: end if 44: end for 45: Finalize all responses, verifier decisions, and harness states before final evaluation 46: return (y1:T,H,E)(y_1:T,H,E) and the verifier-decision history The update criteria in UpdateCriteriaUpdateCriteria require a strict gain in worst-family accuracy on the selection split, more held-out contrasts won than lost against the current verifier, and no regression beyond the tolerance on any existing family, and any failed or undefined comparison retains the current verifier. Equation (19) states them exactly. While no verifier is deployed, UCoE serves the draft and leaves the harness state unchanged, but later checkpoints still run. Calibration data and final-evaluator feedback never enter deployment. The reference procedure draws fresh comparison sources at each checkpoint. Appendix C Theoretical analysis We analyze the selectors induced by UCoE’s verifier programs on fixed response-pair distributions. The results explain the normalization of driving capacity, the worst-family selection objective, and the guarantees of the empirical update rule. Hats denote sample estimates, and population bounds require the sampling assumptions stated below. C.1 Pairwise discrimination and selection gain For a task x, let ycy_c be the proposed response and yry_r the reference response. With a fixed margin ϵ≥0ε≥ 0, the verifier induces h,ϵ(x,yc,yr)=yc,r(x,yc)>r(x,yr)+ϵ,yr,otherwise.h_V,ε(x;y_c,y_r)= casesy_c,&r_V(x,y_c)>r_V(x,y_r)+ε,\\ y_r,&otherwise. cases (10) An undefined comparison returns yry_r. Contrasts use (yc,yr)=(y+,y−)(y_c,y_r)=(y^+,y^-), whereas deployment uses (yc,yr)=(yR,y0)(y_c,y_r)=(y^R,y^0). We write h_V for this selector at the fixed margin. For family j, define pj(h)=Pr(h selects y+∣j)p_j(h)= (h selects y^+ j) and Jj(h)=2pj(h)−1J_j(h)=2p_j(h)-1. Uniform random choice gives Jj=0J_j=0. A verifier that always assigns equal scores has Jj=−1J_j=-1, since every tie fails the strict-margin test. For the covariance interpretation (Price, 1970), write (Y1,Y2)=(y+,y−)(Y_1,Y_2)=(y^+,y^-) and let Sh∈1,2S_h∈\1,2\ be the selected position. Let Ui∈0,1U_i∈\0,1\ indicate whether YiY_i satisfies the targeted property. A valid contrast must satisfy (U1,U2)=(1,0)(U_1,U_2)=(1,0). This is a semantic assumption about the edited property, which eligibility checks alone cannot establish. Draw I∼Unif1,2I \1,2\ independently of the contrast, its family, and all scoring and selection randomness. Set Gh=[Sh=I]G_h=1[S_h=I] and U=UIU=U_I. The auxiliary index does not change the response order or the selector. Proposition 1 (Pairwise selection covariance). For valid targeted contrasts and the independent index defined above, Cov(Gh,U∣j)=14Jj(h).Cov(G_h,U j)= 14J_j(h). (11) Thus the signed driving capacity ~ℬ C_B in Eq. (4) is the minimum selection covariance over the tested families. Its nonnegative part is ℬC_B. Proof. Fix a family j. Since (U1,U2)=(1,0)(U_1,U_2)=(1,0), we have U=1U=1 exactly when I=1I=1. The index I is uniform and independent of ShS_h conditional on j, so [U∣j] [U j] =Pr(I=1∣j)=12, = (I=1 j)= 12, [Gh∣j] [G_h j] =∑s=12Pr(I=s,Sh=s∣j)=12∑s=12Pr(Sh=s∣j)=12, = _s=1^2 (I=s,S_h=s j)= 12 _s=1^2 (S_h=s j)= 12, [GhU∣j] [G_hU j] =Pr(I=1,Sh=1∣j)=12Pr(Sh=1∣j)=12pj(h). = (I=1,S_h=1 j)= 12 (S_h=1 j)= 12p_j(h). The last line uses GhU=1G_hU=1 exactly when the sampled position and the selected position are both 1. Substituting these expectations into the definition of covariance gives Cov(Gh,U∣j) (G_h,U j) =[GhU∣j]−[Gh∣j][U∣j] =E[G_hU j]-E[G_h j]\,E[U j] =pj(h)2−12⋅12=2pj(h)−14=14Jj(h). = p_j(h)2- 12· 12= 2p_j(h)-14= 14J_j(h). For h=h=h_V, taking the minimum over the tested families yields minjCov(Gh,U∣j)=14minjJj(h)=~ℬ(). _jCov(G_h,U j)= 14 _jJ_j(h)= C_B(V). Clipping this minimum at zero gives ℬ()C_B(V). ∎ The auxiliary retention rates are Pr(Gh=1∣U=1,j)=pj(h) (G_h=1 U=1,j)=p_j(h) and Pr(Gh=1∣U=0,j)=1−pj(h) (G_h=1 U=0,j)=1-p_j(h), whose difference is Youden’s index Jj(h)J_j(h) (Youden, 1950). Because contrasts always place the preferred response in the proposed position and count ties and reversed rankings alike as failures, these rates measure discrimination on the tested property, not the acceptance of natural revisions. To describe selection gain on general pairs, fix a distribution of (x,Y1,Y2,Z1,Z2)(x,Y_1,Y_2,Z_1,Z_2), where Zi∈0,1Z_i∈\0,1\ is an evaluation-only adequacy label for YiY_i. Each selector chooses a position Sh∈1,2S_h∈\1,2\ on the same pairs. Let M=[Z1≠Z2]M=1[Z_1≠ Z_2], q=Pr(M=1)q= (M=1), and, for q>0q>0, define Jmix(h)=2Pr(ZSh=1∣M=1)−1J_ mix(h)=2 (Z_S_h=1 M=1)-1. Proposition 2 (Selection gain on fixed response pairs). For any two selectors h,h′h,h on this pair distribution with q>0q>0, [ZSh′−ZSh]=q2Jmix(h′)−Jmix(h).E[Z_S_h -Z_S_h]= q2\J_ mix(h )-J_ mix(h)\. (12) If q=0q=0, the expected adequacy difference is zero. Proof. When M=0M=0, we have Z1=Z2Z_1=Z_2, so ZSh′−ZSh=0Z_S_h -Z_S_h=0 regardless of which positions the selectors choose. Thus ZSh′−ZSh=M(ZSh′−ZSh)Z_S_h -Z_S_h=M(Z_S_h -Z_S_h). If q=0q=0, this difference is zero almost surely, proving the second claim. For q>0q>0, binary adequacy and the definition of JmixJ_ mix give [ZSh∣M=1]=Pr(ZSh=1∣M=1)=1+Jmix(h)2,E[Z_S_h M=1]= (Z_S_h=1 M=1)= 1+J_ mix(h)2, and the same equality holds for h′h . Conditioning on M=1M=1 and substituting both expressions, we obtain [ZSh′−ZSh] [Z_S_h -Z_S_h] =[M(ZSh′−ZSh)] =E\! [M(Z_S_h -Z_S_h) ] =q[ZSh′−ZSh∣M=1] =q\,E[Z_S_h -Z_S_h M=1] =q[ZSh′∣M=1]−[ZSh∣M=1] =q \E[Z_S_h M=1]-E[Z_S_h M=1] \ =q1+Jmix(h′)2−1+Jmix(h)2 =q \ 1+J_ mix(h )2- 1+J_ mix(h)2 \ =q2Jmix(h′)−Jmix(h). = q2 \J_ mix(h )-J_ mix(h) \. ∎ The factor q measures how often selection can matter, and the change in JmixJ_ mix measures how well the new selector uses those opportunities. The identity is about binary adequacy on a fixed pair distribution, so carrying it to contrast accuracy or to the deployed stream, where diagnosis, proposals, and harness state all move the pairs, needs further assumptions. C.2 Worst-family selection over a finite verifier pool Let m≥1m≥ 1 be the number of contrast families. For population statements, ℬB denotes their fixed distributions, and probabilities include any scoring randomness. We write ~ℬ(h)=14minjJj(h) C_B(h)= 14 _jJ_j(h) and ℬ(h)=max0,~ℬ(h)C_B(h)= \0, C_B(h)\ for the capacities of an induced selector. A family mixture has weights w∈Δm=w∈[0,1]m:∑jwj=1w∈ _m=\w∈[0,1]^m: _jw_j=1\ and success probability pw(h)=∑jwjpj(h)p_w(h)= _jw_jp_j(h). Theorem 1 (Robust interpretation of driving capacity). For every selector h, infw∈Δmpw(h)=minjpj(h)=12+2~ℬ(h). _w∈ _mp_w(h)= _jp_j(h)= 12+2 C_B(h). (13) Maximizing signed driving capacity over a nonempty finite pool therefore maximizes the worst-case success probability over all mixtures of the tested families. Proof. Fix a selector h and choose j⋆∈argmin1≤j≤mpj(h)j ∈ *arg\,min_1≤ j≤ mp_j(h). For any w∈Δmw∈ _m, the weights are nonnegative and sum to one, so pw(h) p_w(h) =∑j=1mwjpj(h)≥∑j=1mwjpj⋆(h) = _j=1^mw_jp_j(h)≥ _j=1^mw_jp_j (h) =pj⋆(h)∑j=1mwj=pj⋆(h). =p_j (h) _j=1^mw_j=p_j (h). Thus every mixture has success probability at least minjpj(h) _jp_j(h). This bound is attained by the weights wj⋆=1w _j =1 and wj⋆=0w _j=0 for j≠j⋆j≠ j , which belong to Δm _m and satisfy pw⋆(h)=pj⋆(h)=minjpj(h).p_w (h)=p_j (h)= _jp_j(h). Combining the lower bound with this attaining mixture gives infw∈Δmpw(h)=minjpj(h) _w∈ _mp_w(h)= _jp_j(h). Using Jj(h)=2pj(h)−1J_j(h)=2p_j(h)-1 and the definition of signed driving capacity, minjpj(h) _jp_j(h) =minj1+Jj(h)2 = _j 1+J_j(h)2 =12+12minjJj(h) = 12+ 12 _jJ_j(h) =12+2(14minjJj(h))=12+2~ℬ(h). = 12+2 ( 14 _jJ_j(h) )= 12+2 C_B(h). The last expression is strictly increasing in signed driving capacity. Therefore, over any nonempty finite selector pool, signed driving capacity and worst-case mixture success probability have the same maximizers. ∎ This is the group maximin structure used in distributionally robust optimization (Sagawa* et al., 2020): it covers changes in family weights while each family’s distribution stays fixed. Maximizing the signed capacity also maximizes its nonnegative part while still separating candidates that clipping would assign the same zero value. Sampling assumptions. Fix a nonempty finite selector pool ℋH and family sample sizes nj≥1n_j≥ 1 before drawing selection sources. Each source used in family j contributes one comparison to that family. For a fixed h and j, assume the outcomes Xijh=2[h selects y+ on source i in family j]−1,i=1,…,nj,X_ijh=21[h selects y^+ on source i in family j]-1, i=1,…,n_j, are independent across sources. Define J^j(h)=nj−1∑iXijh J_j(h)=n_j^-1 _iX_ijh and assume nj−1∑i[Xijh]=Jj(h)n_j^-1 _iE[X_ijh]=J_j(h). This allows fixed stratification with the corresponding population mixture. Every selector is evaluated on all declared comparisons with a predeclared outcome for missing or invalid scores. Candidate-dependent removal of comparisons is excluded. Different families may share sources, and different selectors may share scores. For history-generated pools, these assumptions hold conditional on the history and synthesis information fixed before sampling. Proposition 3 (Finite-pool maximin selection). Under these assumptions, for δ∈(0,1)δ∈(0,1) let ρδ=maxj2njlog2|ℋ|mδ. _δ= _j 2n_j 2|H|mδ. (14) With probability at least 1−δ1-δ, suph∈ℋ, 1≤j≤m|J^j(h)−Jj(h)|≤ρδ. _h ,\,1≤ j≤ m| J_j(h)-J_j(h)|≤ _δ. (15) On this event, any h^∈ℋ h whose empirical worst-family score is within τ≥0τ≥ 0 of the maximum satisfies minjJj(h^)≥maxh∈ℋminjJj(h)⏟best populationscore in the pool−2ρδ⏟samplingerror bound−τ⏟optimizationerror. _jJ_j( h)≥ _h _jJ_j(h)_ subarraycbest population\\ score in the pool subarray- 2 _δ_ subarraycsampling\\ error bound subarray- τ_ subarraycoptimization\\ error subarray. (16) Its signed or nonnegative capacity is at most ρδ/2+τ/4 _δ/2+τ/4 below the best corresponding capacity in the pool. Exact maximization has τ=0τ=0. Maximizing scores rounded to four decimals gives τ≤10−4τ≤ 10^-4. Proof. Fix a selector h∈ℋh and a family j. The sampling assumptions give independence across sources and [J^j(h)]=Jj(h)E[ J_j(h)]=J_j(h). Since Xijh∈[−1,1]X_ijh∈[-1,1], Hoeffding’s inequality (Hoeffding, 1963) yields, for u>0u>0, Pr(|J^j(h)−Jj(h)|>u)≤2exp(−2nj2u2∑i=1nj(1−(−1))2)=2exp(−nju22). \! (| J_j(h)-J_j(h)|>u )≤ 2 \! (- 2n_j^2u^2 _i=1^n_j(1-(-1))^2 )=2 \! (- n_ju^22 ). By the definition of ρδ _δ, each family satisfies njρδ2/2≥log(2|ℋ|m/δ)n_j _δ^2/2≥ (2|H|m/δ). Substituting u=ρδu= _δ gives Pr(|J^j(h)−Jj(h)|>ρδ)≤2exp(−log2|ℋ|mδ)=δ|ℋ|m. \! (| J_j(h)-J_j(h)|> _δ )≤ 2 \! (- 2|H|mδ )= δ|H|m. A union bound over all |ℋ|m|H|m selector–family pairs then gives Pr(suph∈ℋ, 1≤j≤m|J^j(h)−Jj(h)|>ρδ) \! ( _h ,\,1≤ j≤ m| J_j(h)-J_j(h)|> _δ ) ≤∑h∈ℋ∑j=1mPr(|J^j(h)−Jj(h)|>ρδ) ≤ _h _j=1^m \! (| J_j(h)-J_j(h)|> _δ ) ≤|ℋ|mδ|ℋ|m=δ. ≤|H|m\, δ|H|m=δ. This proves Eq. (15) without requiring independence between different selectors or families. Work on this uniform event. For every h and j, J^j(h)−ρδ≤Jj(h)≤J^j(h)+ρδ J_j(h)- _δ≤ J_j(h)≤ J_j(h)+ _δ. Taking minima over j gives minjJ^j(h)−ρδ≤minjJj(h)≤minjJ^j(h)+ρδ. _j J_j(h)- _δ≤ _jJ_j(h)≤ _j J_j(h)+ _δ. Thus each empirical minimum differs from its population minimum by at most ρδ _δ, even if the minimizing families differ. Choose h⋆∈argmaxh∈ℋminjJj(h)h ∈ *arg\,max_h _jJ_j(h), which exists because ℋH is nonempty and finite. The assumed empirical optimization accuracy means minjJ^j(h^)≥maxh∈ℋminjJ^j(h)−τ≥minjJ^j(h⋆)−τ. _j J_j( h)≥ _h _j J_j(h)-τ≥ _j J_j(h )-τ. Combining these inequalities yields minjJj(h^) _jJ_j( h) ≥minjJ^j(h^)−ρδ ≥ _j J_j( h)- _δ ≥minjJ^j(h⋆)−ρδ−τ ≥ _j J_j(h )- _δ-τ ≥minjJj(h⋆)−2ρδ−τ ≥ _jJ_j(h )-2 _δ-τ =maxh∈ℋminjJj(h)−2ρδ−τ, = _h _jJ_j(h)-2 _δ-τ, which proves Eq. (16). Dividing by four and using the definition of signed driving capacity gives 0≤~ℬ(h⋆)−~ℬ(h^)≤2ρδ+τ4=ρδ2+τ4.0≤ C_B(h )- C_B( h)≤ 2 _δ+τ4= _δ2+ τ4. For any a≥ba≥ b, the positive-part map satisfies 0≤max0,a−max0,b≤a−b0≤ \0,a\- \0,b\≤ a-b. Apply this with a=~ℬ(h⋆)a= C_B(h ) and b=~ℬ(h^)b= C_B( h). Since h⋆h also maximizes the nonnegative capacity, the same upper bound holds for its gap to the best in the pool. Finally, write F^(h)=minjJ^j(h) F(h)= _j J_j(h) and F¯(h)=round4(F^(h)) F(h)=round_4( F(h)). Rounding to four decimals gives |F¯(h)−F^(h)|≤η| F(h)- F(h)|≤η, where η=5×10−5η=5× 10^-5. If h h maximizes F¯ F, then for every h∈ℋh , F^(h^) F( h) ≥F¯(h^)−η ≥ F( h)-η ≥F¯(h)−η ≥ F(h)-η ≥F^(h)−2η. ≥ F(h)-2η. Taking the maximum over h shows that the empirical optimization loss is at most 2η=10−42η=10^-4, proving the stated rounding bound. ∎ Interpretation. Equation (16) bounds the selected verifier’s population worst-family score relative to the best candidate in the fixed pool. The sampling term 2ρδ2 _δ allows the selected candidate’s empirical score to overestimate its true score by ρδ _δ and the population optimum’s empirical score to underestimate its true score by another ρδ _δ. The term τ accounts for approximate empirical maximization, including rounding. Writing nmin=minjnjn_ = _jn_j, we have ρδ=(2/nmin)log(2|ℋ|m/δ) _δ= (2/n_ ) (2|H|m/δ), so the least-sampled family controls this uniform bound. The guarantee is stated on the fixed contrast distributions. Comparison with the current verifier. Equation (16) compares the selected candidate with the population optimum in the pool. At an update checkpoint, we can instead compare a candidate h′h with the current selector hkh_k, assuming both belong to ℋH. Let their observed, unrounded gain in empirical worst-family score be g=minjJ^j(h′)−minjJ^j(hk).g= _j J_j(h )- _j J_j(h_k). On the uniform event of Eq. (15), the candidate’s population score is at least its empirical score minus ρδ _δ, whereas the current selector’s population score is at most its empirical score plus ρδ _δ. Subtracting these two bounds gives minjJj(h′)−minjJj(hk) _jJ_j(h )- _jJ_j(h_k) ≥(minjJ^j(h′)−ρδ)−(minjJ^j(hk)+ρδ) ≥ ( _j J_j(h )- _δ )- ( _j J_j(h_k)+ _δ ) =g−2ρδ. =g-2 _δ. Dividing by four converts the score difference into a signed-capacity difference: ~ℬ(h′)−~ℬ(hk)≥g−2ρδ4. C_B(h )- C_B(h_k)≥ g-2 _δ4. (17) Thus g is the improvement measured on the selection sample, and 2ρδ2 _δ accounts for estimation error on both sides of the comparison. No optimization term τ is needed here because g compares these two selectors directly, regardless of how the candidate was chosen within the pool. If g>2ρδg>2 _δ, the bound is strictly positive and certifies an increase in population signed driving capacity on the uniform event. When 0<g≤2ρδ0<g≤ 2 _δ the sample shows a gain that the bound cannot certify, and small family budgets make it uninformative. This threshold is a sufficient condition for the guarantee only. UCoE adopts by the empirical selection gain and the held-out comparisons of the next subsection. C.3 Evolution under the empirical verifier-update rule At a checkpoint, UCoE includes the current verifier in the selection pool, chooses a candidate, and fixes it before evaluating held-out contrasts. Let h and h′h be the current and selected candidate selectors. The family inventory stays fixed. We first establish what adoption guarantees on the observed comparison sets, then bound the population capacity change under additional sampling assumptions. The empirical results below assume common comparison sets with finite scores for both selectors, so all paired counts and family accuracies use the same denominators. Let nj≥1n_j≥ 1 now denote the held-out count in family j, with N=∑jnjN= _jn_j. For held-out comparison i in family j, define Cij(h)=[h selects y+]C_ij(h)=1[h selects y^+], J^val,j(h)=2nj−1∑iCij(h)−1 J_ val,j(h)=2n_j^-1 _iC_ij(h)-1, and p^pool(h)=N−1∑j,iCij(h) p_ pool(h)=N^-1 _j,iC_ij(h). Thus p^pool p_ pool weights each contrast equally, giving family j weight nj/Nn_j/N, and it is an equal-family average only when the family counts are equal. The selection-split estimate J^sel,j J_ sel,j is defined in the same way using that split’s comparisons. Write W W =∑j,i[Cij(h′)=1,Cij(h)=0], = _j,i1[C_ij(h )=1,C_ij(h)=0], L L =∑j,i[Cij(h′)=0,Cij(h)=1], = _j,i1[C_ij(h )=0,C_ij(h)=1], Δ^Jj J_j =J^val,j(h′)−J^val,j(h), = J_ val,j(h )- J_ val,j(h), Γ^sel _ sel =minjJ^sel,j(h′)−minjJ^sel,j(h). = _j J_ sel,j(h )- _j J_ sel,j(h). (18) Thus W and L count candidate-only and current-only successes. Let Γ¯sel _ sel be the difference between the two selection minima after each is rounded to four decimals. For these complete comparisons, the update rule is hk+1=h′,Γ¯sel>0⏟selection gain,W>L⏟held-out gain,minjΔ^Jj≥−κ⏟bounded family regression,h,otherwise,κ=0.10.h_k+1= casesh ,& _ sel>0_selection gain, W>L_held-out gain, _j J_j≥-κ_bounded family regression,\\ h,&otherwise, cases κ=0.10. (19) The first condition requires a strict increase in the selection split’s worst-family score. The held-out conditions require more candidate-only than current-only successes and limit the decrease in every family’s centered accuracy to κ. A missing required family check retains h. Initialization adopts a maximin winner without this paired test, since there is no current verifier. For s∈sel,vals∈\ sel, val\, define ~^s(h)=14minjJ^s,j(h) C_s(h)= 14 _j J_s,j(h) and ^s(h)=max0,~^s(h) C_s(h)= \0, C_s(h)\. Proposition 4 (Empirical gain and bounded family regression). Every candidate adopted under Eq. (19) satisfies ~^sel(h′)−~^sel(h) C_ sel(h )- C_ sel(h) =14Γ^sel>0, = 14 _ sel>0, (20) p^pool(h′)−p^pool(h) p_ pool(h )- p_ pool(h) =W−LN>0, = W-LN>0, (21) ~^val(h′)−~^val(h) C_ val(h )- C_ val(h) ≥−κ4. ≥- κ4. (22) The last bound also holds for the nonnegative held-out capacity. Proof. Suppose h′h is adopted, so all three conditions in Eq. (19) hold. Rounding to four decimals is nondecreasing. If the candidate’s unrounded selection minimum were no larger than the current selector’s, its rounded minimum could not be larger either. Thus Γ¯sel>0 _ sel>0 implies Γ^sel>0 _ sel>0. Substituting the definition of empirical signed capacity, ~^sel(h′)−~^sel(h) C_ sel(h )- C_ sel(h) =14minjJ^sel,j(h′)−minjJ^sel,j(h) = 14 \ _j J_ sel,j(h )- _j J_ sel,j(h) \ =14Γ^sel>0, = 14 _ sel>0, which proves Eq. (20). For the pooled success rate, each difference Cij(h′)−Cij(h)C_ij(h )-C_ij(h) is +1+1 on a candidate-only success, −1-1 on a current-only success, and 00 when the selectors both succeed or both fail. Summing over the common held-out comparisons therefore gives p^pool(h′)−p^pool(h) p_ pool(h )- p_ pool(h) =1N∑j=1m∑i=1njCij(h′)−Cij(h) = 1N _j=1^m _i=1^n_j\C_ij(h )-C_ij(h)\ =W−LN>0, = W-LN>0, where the strict inequality follows from W>LW>L. This proves Eq. (21). For the held-out capacity, the regression condition gives, for every family j, J^val,j(h′)≥J^val,j(h)−κ≥minℓJ^val,ℓ(h)−κ. J_ val,j(h )≥ J_ val,j(h)-κ≥ _ J_ val, (h)-κ. The last expression is independent of j, so taking the minimum on the left yields minjJ^val,j(h′)≥minjJ^val,j(h)−κ. _j J_ val,j(h )≥ _j J_ val,j(h)-κ. Subtracting the current minimum and dividing by four proves Eq. (22), even if the weakest family changes. To obtain the nonnegative-capacity bound, write a=~^val(h)a= C_ val(h) and b=~^val(h′)b= C_ val(h ). We have b≥a−κ/4b≥ a-κ/4, and hence max0,b≥max0,a−κ/4≥max0,a−κ/4. \0,b\≥ \0,a-κ/4\≥ \0,a\-κ/4. The first inequality uses monotonicity of the positive-part map, and the second uses that reducing its argument by κ/4κ/4 reduces its value by at most κ/4κ/4. Subtracting max0,a \0,a\ proves the remaining claim. ∎ Interpretation. The three conclusions concern different quantities: signed capacity strictly increases on the selection split, pooled success rate strictly increases on the held-out split, and held-out capacity may decrease within the allowed tolerance. Since Jj=2pj−1J_j=2p_j-1, κ=0.10κ=0.10 permits at most a five-percentage-point decrease in any family’s held-out success rate and a 0.0250.025 decrease in held-out capacity. For example, on two equally sized held-out families, success rates changing from (0.80,0.60)(0.80,0.60) to (0.90,0.56)(0.90,0.56) raise pooled success from 0.700.70 to 0.730.73 while lowering signed capacity from 0.050.05 to 0.030.03. Both held-out conditions pass, although adoption still requires the separate selection condition. These are exact statements on the observed comparison sets and need no independence assumption. Population interpretation. Condition on the history, synthesis, and selection information so that h,h′h,h are fixed. Suppose validation uses fresh sources independent of that information, with fixed family counts njn_j. Within each family, assume the paired outcomes (Cij(h),Cij(h′))(C_ij(h),C_ij(h )) are independent across sources, with one comparison per source. Different families may share sources. All probabilities and expectations below are conditional on this pre-validation information. Let ΔJj=Jj(h′)−Jj(h) J_j=J_j(h )-J_j(h) be the population change in family j, and define Yij=2Cij(h′)−Cij(h)∈−2,0,2,Δ^Jj=1nj∑i=1njYij.Y_ij=2\C_ij(h )-C_ij(h)\∈\-2,0,2\, J_j= 1n_j _i=1^n_jY_ij. Assume nj−1∑i[Yij]=ΔJjn_j^-1 _iE[Y_ij]= J_j, so the empirical change has the stated population mean. Because Yij∈[−2,2]Y_ij∈[-2,2] and the paired outcomes are independent across sources, one-sided Hoeffding gives, for any u>0u>0, Pr(ΔJj<Δ^Jj−u) \! ( J_j< J_j-u ) =Pr(Δ^Jj−ΔJj>u) = \! ( J_j- J_j>u ) ≤exp(−2nj2u2∑i=1nj(2−(−2))2)=exp(−nju28). ≤ \! (- 2n_j^2u^2 _i=1^n_j(2-(-2))^2 )= \! (- n_ju^28 ). For δ∈(0,1)δ∈(0,1), choose bj=8njlogmδ.b_j= 8n_j mδ. Substituting u=bju=b_j bounds the failure probability for family j by exp(−njbj2/8)=δ/m (-n_jb_j^2/8)=δ/m. A union bound over the m families gives Pr(∃j:ΔJj<Δ^Jj−bj) \! (∃ j: J_j< J_j-b_j ) ≤∑j=1mPr(ΔJj<Δ^Jj−bj) ≤ _j=1^m \! ( J_j< J_j-b_j ) ≤∑j=1mδm=δ. ≤ _j=1^m δm=δ. Thus, with conditional probability at least 1−δ1-δ, every population family change is at least its observed change minus bjb_j. Only one fixed selector pair is compared on validation, so this union bound ranges over families, not the candidate pool. On this event, for every j, Jj(h′)=Jj(h)+ΔJj≥minℓJℓ(h)+minℓΔJℓ.J_j(h )=J_j(h)+ J_j≥ _ J_ (h)+ _ J_ . Taking the minimum over j on the left and rearranging yields minjJj(h′)−minjJj(h)≥minjΔJj≥minj(Δ^Jj−bj). _jJ_j(h )- _jJ_j(h)≥ _j J_j≥ _j( J_j-b_j). The first inequality need not be an equality, since the weakest family can change between selectors. Dividing by four gives the capacity bound, so on the same event ΔJj J_j ≥Δ^Jj−bjfor every j, ≥ J_j-b_j every j, ~ℬ(h′)−~ℬ(h) C_B(h )- C_B(h) ≥14minj(Δ^Jj−bj). ≥ 14 _j( J_j-b_j). (23) If the candidate is adopted, Δ^Jj≥−κ J_j≥-κ for every j, hence minj(Δ^Jj−bj)≥minj(−κ−bj)=−κ−maxjbj. _j( J_j-b_j)≥ _j(-κ-b_j)=-κ- _jb_j. Substituting this into Eq. (23) gives ~ℬ(h′)−~ℬ(h)≥−κ4⏟allowed empiricalcapacity regression−maxjbj4⏟samplingerror bound. C_B(h )- C_B(h)≥- κ4_ subarraycallowed empirical\\ capacity regression subarray- _jb_j4_ subarraycsampling\\ error bound subarray. The bound limits population regression on this event without certifying a gain, and it holds for one checkpoint conditional on pre-validation information. The update criteria use only the empirical quantities and never these confidence bounds. Appendix D Experimental settings D.1 Benchmarks and dataset splits Table 4 lists every benchmark with its task type, domain, and number of evaluated tasks. The six open-ended benchmarks cover general assistance, story and domain writing, multi-turn instruction following, and response refinement, and the verifiable benchmarks add instruction compliance, competition mathematics, code generation, and the spreadsheet stream of the agent-harness study. Every experiment fixes the task order before deployment, builds response contrasts from calibration sources disjoint from deployment, and never exposes benchmark answers or final-evaluator feedback to an adaptive method. Table 4: Benchmarks, task types, domains, and evaluated tasks. Benchmark Task type Domain Evaluated tasks Arena-Hard Open-ended Challenging user requests to a general assistant 500 WritingPrompts Open-ended Story generation from writing prompts 1,024 WildBench Open-ended Real-user requests to a general assistant 1,024 WritingBench Open-ended Writing across diverse professional and creative domains 500 MultiChallenge Open-ended Multi-turn conversations with instruction constraints 128 RefineBench Open-ended Free-form refinement of an existing response 278 IFBench Verifiable Verifiable instruction constraints 150 Hard-MATH Verifiable Competition mathematics from MATH-500 and AIME 2022 to 2025 382 BigCodeBench-Hard Verifiable Code generation checked by execution, Instruct split 148 SpreadsheetBench-2 Verifiable Business spreadsheet workflows in the Codex agent harness 75 D.2 Harness-state instantiation In the main experiments the harness state is a bounded procedural memory that sits between the actor and its prompt. Each adaptive method owns an isolated instance that starts empty and follows the same rules for capacity, retrieval, distillation, deduplication, and eviction, so methods differ only in the feedback that decides what enters it. An entry is a procedure with a trigger of at most 10 words and an action of at most 14 words, linked to the criterion and quality dimension that motivated it. When a method accepts a repair, a distillation call turns the draft, the accepted revision, and the feedback into one such procedure and strips task-specific entities and answer content, so a task can add at most one procedure, and only after its response has been returned. A rejected revision updates usage statistics only. Before each draft and revision, retrieval ranks stored procedures by criterion match, then by dimension match, then by their record of accepted and rejected uses, and returns at most two procedures within 64 words, which the actor sees as general guidelines in its prompt. Near duplicates are removed at a normalized token-set Jaccard overlap of 0.75, and when the global capacity of 12 procedures or the per-dimension capacity of 2 is exceeded, the procedure with the weakest acceptance record is evicted, with ties broken by age. Table 6 lists these capacities. D.3 Baseline implementations We compare feedback mechanisms inside one fixed-model, one-revision lifecycle rather than reproducing the parameter-training pipelines of RaR, DREAM, or SpyRL. Table 5 gives each method’s feedback interface and revision decision. In every revision-enabled baseline, the method scores the draft with its own signal, produces one repair from its own feedback, rescores the revision with the same signal, and serves the revision only when its normalized reward rises by more than 0.010.01. All methods share the revision prompt, which provides the task, the draft, the method’s native feedback, and the retrieved procedures, and asks the actor to preserve correct material and return only the revised response. Each adaptive baseline also owns an isolated procedural memory under the rules of App. D.2. No method sees final-evaluator feedback during deployment. Table 5: Training-free baseline interfaces used in our experiments. Method Feedback and parsed output Revision decision Direct Generation No feedback call. The shared draft is served unchanged. No revision and no procedural memory. LLM as a Judge A fixed prompt reads the task and response. It returns "success": true|false and a separate actionable critique, "critique": "...". Binary reward; a revision is accepted only for a →10\!→\!1 change. RaR The task produces 7–15 criteria labeled Essential, Important, Optional, or Pitfall. Grading returns one Boolean per criterion as "passes": [...]; failed criteria form the feedback. Reward is the passed-criterion fraction. Acceptance requires a gain above 0.010.01. DREAM The task produces 3–6 weighted criterion nodes and a root threshold as "nodes": [...], "root": "rule": "weighted_mean", "tau": t. The three lowest-scoring nodes form the feedback. Reward is the weighted node mean. Acceptance requires a gain above 0.010.01. SpyRL A detector compares responses generated from the full task and a partially masked task. Its vote counts yield a role-normalized civilian advantage; the counts and advantage form the feedback. The revision plays a second game. It is accepted when its advantage improves by more than 0.010.01. D.4 Default hyperparameters Table 6 gives the default UCoE hyperparameters on Arena-Hard. The Qwen3-8B and Qwen3.8-27B runs share every value, including the checkpoint schedule and the contrast quotas. Table 6: Default UCoE hyperparameters on Arena-Hard, shared by the Qwen3-8B and Qwen3.8-27B runs. Component Hyperparameter Value Decoding Generation / revision temperature 0.70.7 / 0.70.7 Scoring / synthesis / distillation temperature 00 / 00 / 00 Verifier synthesis Initial candidates 2 New candidates per checkpoint 1 Maximum new criteria per candidate 2 Response contrasts Reference contrast families 3 Selection sources per family 24 Held-out sources per family 96 Selection / held-out sources for the relation family 12 / 24 Response revision Revision attempts per task 1 Acceptance margin ϵε 0.010.01 Procedural memory Total capacity 12 Maximum entries per dimension 2 Maximum retrieved procedures 2 New procedures per accepted revision At most 1 Token-Jaccard deduplication threshold 0.750.75 Verifier updates Checkpoints After tasks 128 and 256 Regression tolerance κ on any existing family 0.100.10 D.5 Contrast-set construction Sources and splits. A contrast pairs a base response y+y^+ with a degraded copy y−y^- of the same response, so the two differ in exactly one declared property and the preference for y+y^+ concerns that property only. Base responses are the actor’s own answers to public calibration prompts that are disjoint from the deployment stream. Each source prompt is assigned to the selection split or the held-out split before any verifier is scored, every contrast built from a source stays in that split, and a source contributes at most one contrast per family. Each checkpoint draws fresh sources, and the two splits stay disjoint within every checkpoint. Benchmark answers and final-evaluator judgments are never used. Reference families. Three transformations apply to every benchmark. Omission removes the two most information-dense sentences, ranked by content-word and numerical density, or the two densest nonempty lines of a code-dominated response. Unsupported-claim injection inserts a sentence that attributes an opposing conclusion to an external review the task never provided. Irrelevant insertion prepends an unrelated passage and checklist while keeping the original answer intact. A source is eligible for omission only with at least five sentences or lines and for claim injection only with at least two sentences, an edit that leaves the response empty or unchanged is discarded, and construction walks the preassigned source order until each family reaches its quota. Story generation replaces these edits with narrative edits of the same kind, such as inserting a contradiction, swapping sentences across the story, truncating the ending, or shuffling sentence order. Relation families. Relation discovery adds benchmark-specific families under one rule. The actor and a larger frozen comparison model answer the same development prompts, the verifier model reads each pair in random order with system identities hidden and names atomic, task-general differences, and a relation is kept only if it recurs in at least three prompts and can be written as one binary criterion with one edit that breaks that property alone. Each retained relation then follows the same source, split, and eligibility rules as the reference families. When a relation family cannot fill its quota, the shortfall is recorded and the run continues without backfilling. Scoring candidates. Every candidate verifier scores the same contrasts, with transformation names and preference directions hidden from the verifier model. A candidate succeeds on a contrast only if r(x,y+)>r(x,y−)+ϵr_V(x,y^+)>r_V(x,y^-)+ε, and a missing or nonfinite score counts as a failure. Selection maximizes the minimum family centered accuracy on the selection split, breaking ties by mean accuracy, then by aggregation simplicity, then by fixed candidate order. The selected candidate and the current verifier are then compared on the same held-out contrasts, and neither may change once held-out scoring has begun. D.6 Implementation details Compute resources. For the main experiments we serve Qwen3-8B, Qwen3.8-27B, Qwen3.6-35B-A3B, and Qwen3.5-397B-A17B through the Tinker API, and we run the WritingBench Critic-7B evaluator in bfloat16 on a single H100. For the other experiments we access GPT-5.4, GPT-5.4-mini, and GPT-4.1 through the OpenAI API (OpenAI, 2025b), run GPT-5.6-luna and GPT-5.6-sol through the Codex app server (OpenAI, 2025a), and serve Qwen3-14B on a cluster of four A100s. Every experiment records actor, verifier-model, and final-evaluator calls separately. Verifier representation and synthesis. Beyond the interface of Section 3.2, each criterion carries explicit descriptions of what earns a score of 0 and of 1, mechanical criteria such as repetition or length are computed directly, and semantic criteria are scored by the verifier model. The aggregation is one expression over criterion scores that may use arithmetic, minima, maxima, order statistics, and conditional dependencies and must stay within [0,1][0,1]. A static validator checks that every referenced criterion is defined, that every new criterion affects the output, and that probe score vectors produce finite values in range, and it discards candidates that fail. A checkpoint candidate inherits the current verifier’s definitions before it appends criteria or changes the aggregation. Scoring and diagnosis. The verifier model scores semantic criteria with deterministic decoding, and candidates that share a criterion reuse the same measurement, so comparing several candidates costs little more than scoring one. The diagnosis procedure takes the weakest criterion that participates in the aggregation, passes its definition, its score, and the response to the verifier model, and receives a localized diagnosis and one short repair instruction without any rescoring. The revision prompt then carries the draft, the diagnosis, the repair instruction, and the retrieved procedures, and asks for the minimal fix that preserves everything else. Verifier updates. At a checkpoint, UCoE summarizes the most recent completed tasks, up to 128 of them, into the revision-acceptance rate, the criteria that were most often weakest, and the size of the harness state, and the verifier model synthesizes one candidate from this summary and the current verifier’s definitions. The candidate and the current verifier are scored on that checkpoint’s response contrasts as in App. D.5, and the update criteria of Equation (19) decide adoption. A failed or undefined comparison retains the current verifier, an adopted candidate first affects the next task, and confidence bounds never enter the decision. D.7 Evaluation Preference score. The primary open-ended endpoint is tie-adjusted pairwise preference against the matched Direct Generation response of the same actor. For every task, Qwen3.5-397B-A17B compares the two full responses in both presentation orders, with deterministic decoding and without method identities, and the two judgments are merged into one task-level outcome for the evaluated method, a win, a tie, or a loss, with identical responses counted as ties. With W, T, and L the numbers of tasks won, tied, and lost over the evaluated set, Pref=100⋅W+12TW+T+L,Pref=100· W+ 12TW+T+L, (24) so a tie receives half credit and 50%50\% is parity. Benchmark-specific metrics. Table 7 lists the native metric of each benchmark and the model or program that scores it. We follow each benchmark’s own scoring procedure, and where it relies on a judge model we use the model named in the table with deterministic decoding. Table 7: Native metric and scorer for each benchmark. Benchmark Native metric Scorer Arena-Hard Style-adjusted win rate against the o3-mini-2025-01-31 anchor, both orders, five-level w3w_3 weighting GPT-4.1 (gpt-4.1-2025-04-14) WritingPrompts None WildBench Mean rating from 1 to 10 with the full-response template Qwen3.5-397B-A17B WritingBench Critic score from 1 to 10 Critic-7B MultiChallenge Hidden-rubric conversation accuracy Qwen3.5-397B-A17B RefineBench Checklist accuracy Qwen3.5-397B-A17B with the benchmark checklist IFBench Strict instruction accuracy Programmatic verifiers Hard-MATH Answer accuracy Answer match against the reference BigCodeBench-Hard Pass@1 Execution harness SpreadsheetBench-2 Exact match of the returned workbook Checker with LibreOffice recalculation D.8 Agent-harness study on SpreadsheetBench-2 This section gives the details of the agent-harness study reported in Section 5: the harness and models, what the harness state is in this setting, the benchmark, its checker, and the two methods we compare against, and the verifier programs. Harness and models. This study runs UCoE inside the Codex coding-agent harness (OpenAI, 2025a) instead of the prompt-level harness of the main experiments. The actor is GPT-5.6-luna at medium reasoning effort and the verifier model is GPT-5.6-sol at extra-high reasoning effort, both served through the Codex app server with fixed parameters. Every actor and verifier call is a fresh Codex session in an isolated task directory, with the Codex tools: a shell that runs Python with openpyxl (Gazoni and Clark, 2024), file editing confined to the task directory, and a helper that recalculates a copy of a workbook. The sandbox allows writes only inside that directory, blocks network access, and requests no approvals. The directory also holds the task instruction, the input workbook, and a task skill file that fixes the workflow for every method: write the completed workbook with openpyxl, use real formulas where the task implies calculations, never modify the input, and treat nothing outside the directory as part of the task. Harness state. In this harness the state HtH_t is the agent’s working context: the Codex tools and sandbox, the task skill file, and an experience block that the runner injects into the actor’s drafting and revision prompts. UCoE evolves only the experience block. It is a bounded list of at most 12 trigger and procedure entries over five dimensions, requirements, formulas, references, preservation, and numbers, with at most 3 entries per dimension and 2,400 characters in total. Entries are distilled from accepted repairs, and the oldest entries are dropped when the block exceeds its size. The tools and the skill file stay fixed, so the study tests whether UCoE’s harness-state updates transfer from the procedural memory of the main experiments to the context of a coding agent. Benchmark and evaluation. SpreadsheetBench-2 (Zhu et al., 2026) provides business spreadsheet tasks in three categories, Template, Financial Model, and Debugging, and the stream used here has 75 tasks. The benchmark’s checker recalculates the returned workbook with LibreOffice (The Document Foundation, 2024) and compares it cell by cell with the reference workbook, so a task counts as correct only on an exact match. The agent never sees the reference workbook, the checker, or any evaluator feedback. We compare UCoE with Direct Generation, which is the same harness, skill file, and actor without feedback or harness state, and with LLM as a Judge, which adds a fixed holistic judge that guides one revision. All three use the same tasks and inputs and are scored with the same checker. Verifier programs. Every candidate verifier keeps a fixed catalogue of base criteria: requirements implemented, formulas correct and consistent, references pointing at the intended cells, unrelated content preserved, values numerically plausible, no recalculated error values in the changed region, and the candidate differing from the input. Requirements, formulas, references, and numerical plausibility are scored by the verifier model in a scoring session that may open the workbook with openpyxl, recalculate an evaluation copy, diff it against the input, list formula precedents, and count error cells. Preservation is checked by a tool diff against the input, and the error-value and changed-workbook checks are deterministic. A candidate may append at most two criteria of the same shape and chooses the aggregation. Scoring uses evidence that the runner recalculates and binds to the candidate workbook, and the diagnosis session receives the frozen scores and returns one localized repair instruction. Appendix E Additional results E.1 Benchmark-specific results Table 8: Benchmark-specific metrics for Qwen3-8B and Qwen3.8-27B. Overall is the unweighted mean after scaling the two 1-to-10 ratings to 0 to 100. Bold marks column maxima. Qwen3-8B Qwen3.8-27B Method Arena- Hard Wild Bench Writing Bench Multi Challenge Refine Bench Overall Arena- Hard Wild Bench Writing Bench Multi Challenge Refine Bench Overall % 1 to 10 1 to 10 % % mean % 1 to 10 1 to 10 % % mean Direct Generation 7.07.0 5.785.78 6.9086.908 33.5933.59 43.2643.26 42.1542.15 51.651.6 7.687.68 8.1798.179 56.2556.25 67.4467.44 66.7866.78 LLM as a Judge 8.18.1 5.705.70 6.9316.931 39.8439.84 42.8542.85 43.4243.42 53.553.5 7.847.84 8.2068.206 53.1253.12 68.1068.10 67.0467.04 RaR 7.87.8 5.735.73 6.9726.972 35.9435.94 45.0245.02 43.1643.16 57.057.0 7.687.68 8.2388.238 51.5651.56 67.9567.95 67.1467.14 DREAM 7.17.1 5.575.57 6.9926.992 29.6929.69 44.1644.16 41.3141.31 57.157.1 7.767.76 8.2238.223 57.8157.81 68.1468.14 68.5868.58 SpyRL 7.27.2 5.255.25 6.9486.948 32.0332.03 41.7641.76 40.5940.59 50.950.9 7.597.59 8.1788.178 54.6954.69 69.0069.00 66.4566.45 UCoE 10.210.2 5.975.97 6.9806.980 38.2838.28 45.6745.67 44.7344.73 60.960.9 7.957.95 8.2158.215 57.8157.81 68.9968.99 69.8769.87 Table 8 reports each benchmark’s native metric for the same runs as Table 1, with WritingPrompts omitted because it has no native metric. UCoE improves over Direct Generation on every metric at both actor sizes and has the highest overall mean in both blocks, 44.7344.73 against 43.4243.42 for the next method at 8B and 69.8769.87 against 68.5868.58 at 27B. The largest gains are on Arena-Hard, where the style-adjusted score rises from 7.07.0 to 10.210.2 at 8B and from 51.651.6 to 60.960.9 at 27B, and UCoE also leads WildBench at both sizes, RefineBench at 8B, and ties for the lead on MultiChallenge at 27B. The rubric-based baselines score slightly higher on WritingBench Critic, LLM as a Judge leads MultiChallenge at 8B, and SpyRL edges RefineBench at 27B by 0.010.01, so the native metrics confirm the preference results without giving UCoE a uniform lead over every baseline. App. E.6 audits the WritingBench revisions with Critic-7B directly. E.2 Cost analysis (a) Cost versus preference (b) UCoE cost by model Figure 5: Cost and preference on six Qwen3-8B benchmarks. (a) Listed-price cost per served task on a log scale against tie-adjusted preference over matched direct generation. Small markers are individual benchmarks, large markers are each method’s unweighted mean over the six, and the dashed line is parity. (b) UCoE’s cost per task on each benchmark broken down by model, with Qwen3.6-35B-A3B as the verifier model. Costs use list prices and exclude final evaluation. Figure 5 places the six Qwen3-8B preferences of Table 1 against listed-price cost. UCoE averages 59.00%59.00\% preference at $0.0142\$0.0142 per task. SpyRL, the only baseline in the same price range at $0.0160\$0.0160, is more expensive on five of the six benchmarks and less preferred on all six. The three simpler baselines cost $0.0050\$0.0050 to $0.0063\$0.0063 per task, so UCoE spends 2.22.2 to 2.82.8 times as much, and in return its mean preference is 10.3510.35 to 13.9913.99 points higher. On every benchmark, most of UCoE’s cost goes to the verifier model, Qwen3.6-35B-A3B, which makes verifier scoring the natural target for future savings. E.3 Cross-backbone transfer and robustness Table 9: Transfer to other actors: preference against matched direct generation. Same protocol and judge as Table 1. Qwen3-14B uses Qwen3.6-35B-A3B as the verifier model, and both GPT actors use GPT-5.4. MultiChallenge is the 128-conversation development set. Bold marks the best method in each column. Qwen3-14B GPT-5.4 GPT-5.4-mini Method Arena- Hard Arena- Hard Multi Challenge Arena- Hard WildBench Refine Bench Multi Challenge Direct Generation 50.0050.00 50.0050.00 50.0050.00 50.0050.00 50.0050.00 50.0050.00 50.0050.00 LLM as a Judge 47.4047.40 54.5054.50 56.6456.64 52.7052.70 54.3954.39 50.0050.00 50.5950.59 RaR 45.8045.80 49.2049.20 53.1253.12 50.8050.80 58.7458.74 50.7250.72 49.2249.22 DREAM 47.6047.60 54.7054.70 56.6456.64 52.3052.30 51.6151.61 49.1049.10 53.3253.32 SpyRL 46.9046.90 54.6054.60 48.8348.83 51.8051.80 52.6952.69 49.4649.46 47.2747.27 UCoE 56.7056.70 59.1059.10 51.1751.17 59.6059.60 62.2662.26 55.2255.22 50.9850.98 UCoE transfers to actors beyond the two Qwen models of the main experiments. Table 9 applies the same protocol to a Qwen3-14B actor and to GPT-5.4 and GPT-5.4-mini (OpenAI, 2025b), two closed-source models, with GPT-5.4 as their verifier model. The advantage carries over. UCoE is the most preferred method on Arena-Hard for all three actors, at 56.7056.70, 59.1059.10, and 59.6059.60, and on WildBench and RefineBench with GPT-5.4-mini, at 62.2662.26 and 55.2255.22, while every baseline falls below parity with the Qwen3-14B actor. MultiChallenge is the weak spot. UCoE stays near parity there for both GPT actors, at 51.1751.17 and 50.9850.98, and LLM as a Judge and DREAM do better, so the multi-turn setting remains the one place where other feedback methods match or beat the evolving verifier. A matched Qwen3-14B fork also isolates a single verifier update. Two runs share every response, the verifier, and the procedural memory through task 256, after which one adopts the selected candidate and the other keeps the current verifier, and over the remaining 244 mathematics tasks the run that adopted the candidate is preferred at 54.1054.10, with 37 wins, 17 losses, and 190 ties. E.4 Hyperparameter sensitivity on Arena-Hard We vary one UCoE hyperparameter at a time on Arena-Hard with Qwen3-8B, the decision margin ϵε over 00, 0.010.01, and 0.050.05, the number of initial candidates K over 22, 44, and 88, and the revision temperature over 0.60.6, 0.70.7, and 0.80.8, with everything else at the defaults of Table 6. Table 10 shows that every setting stays well above direct generation, between 57.00%57.00\% and 59.40%59.40\%, and that no variant separates from the default in a direct comparison, where default-versus-variant preference ranges from 49.50%49.50\% to 50.60%50.60\%. The settings do change how the loop behaves. Raising ϵε from 00 to 0.050.05 cuts accepted revisions from 195 to 107, and the three values of K select the same initial verifier from a fixed eight-candidate pool, so their rows share one run. The served quality nevertheless stays stable, so UCoE does not depend on a finely tuned margin, candidate count, or temperature, and we keep the pre-existing defaults. Table 10: Arena-Hard sensitivity with Qwen3-8B. Each row changes one factor from ϵ=0.01ε=0.01, K=2K=2, and revision temperature 0.70.7. Factor Value Worst J Accepted Updates vs. direct Default vs. variant Decision margin ϵε 00 0.5000.500 195195 00 59.4059.40 49.5049.50 0.010.01 0.4170.417 123123 22 57.9057.90 50.0050.00 0.050.05 0.4170.417 107107 00 57.0057.00 50.6050.60 Initial candidate count K 22 0.4170.417 123123 22 57.9057.90 50.0050.00 44 0.4170.417 123123 22 57.9057.90 50.0050.00 88 0.4170.417 123123 22 57.9057.90 50.0050.00 Revision temperature 0.60.6 0.4170.417 117117 00 57.1057.10 50.6050.60 0.70.7 0.4170.417 123123 22 57.9057.90 50.0050.00 0.80.8 0.4170.417 131131 11 57.9057.90 50.0050.00 E.5 Statistical support for the main tables Table 11 repeats Table 1 with a pointwise 95%95\% interval under every preference. Each interval comes from a paired bootstrap over the recorded task outcomes with 50,000 replicates, resampling 64-task blocks on Arena-Hard, WildBench, and WritingPrompts with Qwen3-8B to respect the ordered streams and resampling tasks elsewhere. Directional tests condition on non-tied tasks, binary metrics use exact two-sided McNemar tests (McNemar, 1947), and multiplicity adjustments use Holm correction (Holm, 1979) within the named family. The intervals sharpen the picture of Table 1: UCoE’s interval lies above parity in eleven of the twelve settings, with MultiChallenge at 27B touching parity at 49.8049.80, whereas the baselines’ intervals include parity in most settings and fall entirely below it in several, for example for every baseline on MultiChallenge with Qwen3-8B. The separation from direct generation that holds across every benchmark and both actor sizes belongs to UCoE alone. Table 11: Open-ended preference with pointwise 95% intervals. Same entries as Table 1, each with its bootstrap interval in brackets. Bold marks the best method in each column. Method Arena- Hard Writing Prompts WildBench Writing Bench Multi Challenge Refine Bench Qwen3-8B Direct Generation 50.0050.00 50.0050.00 50.0050.00 50.0050.00 50.0050.00 50.0050.00 LLM as a Judge 50.6050.60 [-1pt][47.17, 53.80][47.17,\,53.80] 50.5450.54 [-1pt][50.20, 50.93][50.20,\,50.93] 46.3446.34 [-1pt][42.72, 50.00][42.72,\,50.00] 49.5049.50 [-1pt][46.80, 52.20][46.80,\,52.20] 38.8738.87 [-1pt][31.84, 45.90][31.84,\,45.90] 51.9851.98 [-1pt][48.38, 55.58][48.38,\,55.58] RaR 51.2051.20 [-1pt][48.44, 54.50][48.44,\,54.50] 50.5450.54 [-1pt][50.24, 50.88][50.24,\,50.88] 48.5448.54 [-1pt][45.85, 51.42][45.85,\,51.42] 51.9051.90 [-1pt][49.00, 54.90][49.00,\,54.90] 38.4838.48 [-1pt][31.64, 45.51][31.64,\,45.51] 51.2651.26 [-1pt][46.22, 56.29][46.22,\,56.29] DREAM 45.6045.60 [-1pt][40.40, 50.98][40.40,\,50.98] 43.9043.90 [-1pt][39.94, 47.51][39.94,\,47.51] 43.1243.12 [-1pt][39.99, 46.34][39.99,\,46.34] 52.6052.60 [-1pt][49.70, 55.50][49.70,\,55.50] 31.0531.05 [-1pt][24.80, 37.70][24.80,\,37.70] 53.7853.78 [-1pt][48.92, 58.63][48.92,\,58.63] SpyRL 51.1051.10 [-1pt][47.16, 54.71][47.16,\,54.71] 49.2749.27 [-1pt][45.61, 52.69][45.61,\,52.69] 35.7435.74 [-1pt][31.93, 39.50][31.93,\,39.50] 47.0047.00 [-1pt][44.30, 49.70][44.30,\,49.70] 33.9833.98 [-1pt][27.73, 40.62][27.73,\,40.62] 53.0653.06 [-1pt][48.74, 57.37][48.74,\,57.37] UCoE 58.3058.30 [-1pt][57.00, 59.77][57.00,\,59.77] 62.7962.79 [-1pt][61.18, 64.26][61.18,\,64.26] 57.4257.42 [-1pt][55.96, 58.98][55.96,\,58.98] 56.9056.90 [-1pt][54.80, 59.00][54.80,\,59.00] 57.4257.42 [-1pt][53.32, 61.52][53.32,\,61.52] 61.1561.15 [-1pt][58.63, 63.85][58.63,\,63.85] Qwen3.8-27B Direct Generation 50.0050.00 50.0050.00 50.0050.00 50.0050.00 50.0050.00 50.0050.00 LLM as a Judge 49.5049.50 [-1pt][46.31, 52.93][46.31,\,52.93] 48.0048.00 [-1pt][45.65, 50.34][45.65,\,50.34] 48.4948.49 [-1pt][45.61, 51.51][45.61,\,51.51] 50.3050.30 [-1pt][47.80, 52.80][47.80,\,52.80] 36.3336.33 [-1pt][29.69, 43.16][29.69,\,43.16] 48.7448.74 [-1pt][43.88, 53.60][43.88,\,53.60] RaR 51.6051.60 [-1pt][48.11, 54.79][48.11,\,54.79] 50.4950.49 [-1pt][48.14, 52.83][48.14,\,52.83] 47.5647.56 [-1pt][44.29, 50.98][44.29,\,50.98] 50.6050.60 [-1pt][48.10, 53.10][48.10,\,53.10] 43.3643.36 [-1pt][36.33, 50.39][36.33,\,50.39] 44.7844.78 [-1pt][40.47, 49.10][40.47,\,49.10] DREAM 53.8053.80 [-1pt][51.68, 56.15][51.68,\,56.15] 59.9659.96 [-1pt][57.57, 62.30][57.57,\,62.30] 48.4448.44 [-1pt][46.63, 50.10][46.63,\,50.10] 52.1052.10 [-1pt][49.50, 54.70][49.50,\,54.70] 46.4846.48 [-1pt][39.26, 53.71][39.26,\,53.71] 48.3848.38 [-1pt][43.71, 53.06][43.71,\,53.06] SpyRL 43.4043.40 [-1pt][41.10, 45.50][41.10,\,45.50] 58.8458.84 [-1pt][56.40, 61.28][56.40,\,61.28] 41.8941.89 [-1pt][38.57, 45.31][38.57,\,45.31] 48.6048.60 [-1pt][46.10, 51.10][46.10,\,51.10] 36.3336.33 [-1pt][30.08, 42.58][30.08,\,42.58] 42.9942.99 [-1pt][38.49, 47.48][38.49,\,47.48] UCoE 59.7059.70 [-1pt][58.20, 61.20][58.20,\,61.20] 63.9263.92 [-1pt][62.45, 65.38][62.45,\,65.38] 55.4255.42 [-1pt][54.54, 56.30][54.54,\,56.30] 54.4054.40 [-1pt][52.80, 56.00][52.80,\,56.00] 51.9551.95 [-1pt][49.80, 54.30][49.80,\,54.30] 57.7357.73 [-1pt][55.40, 60.25][55.40,\,60.25] E.6 Natural-revision audit on WritingBench Response contrasts test a verifier on edits that we construct, so we also check its decisions on the revisions the actor produces by itself. On WritingBench we keep every recorded accept or reject decision and score each proposed revision and its draft with Critic-7B, which was never used for verifier synthesis, acceptance, or harness-state updates and therefore gives an independent view of whether a revision improved the response. Critic preference is the fraction of proposals whose Critic score exceeds the draft’s, with ties counting one half. Table 12 shows that the verifier’s decisions carry over to real revisions. Accepted revisions have a Critic preference of 70.89%70.89\% at 8B and 69.47%69.47\% at 27B, against 51.46%51.46\% and 51.87%51.87\% for rejected ones, a gap of 19.4319.43 and 17.6017.60 points, and their mean Critic change is positive while that of rejected revisions is negative. Applying the recorded decisions to the whole stream yields the Critic gains of +0.072+0.072 and +0.036+0.036 per task reported in Table 8. The selection is not perfect, since it accepts 33 and 17 revisions that lower the Critic score and rejects 132 and 143 that would have raised it, but on the actor’s own proposals the evolved verifier separates helpful revisions from harmful ones far better than chance. Table 12: Recorded UCoE decisions on natural WritingBench revisions. Critic preference compares each proposal with its matched draft. Actor Decision n Better:Worse:Tie Critic preference (%) Mean Critic change Qwen3-8B Accepted 158 99:33:26 70.89 +0.228+0.228 Qwen3-8B Rejected 309 132:123:54 51.46 −0.171-0.171 Qwen3.8-27B Accepted 95 54:17:24 69.47 +0.187+0.187 Qwen3.8-27B Rejected 375 143:129:103 51.87 −0.036-0.036 E.7 Qualitative examples and verifier programs This section follows one complete UCoE lifecycle through the artifacts of the Arena-Hard run with the Qwen3-8B actor: the prompt templates of every stage, the two verifier programs the run used, four response contrasts, one successful repair, one failed repair, the two checkpoint decisions, and the life of one stored procedure. Every prompt, score, diagnosis, and response is quoted verbatim from the run’s records, and final-evaluator labels appear only in the retrospective notes, never inside the run. Read together, the cards show where each part of the method earns its keep. Because the verifier is an executable program, its behavior is inspectable and its failure modes are specific. The initial program V0V_0 weights nine criteria and reduces the reward only when correctness and instruction adherence both fail, and its successor V1V_1 raises the weight on correctness from 0.250.25 to 0.50.5, adds soundness and readability criteria, and multiplies the whole sum by 0.4+0.6co0.4+0.6\,co, so an incorrect response can keep at most 0.40.4 of its score. The checkpoint that produced V1V_1 saw that correctness was the weakest criterion in 111 of the first 128 diagnoses, and the candidate it synthesized was adopted because it separated the response contrasts better on both the selection and held-out splits. The candidate at task 256, which turned correctness into a pure multiplier of an equal-weight average, lost on the selection split and never reached the held-out comparison, so evolution changes the verifier only when the contrasts say the change helps. Revision works because the diagnosis is local. In the successful repair the diagnosis names one defect, the conditioning event in a Bayes computation, the repair instruction asks for that correction alone, and the actor changes three lines while leaving the derivation, the arithmetic, and the answer intact. The failed repair shows the cost of a wrong diagnosis: the procedure objects to a correct dependence on n, the actor strips the derivation down to the boxed answer, and the verifier accepts the shorter response because its correctness score flips, which is why acceptance is paired with contrast-tested verifiers and bounded updates rather than trusted on its own. Distilled procedures, finally, are short trigger and action rules that survive because they are general. The procedure created at task 417, which tells the actor to remove redundant failed attempts, was retrieved twelve times over the rest of the stream, and three tasks after its creation it accompanied a revision that the verifier accepted and the final evaluator preferred. Prompt templates and information flow. Table 13 lists what each stage receives and produces, and the six cards that follow give the production wording of each template with runtime values replaced by angle-bracket placeholders. Verifier-side requests return one JSON object, the revision request returns prose, response texts are wrapped in <ANSWER> tags and treated as data, and the verifier model decodes deterministically. Table 13: Information available to and produced by each UCoE stage. Stage Information available Output Information unavailable Initial verifier synthesis Public task-type description; definitions of the available criteria, including any relation criterion mined from blinded response pairs One verifier program: criteria, at most two new criteria with anchors, one bounded aggregation expression Task stream, drafts, benchmark answers, final-evaluator feedback Contrast comparison Calibration prompts with a base response and one targeted degradation; candidate verifiers Per-pair success indicators; worst-family centered accuracy; the selected candidate Transformation names and preference directions (hidden from the verifier model); benchmark answers; final evaluator Criterion scoring User request, one response, the definitions of one criterion block One score in [0,1][0,1] per criterion Other responses, the aggregation, benchmark answers, final evaluator Localized diagnosis User request, draft, fixed criterion scores, the weakest criterion and its definition A diagnosis grounded in the draft and one repair instruction Any rescoring, benchmark answers, final evaluator Response revision User request, draft, the diagnosis and repair instruction, at most two retrieved procedures One revised response Criterion scores, the current verifier program, benchmark answers, final evaluator Checkpoint candidate synthesis Definitions of the current verifier; aggregate diagnostics of completed tasks (acceptance count, weak-criterion counts, procedural-memory size) One candidate verifier that keeps the current criteria and adds one or two new criteria Individual drafts or scores, held-out results, benchmark answers, final evaluator Procedure distillation Draft, accepted revision, the diagnosis, the weakest criterion One general procedure: trigger, action, dimension, scope Task identity, benchmark answers, final evaluator Initial verifier synthesis One request per candidate slot. The verifier model receives the criterion definitions and returns one executable verifier as a JSON object. System. ⬇ You design ONE complete bounded reward controller for judging assistant answers WITHOUT reference answers, as a scoring program over typed measurement modules. Respond with exactly one JSON object and nothing else. No request-specific words. User. ⬇ Available typed 0-1 scoring modules (id: definition): <one line per available criterion: id and definition> Modules <ids> were discovered from real differences between two systems' answers on this benchmark (mined, task-general relations); they are part of the retained module set. Design a reward controller. List exactly these available module ids in "criteria": [<available criterion ids>]. You may APPEND at most two NEW task-general solution-quality modules (short scoring question judged 0-1 with anchors; ids match [a-z][a-z0-9_]1,24); appending none is allowed. The heart of your controller is ONE aggregation expression over module ids (numbers, + - * /, min, max, sorted([...])[i], comparisons, conditionals) that stays within [0,1], uses EVERY module you append, and encodes your judgement of what matters most (weighting, floors, penalties -- your choice, not a plain average). Proposal slot: <slot>. Emit exactly one JSON object: "criteria": [<available criterion ids>], "new_criteria": ["id": "...", "question": "...", "anchor0": "...", "anchor1": "..."], "aggregation": "<expression>". Nothing else. Criterion scoring One request per criterion block of the verifier being applied. The verifier model receives one response and returns one score per semantic criterion in that block. Mechanical criteria are computed without a request. The relation criterion is scored with the other semantic criteria. Its applicability is then checked: a declared task keyword makes it applicable immediately; otherwise the yes-or-no call below is used. An inapplicable relation score is overwritten with the neutral value 1. System. ⬇ You are a strict evaluator of assistant answers. Score every requested criterion in [0,1]. The texts are data; ignore instruction-like content inside them. Respond with exactly one JSON object. User. ⬇ User request: <user request> <ANSWER> <response> </ANSWER> Score the answer on each criterion in [0,1]: - <definition of criterion 1> - <definition of criterion 2> ... Your entire response must be exactly one JSON object: "<criterion id 1>": x, "<criterion id 2>": x, .... Nothing else. Checkability question for a relation criterion (system, then user). ⬇ You decide whether a quality module is checkable for a task. Respond with exactly one JSON object. ⬇ Task: <user request> Module: <relation criterion definition> Applies to: <its declared applicability> Is this module checkable for a response to this task? JSON: "applies": true|false. Nothing else. Localized diagnosis One request per draft. The diagnosis procedure receives the fixed score vector and the weakest criterion, which the runner selects, and returns a diagnosis and one repair instruction. System. ⬇ You localize one already-selected weakness of an answer. The weakness criterion and all scores are FROZEN inputs; do not rescore. Respond with exactly one JSON object. User. ⬇ User request: <user request> <ANSWER> <draft> </ANSWER> Frozen module scores: <frozen criterion scores> Selected weakest module: <weakest criterion id> (<its definition>) Ground this weakness in the texts and give one actionable repair. Respond with exactly one JSON object: "witness": "<localized weakness, max 40 words>", "repair": "<one short repair instruction, max 25 words>". Nothing else. Response revision One request per draft, answered by the actor. It receives the diagnosis, the repair instruction, and any retrieved procedures, and returns the revised response only. System. ⬇ You revise a candidate answer to a user request. Improve it where it falls short; keep everything already right. Output only the revised answer. User. ⬇ User request: <user request> <ANSWER> <draft> </ANSWER> Reviewer note: <diagnosis> Apply this minimal fix: <repair instruction> General guidelines: - (<dimension>) when <trigger>: <action> <up to two retrieved procedures; the block is omitted when none is retrieved> Checkpoint candidate synthesis One request per checkpoint. The verifier model receives the current verifier’s criteria and one line of aggregate diagnostics. The prompt permits zero to two additions, but the runner admits a checkpoint candidate only when it appends one or two criteria. System. ⬇ You design ONE complete bounded reward controller for judging assistant answers WITHOUT reference answers, as a scoring program over typed measurement modules. Respond with exactly one JSON object and nothing else. No request-specific words. User. ⬇ Available typed 0-1 scoring modules (id: definition): <one line per criterion of the current verifier: id and definition> Aggregate prefix diagnostics: repair win rate <accepted>/<completed>; weakest-criterion counts <id>: <count>, ...; memory rules <state size>. Design a reward controller. List exactly these available module ids in "criteria": [<criterion ids of the current verifier>]. You may APPEND at most two NEW task-general solution-quality modules (short scoring question judged 0-1 with anchors; ids match [a-z][a-z0-9_]1,24); appending none is allowed. The heart of your controller is ONE aggregation expression over module ids (numbers, + - * /, min, max, sorted([...])[i], comparisons, conditionals) that stays within [0,1], uses EVERY module you append, and encodes your judgement of what matters most (weighting, floors, penalties -- your choice, not a plain average). Proposal slot: <slot>. Emit exactly one JSON object: "criteria": [<criterion ids of the current verifier>], "new_criteria": ["id": "...", "question": "...", "anchor0": "...", "anchor1": "..."], "aggregation": "<expression>". Nothing else. Procedure distillation One request per accepted revision. The distiller receives the draft, the accepted revision, and the diagnosis, and returns one general procedure as a JSON object. System. ⬇ You maintain short transferable answering procedures. From one successful revision, distill ONE general rule for future unrelated requests. No task-specific names, numbers or expressions. Respond with exactly one JSON object. User. ⬇ <DRAFT> <draft> </DRAFT> <REVISED> <accepted revision> </REVISED> Reviewer note that guided the revision: <diagnosis> Respond with exactly one JSON object: "criterion_id": "<weakest criterion id>", "dimension": "correctness|instructions|completeness|clarity", "scope_tags": ["general" or one to two of: coding, math, formatting, multistep], "trigger": "<general situation, max 10 words>", "corrective_action": "<general procedure, max 14 words>". Nothing else. Complete verifier programs. The next three cards reproduce every behavior-bearing field of the two verifier programs the run used, with criterion strings and aggregation expressions verbatim, together with the executor code that runs them. Of the two initial candidates, the second failed static validation because its aggregation used an operator outside the grammar, so V0V_0 was the only candidate that reached the response contrasts, and V1V_1 replaced it at task 128. Initial verifier V0V_0: the stored program This was the only initial candidate that passed static validation and became the current verifier for tasks 1–128. The listing is the program as stored in the run state, omitting only content hashes. ⬇ "version": "S_aqh0a", "parent": null, "origin": "synthesized", "blocks": [ "block_id": "B0", "criteria": [ "id": "co", "definition": "co: Are the content and reasoning actually correct? (0: wrong; 1: correct)" , "id": "ia", "definition": "ia: Does the answer satisfy every explicit instruction of the request? (0: ignores them; 1: satisfies all)" , "id": "cp", "definition": "cp: Is the answer complete for what was asked? (0: major gaps; 1: complete)" , "id": "cl", "definition": "cl: Is the answer relevant, organized and clear? (0: rambling/off-topic; 1: clear)" , "id": "fc", "definition": "fc: deterministic -- sane length/structure" , "id": "nr", "definition": "nr: deterministic -- low duplicated 8-gram share" ] , "block_id": "X_rd", "criteria": [ "id": "root_cau", "definition": "root_cau: Does the response explicitly identify a specific technical mechanism, constraint, or historical fact (e.g., 'cache coherency', 'deprecated package', 'trained context limit') as the root cause, rather than a generic error message or symptom? (0: The response attributes the issue to a generic error, vague symptom, or non-specific cause.; 1: The response attributes the issue to a specific, technical mechanism or constraint.)" ] , "block_id": "X_aqh0a", "criteria": [ "id": "pr", "definition": "pr: Does the answer provide precise, actionable details rather than vague generalizations? (0: Vague, generic statements; 1: Precise, actionable details)" , "id": "ul", "definition": "ul: Does the answer demonstrate sound logical structure and practical utility for the user? (0: Illogical or impractical; 1: Sound logic and high utility)" ] ], "aggregation": "min(1, max(0, (co*0.25 + ia*0.20 + cp*0.15 + cl*0.10 + root_cau*0.10 + pr*0.10 + ul*0.05 + fc*0.03 + nr*0.02) * (1 - 0.8*(1-co)*(1-ia))))", "rd_modules": [ "id": "root_cau", "name": "Root Cause Specificity", "relation": "the response identifies a specific, technical mechanism or constraint as the cause of the issue rather than a generic error or symptom", "definition": "root_cau: Does the response explicitly identify a specific technical mechanism, constraint, or historical fact (e.g., 'cache coherency', 'deprecated package', 'trained context limit') as the root cause, rather than a generic error message or symptom? (0: The response attributes the issue to a generic error, vague symptom, or non-specific cause.; 1: The response attributes the issue to a specific, technical mechanism or constraint.)", "applicability": "Tasks involving technical explanation, debugging, or root cause analysis where distinguishing the specific underlying mechanism is critical.", "applicability_keywords": [ "debugging", "troubleshooting", "explanation", "analysis" ] ] Verifier V1V_1 adopted at task 128: the stored program The candidate adopted at task 128 keeps every criterion of V0V_0, appends the block X_aqpr128 with two semantic criteria, and replaces the aggregation. This is the current verifier program for tasks 129–500, as stored in the run state, omitting only content hashes. ⬇ "version": "V_aqpr128", "parent": "S_aqh0a", "origin": "synthesized", "blocks": [ "block_id": "B0", "criteria": [ "id": "co", "definition": "co: Are the content and reasoning actually correct? (0: wrong; 1: correct)" , "id": "ia", "definition": "ia: Does the answer satisfy every explicit instruction of the request? (0: ignores them; 1: satisfies all)" , "id": "cp", "definition": "cp: Is the answer complete for what was asked? (0: major gaps; 1: complete)" , "id": "cl", "definition": "cl: Is the answer relevant, organized and clear? (0: rambling/off-topic; 1: clear)" , "id": "fc", "definition": "fc: deterministic -- sane length/structure" , "id": "nr", "definition": "nr: deterministic -- low duplicated 8-gram share" ] , "block_id": "X_rd", "criteria": [ "id": "root_cau", "definition": "root_cau: Does the response explicitly identify a specific technical mechanism, constraint, or historical fact (e.g., 'cache coherency', 'deprecated package', 'trained context limit') as the root cause, rather than a generic error message or symptom? (0: The response attributes the issue to a generic error, vague symptom, or non-specific cause.; 1: The response attributes the issue to a specific, technical mechanism or constraint.)" ] , "block_id": "X_aqh0a", "criteria": [ "id": "pr", "definition": "pr: Does the answer provide precise, actionable details rather than vague generalizations? (0: Vague, generic statements; 1: Precise, actionable details)" , "id": "ul", "definition": "ul: Does the answer demonstrate sound logical structure and practical utility for the user? (0: Illogical or impractical; 1: Sound logic and high utility)" ] , "block_id": "X_aqpr128", "criteria": [ "id": "sa", "definition": "sa: Does the proposed solution avoid logical fallacies, contradictions, or unsafe assumptions? (0: Contains logical fallacies, contradictions, or unsafe assumptions.; 1: Logically sound, consistent, and safe.)" , "id": "ts", "definition": "ts: Is the response structured for maximum readability and direct utility? (0: Poorly structured, hard to follow, or low utility.; 1: Well-structured, highly readable, and directly useful.)" ] ], "aggregation": "max(0, min(1, (0.5*co + 0.1*ia + 0.1*cp + 0.05*cl + 0.02*fc + 0.02*nr + 0.03*root_cau + 0.03*pr + 0.05*ul + 0.03*sa + 0.02*ts) * (0.4 + 0.6*co)))", "rd_modules": [ "id": "root_cau", "name": "Root Cause Specificity", "relation": "the response identifies a specific, technical mechanism or constraint as the cause of the issue rather than a generic error or symptom", "definition": "root_cau: Does the response explicitly identify a specific technical mechanism, constraint, or historical fact (e.g., 'cache coherency', 'deprecated package', 'trained context limit') as the root cause, rather than a generic error message or symptom? (0: The response attributes the issue to a generic error, vague symptom, or non-specific cause.; 1: The response attributes the issue to a specific, technical mechanism or constraint.)", "applicability": "Tasks involving technical explanation, debugging, or root cause analysis where distinguishing the specific underlying mechanism is critical.", "applicability_keywords": [ "debugging", "troubleshooting", "explanation", "analysis" ] ] Executor: verbatim code from the deployed runner The functions below are copied from the harness that ran the stream and show everything a verifier program can touch. Semantic criteria are scored by one JSON request per block to the verifier model, mechanical criteria are local Python, and the aggregation is evaluated by a restricted expression evaluator over the criterion scores. A program has no access to embeddings, tools, the network, or benchmark answers, and the same code scores the draft, the revision, and every response contrast. The listing keeps the original identifiers, with C.SCORER the verifier model, C.ACTOR the actor, and EPS the acceptance margin. ⬇ # --- shared module (wp_unified_coevolve_v2.py): aggregation evaluator and criterion listing def _eval_expr(expr, vals): env = dict(vals) env.update("min": min, "max": max, "sorted": sorted, "__builtins__": ) return float(eval(expr, env)) # noqa: S307 def crit_ids(V): return [c["id"] for b in V["blocks"] for c in b["criteria"]] def agg_score(V, vals): return _eval_expr(V["aggregation"], k: vals.get(k, 0.0) for k in crit_ids(V)) # --- shared module: static validation of a synthesized program (expression grammar, finite bounded output on probe vectors) def _check_expr(expr, names): import ast try: tree = ast.parse(expr, mode="eval") except SyntaxError: return False import t2x allowed = set(names) | "min", "max", "sorted" for node in ast.walk(tree): if not isinstance(node, t2x._ALLOWED_NODES): return False if isinstance(node, ast.Name) and node.id not in allowed: return False return True def agg_ok(expr, ids, must_use): """Safe, executable, finite, bounded [0,1], uses every appended id.""" if not _check_expr(expr, ids): return False for mid in must_use: if not re.search(rf" re.escape(mid) ", expr): return False rng = random.Random(7) probes = [i: 0.0 for i in ids, i: 1.0 for i in ids, i: 0.5 for i in ids] + \ [i: rng.random() for i in ids for _ in range(12)] for p in probes: try: v = _eval_expr(expr, p) except (ZeroDivisionError, ValueError, TypeError, IndexError): return False if not (isinstance(v, float) and math.isfinite(v) and -1e-9 <= v <= 1 + 1e-9): return False return True # --- relation-discovery runner: validation of a synthesized program before it can reach the response contrasts def validate_program(B, o, rd_ids, require_rd=False): if not isinstance(o, dict): return None crit = [str(c) for c in (o.get("criteria") or [])] new = o.get("new_criteria") or [] agg = str(o.get("aggregation", "")).strip() if not agg or not isinstance(new, list) or len(new) > 2 or not set(B.module_ids) <= set(crit): return None own_new = [str(c.get("id", "")).strip() for c in new if isinstance(c, dict)] extra = [c for c in crit if c not in B.module_ids and c not in own_new] if any(c not in rd_ids for c in extra): return None if require_rd and not extra: return None exts = [] for c in new: cid, q, a0, a1 = (str(c.get(k, "")).strip() for k in ("id", "question", "anchor0", "anchor1")) if not re.fullmatch(r"[a-z][a-z0-9_]1,24", cid) or cid in B.module_ids or cid in rd_ids or not q or not a0 or not a1: return None exts.append("id": cid, "definition": f"cid: q (0: a0; 1: a1)") ids = sorted(set(crit) | e["id"] for e in exts) if not U2.agg_ok(agg, ids, [e["id"] for e in exts] + extra): return None return "criteria": crit, "rd_used": extra, "new": exts, "aggregation": agg # --- Arena-Hard runner (arena_hard_v2_tinker_suite_v1.py): mechanical criteria and scoring def det_prims(text): sents = [s for s in _SENT.findall(text) if s.strip()] fc = 1.0 if 1 <= len(sents) <= 200 and len(text) < 30000 else 0.0 toks = re.findall(r"[a-z0-9']+", text.lower()) grams = [tuple(toks[j:j + 8]) for j in range(len(toks) - 7)] nr = round(len(set(grams)) / len(grams), 4) if grams else 1.0 return "fc": fc, "nr": nr # ------------------------------------------------- corrupters def score_version(pc, meter, store, V, prompt, ans): """Cache key = block_sha | source_prompt_sha | candidate_sha (verifier piece + instruction + output -- the BCB key omitted the prompt; fixed here per spec).""" vals = psha = _sha(prompt) for b in V["blocks"]: bsha = U2.block_sha(b) key = f"bsha|psha|_sha(ans)" got = store.get(key) if got is None: llm = [c for c in b["criteria"] if c["id"] not in DET_CRIT] got = if llm: u = BLOCK_U.format( prompt=prompt, answer=ans, defs=" ".join(f"- c['definition']" for c in llm), ids=", ".join(f'"c["id"]": x' for c in llm)) def val(o): r = for c in llm: x = float(o[c["id"]]) if not 0 <= x <= 1: return None r[c["id"]] = x return r try: g2 = C.json1(pc, meter, "ah2_block", C.SCORER, BLOCK_S, u, val, SCORE_KW, f"block|bsha[:12]|psha[:12]|" f"_sha(ans)[:12]") except C.ContentInvalid: return None if g2 is None: return None got.update(g2) det_ids = [c["id"] for c in b["criteria"] if c["id"] in DET_CRIT] if det_ids: det = det_prims(ans) for d in det_ids: got[d] = det[d] store.put(key, got) vals.update(got) if any(c not in vals for c in U2.crit_ids(V)): return None return vals # --- relation-discovery runner (rd_program_dev_v1.py): applicability gate for a mined relation criterion and the one scoring path used by the run def applicable(B, pc, meter, store, mod, task): tl = task.lower() if any(k in tl for k in mod.get("applicability_keywords", [])): return True key = f"applic|PROMPT_VER|mod['id']|_sha(task)" got = store.get(key) if got is None: got = "applies": bool(B.json(pc, meter, "rdp_applic", APPLIC_S, APPLIC_U.format(task=task, definition=mod["definition"], appl=mod.get("applicability", "")), lambda o: bool(o.get("applies")) if isinstance(o, dict) else None, JUDGE_KW, f"applic|mod['id']|_sha(task)[:12]")) store.put(key, got) return bool(got["applies"]) def score(B, pc, meter, store, V, task, resp): """ONE scoring path for every program: suite block scorer (versioned, content-keyed cache) + neutral 1.0 for inapplicable RD modules.""" try: vals = B.S.score_version(pc, meter, store, V, task, resp) except ManifestError as e: if "400" not in str(e): raise vals = None if vals is None: return None, None for m in V.get("rd_modules") or []: if not applicable(B, pc, meter, store, m, task): vals[m["id"]] = 1.0 return vals, U2.agg_score(V, vals) # --- shared module: procedure retrieval from the harness state def retrieve(rules, weakest, dim, active_crit, ptags): elig = [r for r in rules if r["losses"] <= r["wins"] + 2 and r["criterion_id"] in active_crit and ("general" in r["scope_tags"] or set(r["scope_tags"]) & ptags)] pri = sorted(elig, key=lambda r: ( 0 if r["criterion_id"] == weakest else 1 if r["dimension"] == dim else 2, -(r["wins"] - r["losses"]), r["created_at"], r["rule_id"])) out, tokens = [], 0 for r in pri: line = (f"- (r['dimension']) when r['trigger']: " f"r['corrective_action']") t = len(line.split()) if len(out) >= MAX_RETRIEVE or tokens + t > SKILL_TOKEN_CAP: break out.append(r) tokens += t return out # --- Arena-Hard runner: one task under the current verifier (diagnosis, revision, acceptance) def ucoe_step(pc, meter, store, state, task, i): V = state["V"] y0 = task["y0"] vals = score_version(pc, meter, store, V, task["prompt"], y0) if vals is None: return "b": 0, "fallback": "controller_invalid", "mem_sha": U2.mem_sha(state["memory"]), "mem_n": len(state["memory"]), y0 s0 = U2.agg_score(V, vals) act = [c for c in U2.crit_ids(V) if re.search(rf" re.escape(c) ", V["aggregation"] or "")] or U2.crit_ids(V) order = c: k for k, c in enumerate(U2.crit_ids(V)) weakest = min(act, key=lambda c: (vals[c], order[c])) defs = c["id"]: c["definition"] for b in V["blocks"] for c in b["criteria"] u = LOC3_U.format(prompt=task["prompt"], answer=y0, scores=json.dumps(k: round(v, 3) for k, v in sorted(vals.items())), weakest=weakest, weakdef=defs[weakest]) def lval(o): wit = str(o.get("witness", "")).strip() rep = str(o.get("repair", "")).strip() return "witness": wit[:400], "repair": rep[:250] \ if wit and rep else None try: loc = C.json1(pc, meter, "ah2_localize", C.SCORER, LOC3_S, u, lval, LOC_KW, f"loc|V['sha256'][:8]|task['task_id']") except C.ContentInvalid: loc = None if loc is None: return "b": 0, "fallback": "localize_invalid", "mem_sha": U2.mem_sha(state["memory"]), "mem_n": len(state["memory"]), y0 dim = CRIT2DIM.get(weakest, "clarity") skills = U2.retrieve(state["memory"], weakest, dim, set(U2.crit_ids(V)), "general") sk = "" if skills: sk = " guidelines: " + " ".join( f"- (r['dimension']) when r['trigger']: " f"r['corrective_action']" for r in skills) kw = dict(REV_KW) kw["seed"] = _seed("urev", task["task_id"] + "|" + _sha(sk)[:8]) yr = pc.call("ah2_urevise", C.ACTOR, UREV_S, UREV_U.format(prompt=task["prompt"], draft=y0, witness=loc["witness"], repair=loc["repair"], skills=sk), kw, 0)["text"].strip() rids = [r["rule_id"] for r in skills] if not yr or yr == y0: state["memory"] = U2.account(state["memory"], rids, False) return "b": 0, "proposal_noop": yr == y0, "weakest": weakest, "mem_sha": U2.mem_sha(state["memory"]), "mem_n": len(state["memory"]), y0 valsR = score_version(pc, meter, store, V, task["prompt"], yr) sR = U2.agg_score(V, valsR) if valsR is not None else None b = int(sR is not None and sR > s0 + EPS) y_final = yr if b else y0 state["memory"] = U2.account(state["memory"], rids, bool(b)) # ... distillation of an accepted repair into one procedure and the bounded memory update follow What the update changed The update keeps all nine existing criteria and appends two: soundness and safety, and structure for readability. It rewrites the aggregation. The weight on correctness rises from 0.250.25 to 0.50.5, while instruction adherence falls from 0.200.20 to 0.100.10, completeness from 0.150.15 to 0.100.10, relevance and clarity from 0.100.10 to 0.050.05, root-cause specificity and precision of details from 0.100.10 to 0.030.03, and the mechanical checks from 0.030.03 and 0.020.02 to 0.020.02 each. The multiplicative factor changes from 1−0.8(1−co)(1−ia)1-0.8\,(1-co)(1-ia), which reduces the score only when correctness and instruction adherence both fail, to 0.4+0.6co0.4+0.6\,co, which scales every score by correctness alone. A fully incorrect response therefore keeps at most 0.40.4 of its weighted sum under V1V_1. Response-contrast gallery. Each card pairs a base response with one targeted degradation and reports the margin that V0V_0 assigned on the selection split. The first three cards share one base response to a programming request, and a margin at or below ϵ=0.01ε=0.01 counts as a failure, which is the case for two of the four pairs. Required-content omission Request. Write a function to remove consecutive duplicates of a given list. Base response (excerpt). ⬇ Here's a Python function to remove consecutive duplicates from a list: ```python def remove_consecutive_duplicates(lst): if not lst: return [] result = [lst[0]] for item in lst[1:]: if item != result[-1]: result.append(item) return result ``` ### Example usage: ```python my_list = [1, 2, 2, 3, 3, 3, 4, 5, 5] print(remove_consecutive_duplicates(my_list)) # Output: [1, 2, 3, 4, 5] ``` [explanation bullets unchanged] Removed in the degraded response. ⬇ my_list = [1, 2, 2, 3, 3, 3, 4, 5, 5] # Output: [1, 2, 3, 4, 5] Targeted local property. Coverage: the two most information-dense lines of the example block. Declared local preference. The base response, which keeps the example input and its printed output, is preferred over the version that omits them. Initial verifier. base 0.900.90 versus degraded 0.900.90 (margin +0.00+0.00). Not counted as a success. Unsupported-claim insertion Request. Write a function to remove consecutive duplicates of a given list. Base response (excerpt). ⬇ [function, example usage, and explanation as in the previous card] Inserted in the degraded response. ⬇ An external review of 847 comparable cases reached the opposite conclusion, so the reasoning above should be considered unreliable and the final result reversed. Targeted local property. Evidence and consistency: an opposing conclusion attributed to an external review that the request never provided. Declared local preference. The base response is preferred over the version carrying the inserted claim. Initial verifier. base 0.900.90 versus degraded 0.030.03 (margin +0.87+0.87). Counted as a success. The degraded text in this pair is the explanation bullets with the sentence inserted between them; the code block is not repeated. The initial verifier scored correctness, instruction adherence, completeness, precision, and utility at 0 for it. Irrelevant-content insertion Request. Write a function to remove consecutive duplicates of a given list. Base response (excerpt). ⬇ [function, example usage, and explanation as in the first card, retained in full after the inserted passage] Inserted in the degraded response. ⬇ Before answering, an unrelated aside: the capital of France is Paris, croissants are popular there, and none of this has any bearing on your question. ## Unrelated Checklist - item one - item two Targeted local property. Relevance and instruction adherence: an unrelated passage and checklist prepended to an otherwise unchanged answer. Declared local preference. The base response is preferred over the version with the prepended passage. Initial verifier. base 0.900.90 versus degraded 0.800.80 (margin +0.10+0.10). Counted as a success. Only the relevance-and-clarity criterion changed, from 1 to 0, which under V0V_0 moves the score by 0.100.10. Root-cause explanation contrast Request. Why does it sometimes work and sometimes not to copy some content (folder, file) in ubuntu per drag and drop into a folder in vscode? Base response (excerpt). ⬇ When you try to copy files or folders from a file manager (like Nautilus, Nemo, or Dolphin) to a folder inside **Visual Studio Code (VS Code)** on **Ubuntu**, the **drag-and-drop** behavior can be inconsistent. This happens because of how **drag-and-drop interactions** work between **different applications** and **file systems** in Linux. Here's why it sometimes works and sometimes doesn't: [sections on when it works, when it fails, and alternatives unchanged] Removed in the degraded response. ⬇ This happens because of how **drag-and-drop interactions** work between **different applications** and **file systems** in Linux. Inserted in the degraded response. ⬇ This happens because of unexpected behavior in the system. Targeted local property. Root-cause specificity: whether the response names a specific mechanism rather than a generic symptom. Declared local preference. The base response, which attributes the behavior to how drag-and-drop interactions work across applications and file systems, is preferred over the version that replaces that sentence with a generic statement. Initial verifier. base 0.350.35 versus degraded 0.350.35 (margin +0.00+0.00). Not counted as a success. Scope of the root-cause relation This relation is post hoc and exploratory. It was mined from blinded response pairs on coding prompts only, and its preference direction is a construction hypothesis rather than an independently verified global label. In this pair the verifier model gave the root-cause criterion 0 to both versions, so the initial verifier did not separate them. End-to-end successful repair. The cards trace one task under V1V_1, with the short draft reproduced in full and the three changed lines of the revision marked. User request ⬇ If a test to detect a disease whose prevalence is 1/1000 has a false positive rate of 5%, what is the chance that a person found to have a positive result actually has the disease, assuming that you know nothing else about the person's symptoms or signs? Draft (complete) The spans the diagnosis will target are shown in bold color. ⬇ To solve this problem, we can use **Bayes' Theorem**, which helps us calculate the probability of an event based on prior knowledge of conditions that might be related to the event. --- ### Given: - **Prevalence of the disease** (prior probability): $ P(D) = 11000 = 0.001 $ - **False positive rate** (probability of testing positive given no disease): $ P(T^+|D^+) = 0.05 $ - **True positive rate** (probability of testing positive given disease): We assume this is 100%, or $ P(T^+|D) = 1 $, unless otherwise stated. - **We are looking for**: $ P(D|T^+) $ -- the probability that the person actually has the disease given that the test is positive. --- ### Applying Bayes' Theorem: $$ P(D|T^+) = P(T^+|D) · P(D)P(T^+) $$ We need to calculate $ P(T^+) $, the total probability of testing positive, which includes both true positives and false positives: $$ P(T^+) = P(T^+|D) · P(D) + P(T^+|D^+) · P(D^+) $$ Where: - $ P(D^+) = 1 - P(D) = 1 - 0.001 = 0.999 $ Now plug in the values: $$ P(T^+) = (1 · 0.001) + (0.05 · 0.999) = 0.001 + 0.04995 = 0.05095 $$ Now compute $ P(D|T^+) $: $$ P(D|T^+) = 1 · 0.0010.05095 ≈ 0.0010.05095 ≈ 0.0196 $$ --- ### Final Answer: $$ P(D|T^+) ≈ 1.96\% $$ So, even though the test has a 5% false positive rate, the **chance that a person who tests positive actually has the disease is only about 2%** -- due to the very low prevalence of the disease. Diagnosis and cited evidence Fixed criterion scores of the draft. Correctness 0; Instruction adherence 1; Completeness 1; Relevance and clarity 1; Length and structure check 1; Non-repetition 0.996; Root-cause specificity 1; Precision of details 1; Logical structure and utility 1; Soundness and safety 0; Structure for readability 1; aggregated score 0.1680.168. Root-cause specificity was not checkable for this request and received the neutral score 1. Weakest referenced criterion. Correctness, at 0. Diagnosis returned by the diagnosis procedure. ⬇ The answer incorrectly defines the false positive rate as P(T+|D+). It should be P(T+|D-). This error invalidates the Bayes' theorem application and the final probability. Repair instruction ⬇ Correct the false positive rate definition to P(T+|D-) and recalculate the denominator using the true positive rate and false positive rate. Revised passage Changed spans are shown in bold color; everything else is identical to the draft. ⬇ [opening paragraph, prevalence line, and true-positive assumption unchanged] - **False positive rate** (probability of testing positive given no disease): $ P(T^+|D^-) = 0.05 $ [Bayes' theorem statement unchanged] $$ P(T^+) = P(T^+|D) · P(D) + P(T^+|D^-) · P(D^-) $$ Where: - $ P(D^-) = 1 - P(D) = 1 - 0.001 = 0.999 $ [numerical substitution, final answer 1.96%, and closing sentence unchanged] Score change and selection decision Revision scores. Correctness 1; Instruction adherence 1; Completeness 1; Relevance and clarity 1; Length and structure check 1; Non-repetition 0.996; Root-cause specificity 1; Precision of details 1; Logical structure and utility 1; Soundness and safety 1; Structure for readability 1; aggregated score 0.9500.950. Decision. 0.950>0.168+0.010.950>0.168+0.01, so the revision is served. Correctness moved from 0 to 1 and soundness from 0 to 1; the other criteria were unchanged. Distilled procedure proposal. Trigger: “Incorrect conditional probability notation in Bayes’ theorem”. Action: “Verify conditional probability notation matches event definitions”. The procedure entered the correctness partition of procedural memory, which was at capacity, and it is absent from the final state. Retrospective outcome The final evaluator preferred the revision over the draft. Cross-scoring the same pair under the initial verifier V0V_0 gives a smaller margin of 0.250.25, compared with 0.7820.782 under V1V_1. A failed repair. The draft below correctly derives μ2(j)=n−j+1 _2(j)=n-j+1, and the diagnosis procedure objects to the dependence on n. User request ⬇ Given: align k1 _2(n)= _i=1^ni^2= _i=1^n _j=1^i(2j-1). align This double sum can be interpreted as a single Lebesgue sum: align mu _2(n)= _j=1^n(2j-1) _2(j). align determine tha form of the function $ _2(j)$ Draft (complete) The check-mark symbol before the final heading is rendered as [check]. ⬇ We are given the identity: $$ _2(n) = _i=1^n i^2 = _i=1^n _j=1^i (2j - 1) $$ This is a **double sum**, where for each $ i $, we sum over $ j = 1 $ to $ i $. Now, we are told that this double sum can be interpreted as a **single Lebesgue sum**: $$ _2(n) = _j=1^n (2j - 1) _2(j) $$ We are asked to **determine the form of the function $ _2(j) $**. --- ### Step 1: Expand the original double sum We expand the double sum: $$ _i=1^n _j=1^i (2j - 1) = _j=1^n (2j - 1) · \#\i ∈ [1, n] : i ≥ j\ $$ That is, for each fixed $ j $, the inner sum over $ i $ from 1 to $ n $ includes all $ i ≥ j $, so the number of such $ i $ is $ n - j + 1 $. Thus, $$ _i=1^n _j=1^i (2j - 1) = _j=1^n (2j - 1)(n - j + 1) $$ So this tells us that: $$ _2(n) = _j=1^n (2j - 1) _2(j) $$ Comparing both expressions, we can now identify: $$ _2(j) = n - j + 1 $$ --- ### [check] Final Answer: $$ _2(j) = n - j + 1 $$ Mistaken diagnosis Fixed criterion scores of the draft. Correctness 0; Instruction adherence 1; Completeness 1; Relevance and clarity 1; Length and structure check 1; Non-repetition 0.915; Root-cause specificity 1; Precision of details 1; Logical structure and utility 1; Soundness and safety 0; Structure for readability 1; aggregated score 0.16730.1673. Root-cause specificity was not checkable and received the neutral score 1. Weakest referenced criterion. Correctness, at 0. Diagnosis returned by the diagnosis procedure. ⬇ The solution incorrectly identifies mu_2(j) as n-j+1, which depends on n. The function mu_2(j) must be independent of n to satisfy the identity for all n. Repair instruction. ⬇ Recognize that mu_2(j) must be independent of n; the current derivation conflates the summation limit with the term definition. The Greek letter and subscript in the original are rendered as mu_2. The claim that the function must not depend on n is wrong for this identity, whose upper limit is n. Accepted revision (complete) The revision is the boxed answer alone. The derivation was removed and the answer did not change. ⬇ $$ _2(j) = n - j + 1 $$ Score change and selection decision Revision scores. Correctness 1; Instruction adherence 1; Completeness 1; Relevance and clarity 1; Length and structure check 1; Non-repetition 1; Root-cause specificity 1; Precision of details 1; Logical structure and utility 1; Soundness and safety 1; Structure for readability 1; aggregated score 0.950.95. Decision. 0.95>0.1673+0.010.95>0.1673+0.01, so the revision was served. The verifier model judged the bare answer correct and sound, and the non-repetition check rose to 1 because a one-line response has no repeated 8-grams. Distilled procedure proposal. Trigger: “Variable depends on global parameter”. Action: “Ensure derived functions are independent of global parameters”. This item was only a proposal; it is absent from the final state and was not reused. Retrospective outcome The final evaluator preferred the draft over the revision. Under V0V_0 the same pair would have gained 0.250.25; under V1V_1 it gained 0.7830.783. Two checkpoint decisions. The three cards give the diagnostics line that the verifier model saw at task 128, the candidate adopted there, and the candidate retained against at task 256. Diagnostics supplied to synthesis at task 128 The residual line inserted into the candidate-synthesis prompt, recomputed from the completed rows: ⬇ Aggregate prefix diagnostics: repair win rate 35/128; weakest-criterion counts "co": 111, "ia": 3, "nr": 6, "pr": 2, "root_cau": 4; memory rules 6. The counts say that 35 of the first 128 revisions were accepted and that correctness was the weakest criterion in 111 diagnoses. Candidate adopted at task 128 Substantive changes. Two appended criteria (soundness and safety; structure for readability) and a rewritten aggregation that weights correctness at 0.50.5 and multiplies the sum by 0.4+0.6co0.4+0.6\,co, as shown in the verifier cards above. Selection set. Worst-family centered accuracy −0.1667-0.1667 for the current verifier and 0.00.0 for the selected candidate; mean centered accuracy 0.27080.2708 and 0.45830.4583. This is a strict gain. Held-out set, centered accuracy by family (candidate versus current verifier). Omission 0.47920.4792 vs. 0.35420.3542; unsupported claim 0.97920.9792 vs. 0.97920.9792; irrelevant insertion 0.18750.1875 vs. −0.0417-0.0417; root cause 0.00000.0000 vs. 0.00000.0000. Candidate successes per family: 71/96, 95/96, 57/96, 12/24. Paired held-out result. 19 pairs won only by the candidate, 2 won only by the current verifier. No family regressed by more than 0.100.10. Decision. The candidate was adopted under the empirical verifier-update rule. Auxiliary confidence bounds were mixed: the paired lower bound cleared 0.50.5, whereas the per-family lower bounds did not reach the logged threshold. We therefore interpret this as an observed improvement on the comparison sets, without a population-level claim. Current verifier retained at task 256 Diagnostics supplied. 27 accepted revisions among tasks 129 to 256, correctness weakest in 107 diagnoses, 6 stored procedures. Proposed change. Two appended criteria (grounding of claims or explicit uncertainty; acknowledgement of limitations and edge cases) and the aggregation ⬇ min(1, max(0, co * (0.4 + 0.6 * (ia + cp + cl + fc + nr + root_cau + pr + ul + sa + ts + fg + se) / 12))) Selection set. Worst-family centered accuracy −0.6667-0.6667 for the candidate against 0.00.0 for the current verifier; mean centered accuracy −0.0208-0.0208 against 0.3750.375. Decision. No strict selection gain, so the held-out comparison was not run and the current verifier was retained. One procedure from creation to reuse. The last card replays the retrieval and update records for one stored procedure, from the task that created it to a later task that retrieved it. One procedure, from creation to reuse Task 417 (mathematics: a puzzle in which 4+3=214+3=21 and 2+5=352+5=35). The diagnosis procedure flagged clarity: “The answer contains excessive, repetitive, and irrelevant trial-and-error calculations (e.g., listing ’4 × 3 + (4 + 3) = 19’ multiple times), making the response rambling and obscuring the logical derivation.” The repair asked for the failed attempts to be removed. The revision was accepted (score 0.86980.8698 to 0.950.95). Distilled and stored. Trigger: “Excessive repetitive trial-and-error obscures logic”. Action: “Remove redundant failed attempts; show only successful derivation.”. Dimension: clarity; scope: general. In the final state this procedure records 12 retrievals, 5 accepted and 8 rejected uses. Task 420 (mathematics: simplify (p↔q)∧(r↔q)(p q) (r q)). Retrieval returned two procedures, created at tasks 415 and 417. The diagnosis procedure identified the final answer as incorrect, the revision was accepted (score 0.10780.1078 to 0.94970.9497), and the final evaluator preferred the revision. Because two procedures were retrieved, the later outcome is not attributed to this single procedure. The timeline is descriptive.