Architecting AI-Driven Systems for Financial Markets

Financial markets generate petabytes of data daily: price ticks, order book updates, news feeds, earnings reports, social media sentiment, and macroeconomic indicators. Traditional quantitative finance relies on human-designed models—moving averages, mean reversion strategies, factor models—that capture known patterns but struggle to adapt to regime changes and novel market dynamics. Modern AI agents combine machine learning with systematic trading infrastructure to process multimodal signals, estimate future price movements, and execute trades at scale.

This article examines the architecture of production-grade AI trading systems, analyzing data pipelines, feature engineering, prediction models, risk management, and backtesting infrastructure. We draw on published research from Renaissance Technologies, Two Sigma, Citadel, and academic literature, while maintaining focus on practical implementation challenges.

Why AI for market estimation is fundamentally difficult:

Unlike supervised learning tasks with ground truth labels (image classification, speech recognition), financial prediction faces severe adversarial dynamics. The market is not a static dataset—it’s a competitive game where your signal becomes worthless once others discover it. If your model predicts Apple stock will rise based on iPhone sales data, and 1,000 other traders make the same prediction, the price adjusts instantly via their buy orders, eliminating the edge. This is the Efficient Market Hypothesis (EMH) in action: prices reflect all available information, making consistent outperformance statistically impossible under strong-form EMH.

Yet markets are not perfectly efficient. Information diffuses gradually, behavioral biases create mispricings, and liquidity constraints prevent instant arbitrage. The challenge is finding alpha (excess returns above market benchmarks) that persists long enough to monetize. Quantitative hedge funds like Renaissance Medallion achieved 66% annualized returns (after fees) over 30 years by exploiting fleeting statistical anomalies—most lasting seconds to hours—across thousands of instruments simultaneously.

Key architectural differences from standard ML systems:

Financial ML requires continuous retraining, regime-aware models, robust risk controls, and infrastructure designed for high-frequency, low-latency operation.

System Architecture

A production financial AI agent decomposes into distinct stages, each with specialized infrastructure:

flowchart TB
    subgraph Data Ingestion
        Market[Market Data Feed<br/>IEX, Polygon, Bloomberg]
        News[News APIs<br/>Reuters, Bloomberg, Twitter]
        Alt[Alternative Data<br/>Satellite imagery, credit card]
    end

    subgraph Feature Engineering
        Market --> Tick[Tick Processor<br/>OHLCV, VWAP, Order Book]
        News --> NLP[NLP Pipeline<br/>Sentiment, Entity, Events]
        Alt --> AltProc[Alternative Feature Extractor]

        Tick --> FeatureStore[(Feature Store<br/>Redis, FeatureStore)]
        NLP --> FeatureStore
        AltProc --> FeatureStore
    end

    subgraph Prediction Engine
        FeatureStore --> Model[ML Models<br/>LSTM, Transformers, GBM]
        Model --> Ensemble[Ensemble & Calibration]
        Ensemble --> Signal[Trading Signals]
    end

    subgraph Execution
        Signal --> Risk[Risk Management<br/>Position sizing, Stop loss]
        Risk --> Portfolio[Portfolio Optimizer<br/>Mean-variance, Black-Litterman]
        Portfolio --> Broker[Broker API<br/>Alpaca, Interactive Brokers]
        Broker --> Market
    end

    subgraph Monitoring
        Broker --> Backtest[Backtesting Engine<br/>Walk-forward, Monte Carlo]
        Backtest --> Metrics[Performance Metrics<br/>Sharpe, Max Drawdown]
        Metrics --> Alerts[Alerting & Circuit Breakers]
    end

Latency budgets and infrastructure choices:

Most systematic funds operate in the medium-to-low frequency range where alpha comes from superior signals rather than speed. We focus on this regime.

Market Data Processing

Financial data arrives in multiple formats and frequencies, each requiring specialized handling.

Tick Data and OHLCV Aggregation

Raw tick data consists of individual trades and quotes:

type Tick struct {
    Symbol    string
    Timestamp time.Time
    Price     float64
    Volume    int64
    Side      string // "buy" or "sell"
}

OHLCV (Open-High-Low-Close-Volume) bars aggregate ticks into time windows:

Implementation (Go for performance-critical path):

type OHLCVBar struct {
    Symbol    string
    Timestamp time.Time
    Open      float64
    High      float64
    Low       float64
    Close     float64
    Volume    int64
}

