🤖 AI

AlphaMemo: Structured Search-Process Memory for Self-Evolving Alpha Mining Agents

AlphaMemo is a self-evolving LLM agent for alpha mining that enhances discovery efficiency and out-of-sample performance by utilizing a structured search-process memory to record and leverage reusable edit motifs, confidence-gated residuals, and asymmetric veto controls against failure patterns.

Original authors: Hang Yu, Zifan Zheng, Jeff Z. Pan, Tongliang Liu, Zhiyong Wang, Fengxiang He

Published 2026-06-23

📖 5 min read🧠 Deep dive

CC BY 4.0

Original authors: Hang Yu, Zifan Zheng, Jeff Z. Pan, Tongliang Liu, Zhiyong Wang, Fengxiang He

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 find the perfect recipe for a dish that will sell millions of copies. You have a massive library of existing recipes (the "search ledger"), and you want to create new ones by tweaking the old ones.

In the world of finance, this is called Alpha Mining. Instead of food, the "recipes" are mathematical formulas that predict stock prices. The goal is to find formulas that are accurate, unique, and don't just copy what everyone else is doing.

The paper introduces AlphaMemo, a smart computer agent designed to do this recipe-searching job better than before. Here is how it works, explained through simple analogies:

The Problem: The "Blind Chef"

Previous AI agents trying to find these stock formulas were like chefs who only remembered the final taste of a dish.

The Issue: If a dish tasted good, the chef would try to make it again. If it tasted bad, they would avoid it.
The Flaw: This is too simple. Sometimes a dish tastes good just because of luck (bad for long-term investing). Sometimes a chef makes a tiny, specific change (like adding a pinch of salt instead of sugar) that causes a failure, but the AI doesn't know which change caused it. It just sees "Bad Dish" and moves on. This leads to wasted time and repeating the same mistakes.

The Solution: AlphaMemo's "Kitchen Notebook"

AlphaMemo is different because it keeps a Structured Search-Process Memory. Instead of just remembering the final dish, it keeps a detailed notebook about the process of cooking.

Here are the four main ingredients of AlphaMemo:

1. The "Edit Motif" (The Specific Tweak)

When a chef changes a recipe, they don't just say "I changed it." They say, "I swapped the baking time from 20 minutes to 25."

How AlphaMemo does it: It looks at the mathematical "skeleton" (called an Abstract Syntax Tree) of the old formula and the new one. It identifies the exact "edit motif"—the specific move the AI made (e.g., "added a time delay," "swapped a ranking operator").
The Benefit: It learns that this specific move, when applied to this specific type of recipe, usually works or fails.

2. The "Confidence Gate" (The Safety Valve)

Imagine a new chef who is very excited and claims, "I tried adding chili once, and it was amazing!" But they only tried it once. Should you trust them? Probably not.

How AlphaMemo does it: It has a Confidence Gate. It won't let the memory influence decisions until it has seen the same "edit" work (or fail) many times. If the data is noisy or scarce, the agent ignores the memory and sticks to its basic, safe search rules. This prevents the AI from getting fooled by early luck.

3. The "Residual Correction" (The Fine-Tuner)

The agent has a strong base rulebook (the "Search Ledger") that tells it which recipes are generally good based on history.

How AlphaMemo does it: The memory doesn't try to rewrite the whole rulebook. Instead, it acts like a fine-tuner. It asks: "The rulebook says this recipe should be a 7/10. But based on our past experience with this specific tweak, it usually gets an extra 1 point."
The Benefit: It corrects small blind spots without overhauling the entire system, keeping the search stable.

4. The "Asymmetric Veto" (The Strict Critic)

This is the most clever part. In finance, finding a "winning" formula is hard and fragile (it might stop working next month). But finding a "losing" pattern is often easy and permanent (e.g., a formula that is mathematically broken or too complex).

How AlphaMemo does it: It treats positive and negative memories differently.
- Positive memories (good edits) are treated as a "soft suggestion." They give a little boost but don't force the agent to go there.
- Negative memories (bad edits) are treated as a hard veto. If the agent sees a pattern that has failed with high confidence before, it immediately says, "No, don't do that," and blocks that path.
The Benefit: It aggressively avoids known traps while remaining open to discovering new, fragile successes.

The Results: A Better Search

The authors tested AlphaMemo on two major stock markets: the CSI 500 (China) and the S&P 500 (USA).

Better Predictions: The formulas AlphaMemo found predicted stock movements more accurately than other methods.
Less Redundancy: It found more unique, useful formulas without wasting time on duplicates.
Stability: Because of the "Confidence Gate" and "Asymmetric Veto," it didn't get confused by early noise or lucky breaks.

Summary

Think of AlphaMemo not as a chef who just remembers the best dishes, but as a master sous-chef who keeps a detailed log of every specific ingredient swap and cooking technique. It knows exactly which small changes tend to ruin a dish (and blocks them immediately) and which small tweaks tend to improve a dish (and suggests them carefully), all while relying on a solid base of culinary knowledge to keep the search grounded.

This approach allows the AI to "self-evolve" by learning from its search process, making it a more efficient and reliable tool for finding financial signals.

Technical Summary: AlphaMemo

Problem Statement

Alpha factor mining involves discovering predictive, interpretable symbolic expressions (formulas) over price-volume variables to forecast asset returns. While Large Language Model (LLM) agents offer a promising framework for this task—combining financial priors, symbolic reasoning, and feedback-driven refinement—they face significant hurdles in a self-evolving setting:

