QuantEvolve — an evolutionary Gemini-powered agent for discovering & back-testing trading strategies

What it does & why it matters (Impact & Innovation)
Trading is hard. As algorithms make up more than 80% of all trading activity we need new platforms to be able to test and develop trading strategies to be able to compete with the large hedge funds. To tackle this problem we propose QuantEvolve. Inspired by Deepmind’s AlphaEvolve paper, it uses evolutionary programming and AI to create multiple solutions to the problem of making successful trading algorithms, improves them, and then evaluates them. The best solutions get fed into the next iteration and we repeat this over time.

What judges need to know

Technical Excellence — end-to-end demo & working code

• Autonomous loop: propose (Gemini) → patch (JSON diff) → backtest & score → select & mutate → repeat.
• Deterministic evaluation: fixed datasets, fees/slippage modeling, standard KPIs (Sharpe, max DD, CAGR, Calmar).
• Reproducibility: every run logs configs, code patches, and metrics for exact replay.

Solution Architecture & Documentation — repo, setup, README

Repo

  src/  
    engine/           # evolution controller, selection, mutation  
    evaluator/        # data loader, walk-forward backtester, KPIs  
    llm/              # Gemini client, prompts, JSON-patch schema  
    strategies/       # seed strategies & tests  
  scripts/            # CLI entry points (demo, eval, report)  
  README.md           # quickstart, structure, configs, troubleshooting  

• Docs: quickstart + config examples + “how we evaluate” section in README.

Gemini Integration — models, tool calling, multimodal, chaining, eval

• Models: Gemini via Google AI Studio (JSON-mode for structured outputs).
• Tool calling: Gemini returns a validated JSON patch; the engine invokes the evaluator as a tool, ingests KPIs, and feeds them back for the next step.
• Chaining: propose → validate → run → score → reflect → mutate (prompt-conditioned by prior metrics).
• Multimodal: designed to accept code + text (current demo uses text/code; image/table context is optional).
• Evaluation: offline, deterministic; no in-loop market calls.

Bonus

• Human-in-the-Loop: optional “curate next generation” step lets a reviewer pin/eliminate candidates between rounds.
• Google ADK / Vertex AI: not used in this build; adapter planned (the LLM boundary makes it a small swap).

Features (short)

• Strategy-level evolution (not just hyperparams) with niche exploration.
• Deterministic walk-forward backtests + standard KPIs.
• Run logs: patches, prompts, seeds, configs, and metrics.
• One-command demo & reproducible reports.

Limitations

• Research tool only; live trading is out of scope.
• Data quality & fee/slippage modeling bound realism.
• Requires Gemini API access (Google AI Studio).

Deployment Status

• Local CLI; results saved to ./runs/<experiment>/ (artifacts + reports).
• Private repo; access on request.

How to run & reproduce (local)

# 1) Clone (private)  
git clone <private-url>/alphaevolve-trading.git  
cd alphaevolve-trading  
  
# 2) Python env  
python -m venv .venv && source .venv/bin/activate  
pip install -e .  # or: pip install -r requirements.txt  
  
# 3) Gemini credentials (Google AI Studio)  
export GOOGLE_API_KEY=...   # (aka Gemini API key)  
  
# 4) Run the end-to-end demo  
python scripts/run_demo.py --experiment demo --iterations 10 --dataset sample  
  
# 5) Generate a report  
python scripts/report.py --experiment demo  
# Artifacts & KPIs: ./runs/demo/  

Key commands/URLs

• python scripts/run_demo.py … — run full propose→backtest→select loop
• python scripts/report.py … — export KPIs/plots for judges
• Google AI Studio (model key management): https://aistudio.google.com/

Tech Stack

Python 3.11+, Gemini (Google AI Studio), JSON-mode tool calling, pandas/numpy, (walk-forward) backtester, pydantic, tqdm, SQLite/CSV artifacts, pytest.

Contact (one-liner): Shaan — ping me on the event Discord/Devpost DM (handle: Shaan S.) for repo access or questions.