type BarAggregator struct {
    interval  time.Duration
    buffer    map[string]*BarBuilder
    output    chan OHLCVBar
}

type BarBuilder struct {
    symbol    string
    startTime time.Time
    open      float64
    high      float64
    low       float64
    close     float64
    volume    int64
    firstTick bool
}

func (agg *BarAggregator) ProcessTick(tick Tick) {
    barTime := tick.Timestamp.Truncate(agg.interval)

    builder, exists := agg.buffer[tick.Symbol]
    if !exists || builder.startTime != barTime {
        // Flush previous bar if exists
        if exists {
            agg.output <- builder.Build()
        }
        builder = NewBarBuilder(tick.Symbol, barTime, tick.Price)
        agg.buffer[tick.Symbol] = builder
    }

    builder.Update(tick)
}

func (b *BarBuilder) Update(tick Tick) {
    if b.firstTick {
        b.open = tick.Price
        b.high = tick.Price
        b.low = tick.Price
        b.firstTick = false
    }

    if tick.Price > b.high {
        b.high = tick.Price
    }
    if tick.Price < b.low {
        b.low = tick.Price
    }

    b.close = tick.Price
    b.volume += tick.Volume
}

Volume-Weighted Average Price (VWAP) is critical for execution quality:

where $P\_i$ is trade price, $V\_i$ is trade volume. VWAP serves as a benchmark: buying below VWAP indicates good execution.

Order Book Dynamics

Level 2 market data provides the full order book:

type OrderBook struct {
    Symbol    string
    Timestamp time.Time
    Bids      []Level // Price levels with volume
    Asks      []Level
}

type Level struct {
    Price  float64
    Volume int64
}

Order book imbalance predicts short-term price movements:

where $V_{\text{bid}} = \sum_{i=1}^{k} \text{Bid}_i.\text{Volume}$ over top $k$ levels (typically $k=5$).

Empirical finding (Cont et al., 2014): Imbalance has predictive power for next-tick price movement with correlation $\rho \approx 0.15$ for liquid stocks over 1-second horizons. This seems small, but is highly significant given market noise.

Bid-ask spread indicates liquidity:

Wide spreads signal illiquidity or information asymmetry; narrow spreads enable profitable high-frequency strategies.

News and Sentiment Analysis

News drives 20-30% of intraday price volatility (Tetlock 2007, Boudoukh et al. 2019). AI agents must parse unstructured text, extract sentiment, and estimate impact.

News Ingestion Pipeline

Data sources:

• Newswires: Reuters, Bloomberg, Dow Jones (expensive, professional-grade)
• Earnings transcripts: Seeking Alpha, SEC EDGAR filings
• Social media: Twitter/X (via API), Reddit WallStreetBets, StockTwits
• Alternative: Satellite imagery (retail parking lots), credit card data

Challenges:

• Latency: News moves markets in milliseconds; slow parsing loses alpha
• Noise: 90% of news is irrelevant or already priced in
• Sarcasm/nuance: “Tesla earnings beat expectations… barely” is negative despite “beat”

Sentiment Extraction

Classical approach (FinBERT, 2020):

from transformers import BertTokenizer, BertForSequenceClassification
import torch

class SentimentAnalyzer:
    def __init__(self):
        self.tokenizer = BertTokenizer.from_pretrained('ProsusAI/finbert')
        self.model = BertForSequenceClassification.from_pretrained('ProsusAI/finbert')
        self.model.eval()

    def analyze(self, text: str) -> dict:
        inputs = self.tokenizer(text, return_tensors='pt', truncation=True, max_length=512)

        with torch.no_grad():
            outputs = self.model(**inputs)
            logits = outputs.logits
            probs = torch.softmax(logits, dim=1).squeeze()

        # FinBERT outputs: [negative, neutral, positive]
        return {
            'negative': probs[0].item(),
            'neutral': probs[1].item(),
            'positive': probs[2].item(),
            'sentiment_score': probs[2].item() - probs[0].item()  # Range: [-1, 1]
        }

Event extraction (earnings surprises, M&A announcements):

import spacy