Combinatorial Search Space: The space of possible symbolic expressions is vast.
Noisy, Non-Stationary Feedback: Financial data feedback is often noisy, and market regimes change, making historical successes unreliable.
Redundancy and Overfitting: Naively reusing past successful factors or full trajectories can lead to redundant discoveries and overfitting to specific market conditions.
Credit Assignment: Existing workflows often store only final factor scores or unstructured histories, failing to identify which specific local edits caused a child factor to succeed or fail relative to its parent.

The core challenge is to design a memory mechanism that targets the search process itself rather than just the final outcomes, allowing agents to learn which edit motifs work under specific parent-factor contexts without becoming unstable or overfitting.

Methodology: AlphaMemo

The authors propose AlphaMemo, a self-evolving alpha mining agent centered on Structured Search-Process Memory (SSPM). Unlike agents that store full trajectories or only final results, AlphaMemo records reusable evidence about specific edit motifs and their outcomes under specific parent contexts.

Core Architecture

The system operates in a loop involving three main phases:

Action Scoring & Selection:
- Search-Ledger Prior: The agent maintains a factor-library ledger ( $G_t$ ) that tracks evaluated factors, their lineage, depth, and diversity. A base scorer assigns a parent score ( $S_{ledger}$ ) based on these structural properties.
- Confidence-Gated Residual Fusion: For a candidate action (parent $p$ , edit motif $m$ ), the agent calculates a score:
  $A_t(p, m) = \log(S_{ledger}(p) + \epsilon) + \lambda_t c_t(z, m) \Delta_t(z, m)$
  Here, $\Delta_t$ is the residual memory (the difference between observed child quality and the base prior's expectation), and $c_t$ is a confidence gate. The memory contribution vanishes if evidence is sparse or unstable, ensuring the agent falls back to the robust base search prior.
- Asymmetric Process Veto (APV): High-confidence negative patterns (e.g., invalid syntax, over-mined transformations) can veto an action entirely. Positive patterns, however, only provide a soft boost. This asymmetry reflects the reality that negative failure modes are often more stable across regimes than fragile positive alpha signals.
Factor Generation & Motif Extraction:
- The LLM generates a child factor based on the selected parent and intended edit.
- AST-Diff Motifs: Instead of relying on manually specified mutation labels, AlphaMemo extracts edit motifs by computing the difference between the Abstract Syntax Trees (AST) of the parent and child expressions. These motifs are canonicalized and mapped to a compact vocabulary (e.g., "add condition gate," "rescale window," "swap operator"). This allows credit assignment at the level of reusable search behaviors rather than surface-level string changes.
Evaluation & Update:
- Generated factors are evaluated against a quality vector (IC, ICIR, etc.).
- Valid factors are admitted to the pool; invalid or rejected ones are recorded as failures.
- The SSPM is updated with the observed residual outcome and failure status, refining the statistics for future context-motif pairs.

Key Design Principles

Residual Learning: The memory does not predict absolute factor quality (which would duplicate the base scorer and risk overfitting). Instead, it learns the residual gain of a local edit over the base expectation.
Calibrated Correction: The system uses confidence gating and warmup schedules to ensure memory only influences the search when evidence is statistically significant.
Asymmetry: The system prioritizes avoiding known failure modes (hard veto) over aggressively exploiting potential successes (soft boost).

Key Contributions

Structured Search-Process Memory (SSPM): A novel memory architecture that stores edge-level evidence (parent context + edit motif $\to$ outcome) rather than node-level final scores or full trajectories.
AST-Diff Edit Motifs: A method for extracting compact, reusable symbolic abstractions of LLM-generated edits directly from syntax tree differences, enabling precise credit assignment.
Confidence-Gated Residual Fusion: A mechanism that treats memory as a bounded, calibrated correction to a strong search-ledger prior, preventing early noisy observations from dominating the search policy.
Asymmetric Process Veto: A control mechanism that aggressively suppresses high-confidence failure patterns while treating positive patterns as soft preferences, addressing the non-stationarity of financial data.

Experimental Results

The authors evaluated AlphaMemo on CSI 500 (Chinese A-shares) and S&P 500 (US large caps) using a 20-trading-day prediction protocol.

Performance: AlphaMemo variants achieved strong out-of-sample performance.
- On S&P 500, the "Residual" configuration achieved the best IC, RankIC, RankICIR, annualized return, and Sharpe ratio among baselines.
- On CSI 500, the "Balanced" configuration (weaker memory intervention) yielded the strongest predictive and portfolio metrics, outperforming baselines like AlphaGen, AlphaGPT, and traditional GP.
Discovery Efficiency: Under a fixed generation budget, AlphaMemo discovered more effective, non-redundant factors compared to search-ledger-only agents and random search.
Ablation Studies: Removing key components confirmed their necessity:
- Removing residual learning reduced stability.
- Removing confidence gating increased sensitivity to early noisy feedback.
- Replacing AST-diff motifs with manual labels reduced discovery yield.
- Removing asymmetric veto weakened the ability to avoid repeated failure patterns.

Significance and Claims

The paper claims that AlphaMemo addresses the specific challenges of self-evolving agents in financial search by shifting the memory focus from "what worked" to "how it worked."

Interpretability: The memory table is inspectable, allowing researchers to audit which edit behaviors are being promoted or suppressed (e.g., "Under context $z$ , motif $m$ has a mean residual of $\Delta$ ").
Stability vs. Adaptation: By treating memory as a residual correction rather than a policy update, AlphaMemo avoids the overfitting risks associated with fine-tuning LLMs on noisy financial feedback.
Generalizability: The approach is designed to be independent of the specific LLM generator or market, relying instead on the structure of the symbolic search process.

The authors conclude that structured process memory, when calibrated and asymmetric, significantly improves the efficiency and robustness of self-evolving alpha mining agents, offering a middle ground between static factor libraries and unstable, full-trajectory memory systems.