Source: Zhengyang Ai, Tong Liu, Jingxian Tang, Xiaobing Du, Tao Xiao, Fengshi Zhang, Zishuo Li, Xiaodong Ai, Pinyan Lu, "Where Autonomy Belongs: A Separation of Powers for Agentic Program Evolution", arXiv:2611.15309, submitted 2026-11-11 (58 pages), arXiv. Surfaced on LinkedIn by Pascal Biese, 2026-11-16.
The problem
LLM-driven program evolution (the AlphaEvolve family) loops: produce a candidate program, score it, build on the best. The paper names three decisions every such system makes:
Govern: which past candidates to build on and where to search next.
Propose: construct the next candidate.
Judge: decide whether it is valid and how fit it is.
Existing systems split into two camps. Controller-centric systems keep govern in a fixed algorithm and use a model call only to propose, which caps how ambitious each candidate can be. Agent-centric systems hand a coding agent (such as Claude Code) both govern and propose, which is costly and lets the agent see, and drift toward, how it is graded. Neither protects the judge.
Architecture
Each decision gets exactly one owner, and owners talk only through typed contracts, with runtime hooks enforcing the boundaries:
Structured Governance spans rounds: a controller picks parents and directions from accumulated scores.
Open Proposal works inside a round: a full coding agent writes and repairs the next version, with freedom to edit a real repository.
Protected Judgment sits behind a private evaluator the agent cannot open or modify.
Because the split is clean, EvoTrias ships as a plug-in that turns an existing coding agent (Claude Code or OpenCode, per the post) into an evolution system.
Results (as reported)
State of the art on mathematical, systems and algorithm-design benchmarks.
Separating governance from proposal cuts token cost by 64%. The post's illustration: about $41 per full run on seven maths tasks versus about $115 for the strongest rival, which runs four agents in parallel, while EvoTrias led on six of the seven.
Open Proposal scales evolution to a 680K-line industrial repository.
Protected Judgment keeps benchmark scores faithful to transfer, meaning gains on the scored task carry over rather than reflecting grader gaming.
It costs more than the simplest single-call controller systems.
Why it matters beyond program evolution
The lesson generalises to any agent loop with a metric: give the agent autonomy where creativity pays (writing code), keep search strategy in cheap deterministic code, and make the evaluator unreadable and unwritable by the agent. The best agent here was the one trusted with the fewest decisions.
Tradeoffs
The controller's search policy is now a design surface; a poor policy wastes a capable proposer.
Typed contracts between roles add engineering overhead and limit what the agent can communicate upward (for example, "this direction is a dead end").
A private judge is only as good as its coverage; hiding it prevents gaming but not blind spots.
Failure modes to watch
Agents that infer the grader from feedback alone even without reading it (score probing).
Hooks that can be bypassed by shell access or by editing configuration.
Cost savings that come from fewer, shallower proposals rather than better governance; compare at equal quality.
Review checklist for an optimise-against-a-metric agent loop
Who decides what to try next: the agent, or deterministic code with logged rationale?
Can the agent read, run selectively or edit the evaluator? Is that enforced, not just instructed?
Is there a held-out check that scores transfer, not just the training metric?
Is cost per accepted improvement tracked, not just best score?
Related
R102 AI-assisted performance tuning overfits to the benchmark machine (the same metric-gaming risk in everyday optimisation).
R098 Stanford CS329A (verifiers, open-ended evolution, AlphaEvolve).
R094 CodeClimb (self-improving coding agent with hidden tests and budgets).
R086 Agents doing AI engineering: four November 2026 benchmarks.