class EventExtractor:
    def __init__(self):
        self.nlp = spacy.load('en_core_web_trf')
        self.event_patterns = {
            'earnings_beat': r'beat estimates|exceeded expectations|surpassed forecasts',
            'earnings_miss': r'missed estimates|fell short|disappointed',
            'merger': r'acquir(e|ing|ed)|merger|takeover|buyout',
            'bankruptcy': r'bankrupt|chapter 11|insolvency'
        }

    def extract(self, text: str) -> list:
        doc = self.nlp(text)
        events = []

        # Entity recognition for companies
        entities = [ent.text for ent in doc.ents if ent.label_ == 'ORG']

        # Pattern matching for events
        for event_type, pattern in self.event_patterns.items():
            if re.search(pattern, text, re.IGNORECASE):
                events.append({
                    'type': event_type,
                    'entities': entities,
                    'text': text[:200]  # Snippet
                })

        return events

Aggregate sentiment score for a symbol over time window:

where $s_i$ is sentiment of article $i$, $w_i$ is source credibility weight, $t_i$ is publish time, and $\lambda$ controls decay (recent news matters more).

Production consideration: Financial news APIs cost $1,000-$50,000/month. Bloomberg Terminal costs $24,000/year per user. Many systematic traders use alternative data (satellite parking lot images predicting retail earnings, shipping manifests) to find uncrowded signals.

Feature Engineering

Raw data must be transformed into predictive features. Financial features fall into three categories:

Technical Indicators

Moving averages:

Relative Strength Index (RSI):

RSI > 70 signals “overbought”; RSI < 30 signals “oversold”.

Bollinger Bands (volatility indicator):

where $\sigma\_t$ is rolling standard deviation. Prices hitting bands suggest mean reversion.

Python implementation (vectorized with NumPy):

import numpy as np
import pandas as pd

class TechnicalIndicators:
    @staticmethod
    def sma(prices: pd.Series, window: int) -> pd.Series:
        return prices.rolling(window=window).mean()

    @staticmethod
    def ema(prices: pd.Series, window: int) -> pd.Series:
        return prices.ewm(span=window, adjust=False).mean()

    @staticmethod
    def rsi(prices: pd.Series, window: int = 14) -> pd.Series:
        delta = prices.diff()
        gain = (delta.where(delta > 0, 0)).rolling(window=window).mean()
        loss = (-delta.where(delta < 0, 0)).rolling(window=window).mean()
        rs = gain / loss
        return 100 - (100 / (1 + rs))

    @staticmethod
    def bollinger_bands(prices: pd.Series, window: int = 20, num_std: float = 2.0):
        sma = prices.rolling(window=window).mean()
        std = prices.rolling(window=window).std()
        upper = sma + num_std * std
        lower = sma - num_std * std
        return upper, sma, lower

    @staticmethod
    def macd(prices: pd.Series, fast: int = 12, slow: int = 26, signal: int = 9):
        ema_fast = prices.ewm(span=fast, adjust=False).mean()
        ema_slow = prices.ewm(span=slow, adjust=False).mean()
        macd_line = ema_fast - ema_slow
        signal_line = macd_line.ewm(span=signal, adjust=False).mean()
        histogram = macd_line - signal_line
        return macd_line, signal_line, histogram

Fundamental Factors

Fama-French factors (academic standard):

where:

• MKT: Market return (S&P 500)
• SMB: Small Minus Big (size factor)
• HML: High Minus Low (value factor)

Momentum factor (Jegadeesh & Titman, 1993):

Stocks with high past returns tend to continue outperforming (momentum anomaly).

Value factor (Price-to-Book):

Low P/B stocks historically outperform (value anomaly).

Data source: Fundamental data from Quandl, Alpha Vantage, Financial Modeling Prep APIs.

Alternative Data Features

Satellite imagery (orbital insight for retail traffic):

• Pixel count of cars in Walmart parking lots → predict quarterly sales
• Oil storage tank shadows → estimate inventory levels

Credit card transactions (anonymized, aggregated):

• Consumer spending trends by sector → predict earnings

Social media volume:

Sudden spikes in Twitter mentions precede volatility (but often noise).

Feature importance analysis (Random Forest on S&P 500, 2015-2020):

Momentum and order book imbalance dominate. Many classical indicators (RSI, MACD) have weak predictive power in isolation.

Prediction Models

Financial prediction spans multiple paradigms depending on target variable and horizon.

Price Forecasting (Regression)

Objective: Predict next-period return $r\_{t+1} = \frac{P\_{t+1} - P\_t}{P\_t}$.

LSTM for time series (captures temporal dependencies):

import torch
import torch.nn as nn

