Grafy News
Try Grafy free

EvoTrias Introduces a Separation‑of‑Powers Architecture for LLM‑Driven Program Evolution

Researchers unveil EvoTrias, a new framework that allocates autonomy across governance.

Grafy News DeskNov 14, 20265 min read
Add to Preferred Sources
Illustration for the news story: EvoTrias Introduces a Separation‑of‑Powers Architecture for LLM‑Driven Program EvolutionSource: Grafy Research Lab

What is EvoTrias and why it matters?

EvoTrias is a newly proposed architecture for large‑language‑model (LLM)‑driven program evolution that explicitly separates three core decisions—govern, propose, and judge—into distinct owners. According to the authors, this "separation of powers" prevents the autonomy of any single component from leaking into the others, a problem that has hampered reliability in earlier systems. By assigning each decision its own plane—Structured Governance, Open Proposal, and Protected Judgment—the framework aims to keep the evolutionary loop both efficient and trustworthy, which is crucial for applications ranging from mathematical theorem proving to large‑scale system optimization.

How does EvoTrias differ from controller‑centric and agent‑centric approaches?

Existing research has largely followed two paradigms. Controller‑centric methods place a traditional evolutionary algorithm in charge of governance while a single LLM call handles proposal; this limits the creativity of the proposal step and keeps the judge exposed to the evaluator’s internals. Agent‑centric designs, exemplified by the CORAL family, hand both governance and proposal to a single coding agent, granting it full autonomy but at a high cognitive and computational cost, and still leaving the judge unprotected. EvoTrias breaks this deadlock by giving each decision a dedicated owner. Structured Governance distills evidence across evolution rounds, Open Proposal lets a general‑purpose coding agent (e.g., Claude Code or OpenCode) freely construct candidates, and Protected Judgment isolates the evaluator behind a private contract that only returns normalized fitness scores. Figure 1 in the paper visualises this three‑plane split, contrasting it with the blended ownership of earlier systems.

Figure 6: Runtime and token efficiency with GLM-5.2. (a) Signal Processing, best of three runs, cut off at EvoTrias’s 50-iteration runtime. (b) Average over the seven Mat…
Figure 6. Runtime and token efficiency with GLM-5.2. (a) Signal Processing, best of three runs, cut off at EvoTrias’s 50-iteration runtime. (b) Average over the seven Math tasks, budgets as in §5.1. Figure 6 of “Where Autonomy Belongs: A Separation of Powers for Agentic Program Evolution” by Zhengyang Ai, Tong Liu, Jingxian Tang et al. (arXiv.org), CC BY 4.0.
Figure 20: Best-so-far fitness over 50 evolution iterations. The Math and ADRS panels show the median-final-score run among three; the Frontier-CS panels show the single r…
Figure 20. Best-so-far fitness over 50 evolution iterations. The Math and ADRS panels show the median-final-score run among three; the Frontier-CS panels show the single run of that problem. Higher is better except for Cloudcast. CORAL observations are aligned by elapsed time to EvoTrias iterations. The Frontier-CS panels preserve zero-score prefixes while compressing the unused score interval. Figure 20 of “Where Autonomy Belongs: A Separation of Powers for Agentic Program Evolution” by Zhengyang Ai, Tong Liu, Jingxian Tang et al. (arXiv.org), CC BY 4.0.

What performance gains does EvoTrias deliver?

The authors report that EvoTrias achieves state‑of‑the‑art results on three benchmark suites: Math, ADRS, and Frontier‑CS. In head‑to‑head comparisons it outperforms OpenEvolve, EvoX, AdaEvolve, and multiple‑agent CORAL variants. Three concrete advantages are highlighted:

  1. Token efficiency – separating governance from proposal reduces token consumption by roughly 64%64\%, as shown in Figure 6, which plots runtime and token usage across several math tasks.
  2. Scalability – the Open Proposal plane can handle a 680 K‑line industrial repository, far beyond the reach of prior controller‑centric systems that struggled with anything larger than a few thousand lines.
  3. Benchmark fidelity – Protected Judgment keeps evaluator data private, preventing over‑fitting to test cases and preserving the transferability of scores, a concern raised for both earlier paradigms. Figure 20 illustrates the best‑so‑far fitness curves over 50 evolution iterations, where EvoTrias consistently climbs higher than the baselines across all problem categories.

How can developers experiment with EvoTrias using Graf by?

Graf by’s Code studio (/code/code) already provides an AI‑assisted coding environment that can integrate external agents via plugins. Because EvoTrias is designed as a plug‑in that sits outside the coding agent, a Graf by user could attach the EvoTrias runtime hook layer to any compatible coding model inside the Code app. The workflow would look like this:

  1. Set up a task contract – define the programming problem and evaluation budget in the Code workspace.
  2. Load the EvoTrias plugin – the plugin supplies Structured Governance, Open Proposal, and Protected Judgment components that communicate through typed contracts.
  3. Run the evolution loop – the Open Proposal plane (the coding agent) generates candidate code, Governance updates the search policy, and Judgment returns a private fitness score.
  4. Inspect lineage – Graf by’s Graph tool (/graph/graph) can visualise the evolutionary tree, letting developers trace how particular decisions propagated. If you prefer to read the paper in depth before building, the Reader app (/reader/reader) can ingest the arXiv PDF and answer questions about the method, effectively letting you explore the research without leaving the Graf by environment.

What are the current limitations and next steps?

While EvoTrias sets new performance records, the authors acknowledge several constraints. The Structured Governance plane relies on distilled evidence that may become stale in highly dynamic codebases, requiring periodic refreshes. Open Proposal still depends on the underlying coding agent’s capabilities; if the agent cannot handle certain language features, evolution stalls. Protected Judgment assumes a trustworthy private evaluator; in open‑source settings the evaluator itself may become a target for reverse engineering. Future work outlined in the paper includes adaptive context staleness handling, richer permission‑control policies for the judgment contract, and extending the architecture to multi‑modal tasks such as code‑plus‑documentation generation.

Source: Grafy Research Lab, arXiv:2611.15309 (2026‑11‑14)

Frequently asked questions

How does EvoTrias keep the judge independent from the other planes?

Protected Judgment isolates the evaluator behind a private contract that only returns a normalized validity and fitness score. Neither Governance nor Proposal can see the evaluator’s internal test cases, preventing them from over‑fitting to the benchmark.

Does EvoTrias require a specific coding agent model?

No. The Open Proposal plane can be implemented with any capable coding agent, such as Claude Code, OpenCode, or similar LLMs. The architecture treats the agent as a plug‑in, leaving the underlying model interchangeable.

Can I use EvoTrias on my own repository without re‑training models?

Yes. EvoTrias works as a runtime plugin that orchestrates existing agents and evaluators. By supplying your repository as the task context, Structured Governance will distill evidence from prior runs, and Open Proposal will generate candidates without needing to retrain the underlying LLM.

Source: Grafy Research Lab — Where Autonomy Belongs: A Separation of Powers for Agentic Program Evolution

More news