CogAlpha: A Cognitive Alpha Mining Framework

• CogAlpha is an automated alpha discovery framework that integrates Python-coded alphas, LLM reasoning, and evolutionary algorithms to extract robust predictive signals from financial data.
• It employs code-level representations with explicit type checks and unit tests, ensuring reproducibility and interpretability in financial model evaluation.
• Evolutionary search leveraging mutation, crossover, and multi-agent quality checks optimizes alphas to effectively navigate high-dimensional, noisy market data.

CogAlpha denotes a Cognitive Alpha Mining Framework for the automated discovery of interpretable, robust predictive signals—“alphas”—in financial datasets exhibiting high dimensionality and low signal-to-noise ratio. The approach integrates code-level alpha representation with large-language–model (LLM) reasoning and genetic-style evolutionary search. Within this context, alphas are explicit Python functions operating on daily OHLCV DataFrames, permitting structured exploration and human-like creativity while preserving rigorous logical and economic validity (Liu et al., 24 Nov 2025).

1. Architecture and Code-Level Alpha Representation

CogAlpha instantiates each candidate alpha as a Python function with explicit type checks and unit tests before financial evaluation. This code-level representation affords several advantages:

• Reproducibility: Executable code allows for systematic detection of information leakage and NaNs via automated tests prior to performance assessment.
• Expansive Search Space: Arbitrary arithmetic, rolling statistics, and nonlinear transforms (e.g., tanh, rank, z-score) substantially expand the set of admissible factors beyond static formula libraries.
• Interpretability: Each alpha is accompanied by a docstring articulating its financial logic (e.g., “price impact per unit volume”), ensuring result intelligibility.

The pipeline is structured into three interacting modules:

Module	Function	Example Sub-agent
Seven-Level Agent Hierarchy	Task agents generate alpha candidates	AgentLiquidity, AgentBarShape
Multi-Agent Quality Checker	Syntax, logic, and economic checks and refinement	CodeQuality, Judge
Thinking Evolution	LLM-driven mutation and recombination of code	Mutation Agent, Crossover Agent

Twenty-one task agents operate at seven semantic levels; each agent generates initial batches guided by domain-specific prompts and mini chain-of-thought rationales from previous rounds.

2. Evolutionary Search and LLM-Driven Reasoning

The framework conducts generational evolutionary optimization over code strings, leveraging LLMs for structured candidate variation.

2.1 Candidate Generation and Variation Modes

• Generation: Each task agent outputs approximately 80 distinct alpha functions per cycle, with prompt temperature randomized over {0.7,…,1.2}.
• Mutation: The Mutation Agent proposes minimal modifications (e.g., alternative normalization, time window) to parent code, preserving core economic logic.
• Crossover: The Crossover Agent fuses distinct functional motifs (e.g., price impact from one parent with nonlinear transform from another) into new offspring.
• Variation Modes: Three modes are employed: mutation-only, crossover-only, and sequential crossover→mutation.

2.2 Multi-Stage Prompting and Learning

Every LLM prompt per generation includes:

• Two “elite” and two “failure” prototypes annotated with success/failure rationales (e.g., “leaked future close prices”; “achieved IC=0.012”).
• A synthesis request for offspring that incorporate lessons learned.
• Enforcement of hard constraints: no nested loops, ≤5 logical steps, strict naming conventions.

2.3 Fitness Metrics and Selection Criteria

Each alpha candidate $f_i$ is quantitatively evaluated by:

• $$IC = \frac{1}{T} \sum_t \mathrm{cov}(f_i, r_{t+1}) / (\sigma_f \sigma_r)$$
• RankIC: rank-based Pearson analog
• ICIR: $E[IC_t]/\mathrm{Std}[IC_t]$
• RankICIR: $$E[\mathrm{RankIC}_t]/\mathrm{Std}[\mathrm{RankIC}_t]$$
• $$MI = \iint p(f, r)\log \frac{p(f, r)}{p(f)p(r)} \,df\,dr$$

Candidates qualify if all metrics surpass the 65th percentile (with absolute minimums, e.g., $IC \geq 0.005$). Immediate archiving (“elite”) requires exceeding the 80th percentile on stricter floors. The parent pool for the next generation incorporates the top 32 factors, plus prior-generation elites.