class PricePredictor(nn.Module):
    def __init__(self, input_size, hidden_size, num_layers, dropout=0.2):
        super().__init__()
        self.lstm = nn.LSTM(input_size, hidden_size, num_layers,
                            batch_first=True, dropout=dropout)
        self.fc = nn.Linear(hidden_size, 1)

    def forward(self, x):
        # x shape: (batch, seq_len, input_size)
        lstm_out, (h_n, c_n) = self.lstm(x)
        # Use last hidden state
        out = self.fc(h_n[-1])
        return out

# Training loop
model = PricePredictor(input_size=50, hidden_size=128, num_layers=2)
criterion = nn.MSELoss()
optimizer = torch.optim.Adam(model.parameters(), lr=0.001)

for epoch in range(100):
    for batch_x, batch_y in dataloader:
        optimizer.zero_grad()
        predictions = model(batch_x)
        loss = criterion(predictions, batch_y)
        loss.backward()
        optimizer.step()

Attention mechanism (Transformer):

Modern approaches use Temporal Fusion Transformer (Lim et al., 2021) which combines:

• Multi-head self-attention for long-range dependencies
• Gating mechanisms for feature selection
• Quantile regression for uncertainty estimation

Gradient Boosting Machines (LightGBM, XGBoost):

Often outperform deep learning for tabular financial data due to better handling of missing values and categorical features.

import lightgbm as lgb

params = {
    'objective': 'regression',
    'metric': 'rmse',
    'boosting_type': 'gbdt',
    'num_leaves': 31,
    'learning_rate': 0.05,
    'feature_fraction': 0.8
}

train_data = lgb.Dataset(X_train, label=y_train)
model = lgb.train(params, train_data, num_boost_round=1000)
predictions = model.predict(X_test)

Classification (Direction Prediction)

Objective: Predict $y_{t+1} \in \{\text{Up}, \text{Down}, \text{Flat}\}$.

Accuracy paradox: Even 55% accuracy can be profitable with proper position sizing, but most models achieve 50-52% (barely above random).

Log-loss vs accuracy: Financial ML optimizes log-loss or calibrated probabilities rather than raw accuracy, because bet sizing depends on confidence.

Regime Detection (Hidden Markov Models)

Markets switch between regimes (bull, bear, high volatility, low volatility). Models trained on one regime fail in another.

Hidden Markov Model:

Regime-conditional models: Train separate models for each regime, switch based on HMM state.

Risk Management and Position Sizing

Most important lesson in quantitative finance: Risk management matters more than prediction accuracy. A model with 60% accuracy but poor risk controls loses money; a 52% accurate model with disciplined position sizing makes money.

Kelly Criterion

Optimal bet size to maximize long-term growth:

where:

• $p$ = win probability
• $q = 1 - p$ = loss probability
• $b$ = win/loss ratio

Example: If $p = 0.55$, $b = 1.5$ (win $1.50 for every $1 lost):

Bet 25% of capital. But full Kelly is too aggressive—practitioners use half-Kelly or quarter-Kelly to reduce volatility.

Mean-Variance Portfolio Optimization

Markowitz model (1952 Nobel Prize):

where $\mathbf{w}$ is weight vector, $\Sigma$ is covariance matrix, $\boldsymbol{\mu}$ is expected return vector.

Problem: Covariance estimates are noisy, leading to extreme positions. Solution: Regularization (L2 penalty, shrinkage estimators).

Black-Litterman model (Goldman Sachs, 1992):

Combines market equilibrium with investor views:

where $\Pi$ is market equilibrium, $P$ encodes views, $Q$ is view returns, $\Omega$ is view uncertainty.

Stop-Loss and Drawdown Control

Maximum drawdown constraint:

If $\text{DD}\_t > 20\%$, halt trading (circuit breaker).

Trailing stop-loss:

If $P\_t < \text{Stop}\_t$, exit position. Common $\delta = 0.02$ (2% trailing stop).

Backtesting Infrastructure

Goal: Estimate strategy performance on historical data to gauge out-of-sample profitability.

Walk-Forward Analysis

Expanding window:

Train: [2015-01-01, 2016-12-31] → Test: [2017-01-01, 2017-12-31]
Train: [2015-01-01, 2017-12-31] → Test: [2018-01-01, 2018-12-31]
Train: [2015-01-01, 2018-12-31] → Test: [2019-01-01, 2019-12-31]
...

Rolling window (fixed size):

