💻 computer science

EVOQUANT: Self-Evolving Verifier-Guided Strategy Optimization for Robust Quantitative Trading

EVOQUANT is a self-evolving, verifier-guided framework that leverages large language models to automate the diagnosis, editing, and verification of quantitative trading strategies, significantly improving their performance and robustness while eliminating manual trial-and-error processes.

Original authors: Jie Mao, Changlun Li, Xiang Li, Qiqi Duan, Jinhui Yuan, Xiang Liu, Yuyu Luo, Jing Tang, Xiaowen Chu, Nan Tang

Published 2026-07-15

📖 5 min read🧠 Deep dive

CC BY 4.0

Original authors: Jie Mao, Changlun Li, Xiang Li, Qiqi Duan, Jinhui Yuan, Xiang Liu, Yuyu Luo, Jing Tang, Xiaowen Chu, Nan Tang

Original paper licensed under CC BY 4.0 (http://creativecommons.org/licenses/by/4.0/). ✨ This is an AI-generated explanation of the paper below. It is not written or endorsed by the authors. For technical accuracy, refer to the original paper. Read full disclaimer

Imagine you are trying to fix a very old, very complicated recipe for a cake that is supposed to win a baking contest. Usually, a human chef has to taste the cake, guess why it's dry, tweak the oven temperature, taste it again, and hope they didn't accidentally add salt instead of sugar. This is slow, tiring, and often leads to the chef making the same mistake over and over.

Now, imagine you hire a super-smart robot chef (a Large Language Model) to help. The problem is, if you just tell the robot, "Make this cake better," it might get too excited. It could hallucinate a new ingredient that doesn't exist, or it might change the recipe so wildly that the cake turns into a brick. It might even trick itself by only testing the cake on a tiny, lucky slice of the day, making it look perfect when it would actually fail in the real world.

This is exactly the problem the paper EVOQUANT tries to solve. The authors suggest that instead of letting the robot chef run wild, we need a strict taste-tester supervisor (a "Verifier") to watch every single change the robot makes.

The Magic Recipe Book: The "Strategy Genome"

First, the system takes the original trading strategy (the recipe) and turns it into a special, structured "genome." Think of this like a LEGO instruction manual where every brick is labeled. You can't just smash the whole thing apart; you have to swap specific bricks (like changing a "buy" signal or a "stop-loss" rule) in a way that keeps the structure intact. This ensures the robot isn't just guessing; it's making controlled, logical edits.

The Detective and the Editor

The system works in a loop, like a detective solving a mystery:

The Diagnosis: The robot acts like a detective, looking at the "crime scene" (the past performance data). It asks, "Why did this strategy lose money? Was it too risky? Did it stop trading when the market changed?" It doesn't just say "it failed"; it finds the specific failure mode.
The Controlled Edit: Based on that diagnosis, the robot proposes a fix. But here's the catch: it can't just propose any fix. It has to stick to a plan. If the problem is that the strategy is too sensitive to small market changes, the robot is told to make the strategy more stable, not to add more complex rules.
The Strict Taste-Tester (The Verifier): This is the most important part. Before the new recipe is allowed to be used, it goes through a rigorous "taste test" on data the robot has never seen before (out-of-sample data).
- If the new recipe only works on the training data but fails on the new data, the Verifier says, "Nope, that's a trick. Reject."
- If the new recipe loses too much money in a worst-case scenario, the Verifier says, "Too risky. Reject."
- Only if the new recipe proves it is genuinely better and safer does it get promoted to the "Champion" spot.

The Results: From "Yuck" to "Yum"

The authors tested this system on seven different trading strategies (four from the Chinese stock market and three from the Bitcoin market). They found that the system significantly improved the strategies' performance.

Before the robot helped, the average "score" (called the Sharpe ratio, which measures how much profit you get for the risk you take) was -0.298. That's a losing game. After the EVOQUANT system went to work, the average score jumped to 0.538. That's a winning game. One of the best strategies improved by 199% relative to its original self.

The paper shows that this isn't just luck. When they tested the system with higher fees (like a tougher baking contest) or different time periods, the strategies still held up, though the gains were a bit smaller. This suggests the improvements are real and not just a fluke.

What This System is NOT

The authors are very clear about what this is not.

It is not a magic wand that guarantees you will get rich. The paper explicitly states this is a research prototype, not financial advice.
It is not a system that just throws random changes at the wall until something sticks. The authors proved that if you remove the "diagnosis" step and just let the robot make random edits, the results are much worse. The "detective" part is essential.
It is not a system that eliminates all risk. In fact, for some strategies, the system accepted higher risk (larger drops in value) because the potential profit was so much better. The goal was a better balance, not a risk-free one.

The Bottom Line

The paper suggests that we can turn the messy, manual job of fixing trading strategies into a clean, automated loop. By using a robot to propose changes but a strict supervisor to verify them, we can evolve strategies that are smarter and more robust. The authors measured this through simulations and backtests on historical data, showing that this "Verifier-Guided" approach works better than letting the AI run free or letting humans do it all by hand.

It's like having a team where the creative artist (the LLM) draws the new designs, but the safety inspector (the Verifier) checks every single bolt before the plane is allowed to fly. And in these simulations, the planes flew much better than before.

Technical Summary: EVOQUANT

Problem Statement

Quantitative strategy optimization is traditionally a manual, labor-intensive process requiring domain experts to identify weak signals, tune risk controls, and iteratively validate revisions. While Large Language Models (LLMs) offer the potential to accelerate this loop, direct application of general-purpose LLMs to trading strategies introduces critical risks: hallucinated edits, strategy drift, and severe backtest overfitting. Existing approaches often lack transparent causal explanations for proposed changes or fail to distinguish between genuine signal refinement and selection bias among many degrees of freedom. The core challenge is not merely generating strategies, but improving them under a protocol that rigorously records, verifies, and rejects unsafe edits.

Methodology: EVOQUANT Framework

EVOQUANT (Self-Evolving Verifier-Guided Strategy Optimization) reframes quantitative strategy improvement as a verifier-guided program evolution problem. The system operates as a closed-loop scientific process comprising four modules:

1. Strategy Ingestion and Representation

The system normalizes user-provided strategies (code or rule text) into a typed strategy genome. This intermediate representation ( $g$ ) parses raw logic into an Abstract Syntax Tree (AST) and tags trading semantics (signals, entry/exit conditions, risk rules, position sizing). The genome is factored into editable layers and includes provenance metadata ( $\xi$ ) to track mutation history and strategy family. This structure ensures that all subsequent edits are localized, executable, and drift-constrained.

2. Baseline Evaluation and Evidence Construction

Before optimization, the system constructs a chronological evidence pack ( $E_t$ ) by backtesting the incumbent genome across train, validation, and test sets. This pack includes:

Scalar Metrics: Return, Sharpe ratio, maximum drawdown (MDD), trade count, and win rate.
Behavioral Profiles: Trade sparsity, holding period distributions, and return concentration.
Regime Sensitivity: Strategy performance across different market regimes.
Risk Diagnostics: Out-of-sample (OOS) degradation ( $\delta_{oos}$ ) and abnormal risk phenomena (e.g., excessive stop-loss triggering).

3. Diagnostic-Generative Optimization Loop

This core module iterates through diagnosis, generation, and verification:

Bottleneck Diagnosis: An LLM-based agent analyzes the evidence pack to identify specific failure modes (e.g., regime mismatch, alpha truncation). It generates a search plan ( $p_t$ ) defining the objective, search level (from local repair to family migration), and allowed operators.
Controlled Candidate Generation: Guided by the search plan and retrieved memory cases, the LLM generates an edit plan ( $\Delta_{t,i}$ ). Candidates must satisfy a typed edit contract, ensuring semantic drift ( $d_G$ ) remains within bounds and financial invariants are preserved. Edits range from parameter tuning to structural reconstruction.
OOS-Aware Verification and Promotion: A verifier evaluates candidates in parallel with the incumbent using strict hard gates (minimum trade counts, OOS drawdown limits, drift constraints). Candidates passing gates are ranked by a score ( $Q$ ) that balances validation improvement against OOS performance and penalties for drawdown expansion or stress-test failures.
Adaptive Promotion: The system assigns candidates to ADOPT (replace incumbent), INCUBATE (store for future reference), or REJECT. A built-in memory module distills successful patterns and failure reasons into a reusable knowledge base, enabling continual self-improvement and preventing the repetition of unproductive edits.

4. Iterative Refinement and Output

The loop continues until the budget is exhausted or convergence is reached. The final output includes the optimized strategy code, a comprehensive pre/post backtest report, and a full audit trail of diagnoses, edit plans, and promotion decisions.

Key Contributions

Evidence-Constrained Strategy Evolution: The paper formulates automated optimization as constrained program evolution where strategies are represented as structured "trading genomes." This supports localized, executable edits with preserved provenance, moving beyond unconstrained generative search.
Verifier-Guided Optimization Protocol: It introduces a unified, auditable loop where LLMs handle failure-mode diagnosis and hierarchical candidate synthesis, while an out-of-sample-aware verifier and adaptive promotion engine enforce rigorous safety and robustness standards.
Long-Horizon Cross-Market Evaluation: The framework is empirically validated across diverse asset classes (A-share equities and Bitcoin) and strategy families, utilizing before-after comparisons, component ablations, transaction-cost stress tests, and walk-forward validation.

Experimental Results

The framework was evaluated on seven representative strategies (four A-share, three Crypto) using data from 2020 to 2025.

Performance Gains: The average test Sharpe ratio improved significantly from −0.298 to 0.538. The best-performing strategy achieved a 199% relative improvement.
Robustness: Under doubled transaction cost and slippage assumptions, the mean Sharpe uplift remained positive (0.700). Walk-forward tests with different rolling windows confirmed that performance gains did not collapse, though magnitudes varied.
Ablation Studies: Removing the adaptive promotion engine reduced Sharpe uplift from 0.982 to 0.128, demonstrating that adaptive selection is a core enabler. Random mutation baselines achieved lower gains (0.645) and were more prone to strategy drift, confirming the necessity of diagnosis-guided search.
Market Adaptability: The system successfully improved strategies in both low-volatility equity markets and high-volatility crypto markets, reducing drawdowns in Bitcoin strategies while increasing returns in A-share strategies.

Significance and Claims

The paper claims to transform quantitative strategy optimization from a costly manual trial-and-error process into an automated, verifiable, and iterative paradigm.

Reliability over Generation: The work emphasizes that the value of LLMs in finance lies not in generating fluent code, but in grounding edits in chronological backtests, trade-coverage checks, and risk-sensitive promotion.
Auditability: By explicitly logging rejected candidates and failure reasons, EVOQUANT addresses the "black box" nature of LLM trading agents, providing a transparent audit trail for strategy evolution.
Scientific Process: The framework treats optimization as a scientific cycle of hypothesis, validation, and revision, mitigating data snooping and backtest overfitting through rigorous out-of-sample verification.

The authors position this work as a step toward applying LLMs to financial research, while explicitly noting that the system is a research prototype evaluated on historical data and simplified execution assumptions, not a live trading recommendation.