AI Trading System

Autonomous AI trading system with multi-model routing via Tetrate Agent Router Service (TARS), self-healing CI, continuous learning from failures, and a defined-risk SPY iron condor strategy.

North Star: $6K/month after-tax options income, as fast as safely possible (no fixed date).

Accounts: Alpaca Paper ($100K) validates strategy + Alpaca live brokerage opportunistically mirrors qualified setups behind strict risk gates.

Strategy: SPY-first iron condors (15-20 delta, $10-wide wings, up to 8 open option legs, typically ~2 concurrent condors). The risk layer uses an index/ETF whitelist that can expand (broker support permitting); current production trading targets SPY options.

Status: System State | Progress Dashboard | GitHub Pages | Judge Demo Evidence | RAG Query

System Overview

End-to-end architecture: data ingestion, AI decision engine, autonomous execution, safety compliance, and transparent reporting

Architecture

CI/CD Pipeline (30+ Automated Gates)

Every code change passes through 30+ automated quality, security, testing, and trading-specific gates

LLM Gateway & TARS Integration

Multi-model routing via TARS with budget-aware fallback to OpenRouter and Anthropic Direct

The system routes all LLM calls through a unified gateway (src/utils/llm_gateway.py) that supports Tetrate Agent Router Service (TARS) as the primary provider, with OpenRouter and direct Anthropic as fallbacks.

Budget-Aware Model Selection (src/utils/model_selector.py) implements the BATS framework — routing tasks to the cheapest model that can handle the complexity:

Safety guarantee: trade execution always uses Opus regardless of budget. Fallback chain: Opus -> Kimi K2 -> Mistral -> DeepSeek.

Autonomous Pre-Trade Reliability Controls (src/llm/trade_opinion.py)

• Uncertainty-adaptive consensus: when confidence is near the boundary (or risk flags exist), the system can run multiple independent samples and aggregate by majority vote + agreement score.
• Sampled strong-judge audit: optional quality/risk judge runs on a sampled subset of opinions and can enforce conservative overrides.

Key env vars:

Feedback-Driven Context Pipeline

Continuous learning: Signal Capture -> Thompson Sampling -> Memory Storage -> Context Injection

• LanceDB vector store — Semantic search over 170+ lessons learned (rag_knowledge/lessons_learned/)
• Thompson Sampling — Beta-Bernoulli model per task category with 30-day exponential decay
• MemAlign — Distills feedback into principles; syncs to ShieldCortex persistent memory
• Context injection — Weak categories and past failures injected into every session start

Trading Pipeline

6-stage execution with safety gates at every step and a closed learning loop

Ralph Mode (Autonomous CI)

Ralph is the self-healing loop that keeps the system operational:

• 88 GitHub Actions workflows — trading execution, position management, monitoring, learning
• Self-Healing Monitor — runs every 15 minutes during market hours, auto-fixes issues
• Ralph Loop — overnight autonomous coding sessions (design-first, atomic tasks, validation gates)
• Auto-published blog — lessons and reports publish to GitHub Pages and Dev.to automatically

Key Components

Strategy: SPY-First Iron Condors

Sell 15-20 delta put spread + 15-20 delta call spread
$10-wide wings, 30-45 DTE
Exit: 50% profit OR 7 DTE | Stop: 100% of credit
Max risk: $5,000 per position (5% of $100K), max 8 open option legs (~2 concurrent condors)

Why iron condors: Defined risk on both sides, ~85% probability of profit at 15-delta, theta decay works daily, profits in sideways markets. Phil Town Rule #1 (don't lose money) enforced at every level.

Iron Condor Payoff Profile

Defined risk on both sides: $150 credit collected, $350 max risk, 85% probability profit zone

Theta Decay & Exit Rules

Time decay accelerates exponentially — 50% profit target at 20-25 DTE, mandatory exit at 7 DTE

Thompson Sampling Learning

Bayesian reliability estimation: uncertainty narrows from 15-95% CI to 68-86% CI as signals accumulate

RAG Knowledge Retrieval

6-stage retrieval: embed query → semantic search → top-K results → context injection → informed decision

Quick Start

Runtime requirement: Python >=3.11,<3.12 (CPython 3.11.x).

git clone https://github.com/IgorGanapolsky/trading.git
cd trading
python3 -m venv venv && source venv/bin/activate
pip install -r requirements.txt
cp .env.example .env  # Configure API keys (see .env.example for full list)

python3 scripts/autonomous_trader.py     # Paper trading
python3 scripts/sync_alpaca_state.py     # Sync broker state
python3 scripts/system_health_check.py   # Health check
pytest tests/ -q                         # Run tests
ruff check src/                          # Lint

Risk Management

For AI Agents & LLMs

This repo is optimized for AI agent collaboration:

• System rules: .claude/CLAUDE.md
• Mandatory rules: .claude/rules/MANDATORY_RULES.md
• RAG knowledge base: rag_knowledge/
• RLHF feedback: .claude/memory/feedback/
• Agent terminal toolkit: scripts/agent_workflow_toolkit.py
• Toolkit usage: python3 scripts/agent_workflow_toolkit.py --help
• LLM manifest (summary): https://igorganapolsky.github.io/trading/llms.txt
• LLM manifest (full catalog): https://igorganapolsky.github.io/trading/llms-full.txt
• Auto-refresh workflow: .github/workflows/refresh-llms-manifests.yml

Quick bootstrap:

python3 scripts/agent_workflow_toolkit.py zsh-snippet   # x/p/s/funked helpers
python3 scripts/agent_workflow_toolkit.py slim-logs --in artifacts/devloop/continuous.log
python3 scripts/agent_workflow_toolkit.py bundle README.md src/utils/llm_gateway.py --out artifacts/devloop/context_bundle.md

Disclaimer

This software is for educational purposes only. Trading involves significant risk of loss. Past performance does not guarantee future results. Always paper trade before using real money. This is NOT financial advice.

Built with Python, Alpaca, TARS, OpenRouter, LanceDB, PaperBanana, and GitHub Actions

Maintained by Igor Ganapolsky