Train: [2015-01-01, 2016-12-31] → Test: [2017-01-01, 2017-12-31]
Train: [2016-01-01, 2017-12-31] → Test: [2018-01-01, 2018-12-31]
Train: [2017-01-01, 2018-12-31] → Test: [2019-01-01, 2019-12-31]
...

Rolling window adapts faster to regime changes.

Avoiding Look-Ahead Bias

Critical mistake: Using future information in features.

Example of look-ahead bias:

# WRONG: Normalizing with entire dataset statistics
df['normalized'] = (df['price'] - df['price'].mean()) / df['price'].std()

# CORRECT: Normalizing with past data only
df['normalized'] = df['price'].rolling(window=252).apply(
    lambda x: (x.iloc[-1] - x.mean()) / x.std()
)

Transaction Costs

Slippage: Difference between expected and actual execution price.

Model:

where ADV = Average Daily Volume.

Realistic cost assumptions (US equities):

• Commission: $0.001/share (Interactive Brokers)
• Bid-ask spread: 0.01-0.10% (liquid stocks)
• Slippage: 0.01-0.05% per trade
• Total round-trip cost: 0.05-0.20%

High-frequency strategies with 10+ trades/day need to generate 0.5%+ daily alpha just to break even on costs.

Performance Metrics

Sharpe Ratio:

Good strategies achieve Sharpe > 1.5 (institutional standard).

Sortino Ratio (penalizes only downside volatility):

Maximum Drawdown:

Calmar Ratio (return / max drawdown):

Renaissance Medallion achieved Sharpe > 3, Calmar > 5 over decades—far exceeding typical hedge fund performance (Sharpe ~1).

Production Deployment

Real-Time Execution Pipeline

class TradingAgent:
    def __init__(self, model, risk_manager, broker):
        self.model = model
        self.risk_manager = risk_manager
        self.broker = broker
        self.positions = {}

    async def on_market_data(self, tick: Tick):
        # 1. Update features
        features = self.feature_engineer.extract(tick)

        # 2. Predict
        prediction = self.model.predict(features)
        signal_strength = prediction['probability'] - 0.5  # [-0.5, 0.5]

        # 3. Risk check
        position_size = self.risk_manager.calculate_size(
            symbol=tick.symbol,
            signal_strength=signal_strength,
            current_position=self.positions.get(tick.symbol, 0)
        )

        # 4. Execute
        if abs(position_size) > self.min_position:
            order = self.create_order(tick.symbol, position_size)
            await self.broker.submit_order(order)
            self.positions[tick.symbol] = position_size

    def create_order(self, symbol: str, size: int):
        return {
            'symbol': symbol,
            'qty': abs(size),
            'side': 'buy' if size > 0 else 'sell',
            'type': 'limit',
            'limit_price': self.get_limit_price(symbol, size),
            'time_in_force': 'day'
        }

Model Versioning and A/B Testing

Problem: Deploying untested models risks capital loss.

Solution: Shadow mode → Canary deployment → Full rollout.

Shadow mode: Run new model alongside production, log predictions but don’t trade.

Canary deployment: Allocate 5% of capital to new model, 95% to baseline. Monitor for 2 weeks.

Metrics comparison:

If new model outperforms on all metrics with statistical significance, promote to production.

Circuit Breakers and Anomaly Detection

Automated shutoff triggers:

• Daily loss > 2%
• Sharpe ratio (rolling 30 days) < 0.5
• Single position loss > 5%
• Extreme volatility (VIX > 40)
• API errors (> 5% failed requests)

Implementation:

class CircuitBreaker:
    def __init__(self, max_daily_loss=0.02, max_position_loss=0.05):
        self.max_daily_loss = max_daily_loss
        self.max_position_loss = max_position_loss
        self.start_value = None
        self.tripped = False

    def check(self, current_value: float, positions: dict) -> bool:
        if self.start_value is None:
            self.start_value = current_value

        # Daily loss check
        daily_pnl = (current_value - self.start_value) / self.start_value
        if daily_pnl < -self.max_daily_loss:
            self.trip("Daily loss exceeded")
            return True

        # Position loss check
        for symbol, position in positions.items():
            if position['unrealized_pnl_pct'] < -self.max_position_loss:
                self.trip(f"Position loss on {symbol} exceeded")
                return True

        return False

    def trip(self, reason: str):
        self.tripped = True
        logger.critical(f"CIRCUIT BREAKER TRIPPED: {reason}")
        self.close_all_positions()
        self.send_alert()