3. Algorithmic and Mathematical Foundations

The overall search process is formally described by a pipeline loop iterating across task agents, subcycles, and generations. The high-level pseudocode specifies:

• Initial elite set and parent pools per task agent
• Multiple agent-driven explorations and evolutionary variations per generation
• Inspection and filtering by multi-agent quality checking
• Fitness evaluation, percentile selection, and elite updating
• Generation-to-generation adaptation through prompt augmentation

The search space $\mathcal{C}$ comprises all code strings satisfying syntax/complexity constraints ($+$, $-$, $*$, $/$, $\mathrm{abs}$, $\mathrm{tanh}$, $\mathrm{rank}$, $\mathrm{zscore}$, $\mathrm{rolling\_mean}$, ...). The LLM induces a stochastic transition kernel $K(c \to c')$, parameterized by the prompt, with mutation and crossover yielding distinct kernels. Sampling is governed by:

$$\pi(c) \propto \exp(\beta \cdot \mathrm{Fitness}(c) - \lambda \cdot \mathrm{Complexity}(c))$$

Fitness is aggregated across predictive metrics; complexity penalties stem from step limits and logical constraints.

4. Empirical Validation and Ablation

4.1 Data and Experiment Structure

• Market: CSI 300 A-share stocks (daily OHLCV); predicting 10-day forward returns
• Temporal splits: Train (2011–2019), validation (2020), test (2021–2024)
• Portfolio construction: top-50 long, 5 daily replacements, explicit trading costs (0.05% buy, 0.15% sell)

4.2 Baseline Comparisons

Baselines include:

• Classical ML: Linear, MLP, RF, LightGBM, XGBoost, CatBoost, AdaBoost
• Deep learning: CNN, LSTM, GRU, Transformer
• Factor libraries: Alpha-158, Alpha-360
• LLM-generated formulas: Llama3-8B/70B, GPT-OSS-20B/120B, GPT-4.1, o3

4.3 Performance Results

On the test set:

Method	IC	IR
CogAlpha	0.0591	1.8999
LightGBM	0.0269	1.0980
GPT-OSS-120B	0.0300	—

Further summary metrics: RankIC = 0.0814, ICIR = 0.3410, RankICIR = 0.4350, AER = 16.39%.

4.4 Component Ablation

Sequential component removal quantifies incremental contributions:

Configuration	IC	IR
Agent only	0.0300	0.8015
+ ThinkingEvolution	0.0219	0.8999
+ Adaptation	0.0315	1.0145
+ Diversified Guidance	0.0414	1.4668
+ Seven-Level Hierarchy (full)	0.0591	1.8999

4.5 Factor Discovery Example

For “liquidity impact”:

• Initial: Alpha = (high–close)/(volume+ε), IC = 0.0090
• Mutated: Alpha′ = (high–low)/(volume+ε), IC = 0.0073 (discarded)
• Refined: Alpha″ = tanh(|close–open|/(close×volume + ε)), IC = 0.0141

5. Interpretability, Robustness, and Generalization

CogAlpha enforces interpretability by requiring docstrings detailing economic intuition (price impact, candlestick symmetry, regime gating). Complexity constraints (≤5 logical steps, no nested loops) mitigate overfitting and enforce semantic parsimony. The “Diversified Guidance” strategy broadens factor semantics through paraphrasing (light, moderate, creative, divergent, concrete), maintaining core financial relevance. Multi-agent quality checks eliminate coding errors, logical flaws, and future data leakage. Out-of-sample stability is quantified by ICIR and RankICIR, demonstrating generalization across market regimes.

6. Limitations and Future Directions

CogAlpha’s productivity is bounded by LLM model quality—the reasoning and generative capacities of the underlying LLMs dictate the diversity and validity of discovered alphas. Substantial computational resources are required: orchestrating numerous LLM agents and code evaluations is non-trivial, suggesting future research in model distillation or agent pruning. Live trading validation beyond simulated backtests remains an open challenge: real-time deployment must address execution slippage and adversarial dynamics inherent in capital markets.

A plausible implication is that aligning evolutionary optimization with adaptive LLM-driven reasoning substantially increases the scope and quality of automated alpha discovery, providing interpretable and robust predictive signals that outperform traditional black-box and formula-driven methods (Liu et al., 24 Nov 2025).