Regulatory and Ethical Considerations

Financial AI operates under strict regulatory oversight.

Market Manipulation

Spoofing: Placing fake orders to manipulate prices, then canceling. Illegal under Dodd-Frank Act.

Wash trading: Self-trading to inflate volume. Illegal.

Pump-and-dump: Buying, hyping on social media, selling. Illegal securities fraud.

AI agents must avoid patterns that resemble manipulation, even if unintentional. Regulators use surveillance systems that flag suspicious order patterns.

Algorithmic Trading Regulations

SEC Rule 15c3-5 (Market Access Rule): Requires risk controls:

• Pre-trade capital checks
• Order size limits
• Erroneous order prevention

MiFID II (Europe): Algorithmic trading firms must:

• Register with regulators
• Maintain audit trails (6 years)
• Test algorithms before deployment
• Implement kill switches

Fairness and Systemic Risk

Flash crashes: Algorithmic feedback loops caused 2010 Flash Crash (S&P dropped 9% in minutes).

Responsibilities:

• Avoid overly aggressive strategies that destabilize markets
• Implement rate limits (don’t send 10,000 orders/second on small stocks)
• Monitor for unintended consequences (e.g., model exploits liquidity imbalances, draining market depth)

Quant fund failures:

• Long-Term Capital Management (1998): Over-leveraged, nearly collapsed financial system
• Knight Capital (2012): Software bug lost $440M in 45 minutes

These failures highlight the importance of rigorous testing, risk controls, and kill switches.

Conclusion

Building an AI agent for financial market estimation requires synthesizing disparate disciplines: machine learning, quantitative finance, distributed systems, and risk management. Unlike typical ML applications, financial agents operate in adversarial, non-stationary environments where errors have monetary consequences and signals decay as competitors discover them.

Key takeaways:

1. Alpha is fleeting: Strategies work until they’re crowded. Continuous research and adaptation are mandatory.
2. Risk management > prediction accuracy: Position sizing, stop-losses, and diversification matter more than model sophistication.
3. Transaction costs compound: High-frequency strategies need exceptional signal-to-noise to overcome fees and slippage.
4. Backtesting is hard: Look-ahead bias, survivor bias, and overfitting plague most strategies. Walk-forward analysis with realistic costs is essential.
5. Production requires discipline: Circuit breakers, A/B testing, and monitoring prevent catastrophic losses.

The most successful quantitative funds—Renaissance, Two Sigma, DE Shaw—combine cutting-edge ML with rigorous engineering, decades of proprietary data, and teams of PhDs. Retail traders can apply similar principles at smaller scale using cloud infrastructure (AWS, GCP), open-source ML libraries (PyTorch, scikit-learn), and low-cost brokers (Alpaca, Interactive Brokers).

The democratization of AI and financial data creates opportunities, but also intensifies competition. As markets become more efficient, finding alpha requires increasingly sophisticated models, alternative data sources, and creative signal combinations. The arms race continues.

References

1. Marcos López de Prado. Advances in Financial Machine Learning. Wiley, 2018.
2. Ernest P. Chan. Algorithmic Trading: Winning Strategies and Their Rationale. Wiley, 2013.
3. Rishi K. Narang. Inside the Black Box: The Simple Truth About Quantitative Trading. Wiley, 2009.
4. Stefan Jansen. Machine Learning for Algorithmic Trading, 2nd ed. Packt, 2020.
5. Bryan Lim et al. “Temporal Fusion Transformers for Interpretable Multi-horizon Time Series Forecasting.” arXiv:1912.09363, 2021.
6. Paul C. Tetlock. “Giving Content to Investor Sentiment: The Role of Media in the Stock Market.” Journal of Finance 62.3 (2007): 1139-1168.
7. Rama Cont et al. “The Price Impact of Order Book Events.” Journal of Financial Econometrics 12.1 (2014): 47-88.
8. Narasimhan Jegadeesh and Sheridan Titman. “Returns to Buying Winners and Selling Losers: Implications for Stock Market Efficiency.” Journal of Finance 48.1 (1993): 65-91.
9. Fischer Black and Robert Litterman. “Global Portfolio Optimization.” Financial Analysts Journal 48.5 (1992): 28-43.
10. Gregory Zuckerman. The Man Who Solved the Market: How Jim Simons Launched the Quant Revolution. Portfolio, 2019.