# Trading Agent Service - Architecture Diagrams **Version**: 1.0 **Date**: 2025-10-16 **Companion to**: TRADING_AGENT_SERVICE_DESIGN.md --- ## System Architecture Overview ``` ┌────────────────────────────────────────────────────────────────────────┐ │ Foxhunt HFT System │ └────────────────────────────────────────────────────────────────────────┘ ┌─────────────┐ │ TLI CLI │ (Terminal User Interface) └──────┬──────┘ │ gRPC (JWT Auth) ▼ ┌─────────────────────────────────────────────────────────────────────┐ │ API Gateway (50051) │ │ - JWT + MFA Authentication │ │ - Rate Limiting │ │ - Audit Logging │ │ - Service Proxy/Router │ └───┬────────────┬─────────────┬─────────────┬────────────────────────┘ │ │ │ │ │ │ │ │ ▼ ▼ ▼ ▼ ┌───────────┐ ┌──────────┐ ┌──────────┐ ┌────────────────────┐ │ Trading │ │ Risk │ │ Config │ │ Trading Agent │ ← NEW │ Service │ │ Service │ │ Service │ │ Service (50055) │ │ (50052) │ │ │ │ │ │ │ └─────┬─────┘ └──────────┘ └──────────┘ └────────┬───────────┘ │ │ │ ┌──────────────────────────────────────────┘ │ │ gRPC: SubmitMLOrder(), GetPositions() │ │ ▼ ▼ ┌────────────────────────────────────────────────────────────────┐ │ Trading Service (50052) │ │ - Order Execution │ │ - Position Management │ │ - Market Data Streaming │ │ - Execution Quality Monitoring │ └────────────────────────────────────────────────────────────────┘ │ │ │ │ ┌─────────────────┘ └─────────────────┐ │ │ ▼ ▼ ┌────────────────────┐ ┌─────────────────────┐ │ Backtesting Service│ │ ML Training Service│ │ (50053) │ │ (50054) │ │ │ │ │ │ - Simulates Agent │◄───────gRPC────────────────│ - Model Training │ │ - Historical Tests │ GetMLPredictions() │ - Predictions │ └────────────────────┘ └─────────────────────┘ │ │ ┌──────────────────────────────────────────────────────┘ │ ▼ ┌────────────────────────────────────────────────────────────────┐ │ Data Layer │ │ ┌────────────┐ ┌────────────┐ ┌────────────┐ │ │ │ PostgreSQL │ │ Redis │ │ MinIO │ │ │ │ (5432) │ │ (6379) │ │ (9000) │ │ │ │ │ │ │ │ │ │ │ │ - Trades │ │ - Cache │ │ - Models │ │ │ │ - Positions│ │ - Sessions │ │ - Checkpts │ │ │ │ - Universe │ │ - Quotes │ │ - Data │ │ │ │ - Agent │ │ │ │ │ │ │ └────────────┘ └────────────┘ └────────────┘ │ └────────────────────────────────────────────────────────────────┘ ``` --- ## Trading Agent Service - Internal Architecture ``` ┌────────────────────────────────────────────────────────────────────────┐ │ Trading Agent Service (50055) │ ├────────────────────────────────────────────────────────────────────────┤ │ │ │ ┌──────────────────────────────────────────────────────────────┐ │ │ │ gRPC Server Layer │ │ │ │ - Health Check │ │ │ │ - Universe Selection APIs │ │ │ │ - Asset Selection APIs │ │ │ │ - Portfolio Allocation APIs │ │ │ │ - Order Generation APIs │ │ │ │ - Strategy Coordination APIs │ │ │ │ - Monitoring APIs │ │ │ └────────────────┬─────────────────────────────────────────────┘ │ │ │ │ │ ┌────────────────▼─────────────────────────────────────────────┐ │ │ │ Business Logic Layer │ │ │ │ │ │ │ │ ┌─────────────────┐ ┌──────────────────┐ │ │ │ │ │ Universe Manager│ │ Asset Selector │ │ │ │ │ │ │ │ │ │ │ │ │ │ - Liquidity │ │ - ML Scoring │ │ │ │ │ │ - Volatility │ │ - Factor Models │ │ │ │ │ │ - ML Signals │ │ - Composite │ │ │ │ │ └─────────────────┘ └──────────────────┘ │ │ │ │ │ │ │ │ ┌─────────────────┐ ┌──────────────────┐ │ │ │ │ │ Portfolio │ │ Order Generator │ │ │ │ │ │ Allocator │ │ │ │ │ │ │ │ │ │ - Market Orders │ │ │ │ │ │ - Risk Parity │ │ - Limit Orders │ │ │ │ │ │ - Mean-Variance │ │ - Slippage │ │ │ │ │ │ - ML Optimized │ │ - Price Offsets │ │ │ │ │ └─────────────────┘ └──────────────────┘ │ │ │ │ │ │ │ │ ┌─────────────────┐ ┌──────────────────┐ │ │ │ │ │ Strategy │ │ Risk Engine │ │ │ │ │ │ Coordinator │ │ │ │ │ │ │ │ │ │ - Position Limits│ │ │ │ │ │ - Registration │ │ - VaR │ │ │ │ │ │ - Execution │ │ - Leverage │ │ │ │ │ │ - Performance │ │ - Constraints │ │ │ │ │ └─────────────────┘ └──────────────────┘ │ │ │ │ │ │ │ └────────────────┬─────────────────────────────────────────────┘ │ │ │ │ │ ┌────────────────▼─────────────────────────────────────────────┐ │ │ │ Integration Layer │ │ │ │ │ │ │ │ ┌──────────────────┐ ┌──────────────────┐ │ │ │ │ │ Trading Service │ │ ML Training │ │ │ │ │ │ Client │ │ Service Client │ │ │ │ │ │ │ │ │ │ │ │ │ │ - SubmitMLOrder │ │ - Get Predictions│ │ │ │ │ │ - GetPositions │ │ - Get Performance│ │ │ │ │ └──────────────────┘ └──────────────────┘ │ │ │ │ │ │ │ └────────────────┬─────────────────────────────────────────────┘ │ │ │ │ │ ┌────────────────▼─────────────────────────────────────────────┐ │ │ │ Data Access Layer │ │ │ │ │ │ │ │ ┌──────────────────────────────────────────────────────┐ │ │ │ │ │ Repository Pattern │ │ │ │ │ │ │ │ │ │ │ │ - UniverseRepository │ │ │ │ │ │ - AssetSelectionRepository │ │ │ │ │ │ - AllocationRepository │ │ │ │ │ │ - OrderBatchRepository │ │ │ │ │ │ - StrategyRepository │ │ │ │ │ │ - ActivityLogRepository │ │ │ │ │ │ - PerformanceMetricsRepository │ │ │ │ │ └──────────────────────────────────────────────────────┘ │ │ │ │ │ │ │ └────────────────┬─────────────────────────────────────────────┘ │ │ │ │ │ ▼ │ │ PostgreSQL Database │ │ │ └────────────────────────────────────────────────────────────────────────┘ ``` --- ## Trading Decision Flow (End-to-End) ``` ┌─────────────────────────────────────────────────────────────────────────┐ │ Trading Agent Service - Decision Pipeline │ └─────────────────────────────────────────────────────────────────────────┘ Step 1: Universe Selection (Every 1 hour) ┌─────────────────────────────────────────────────────────────────────┐ │ Input: UniverseCriteria │ │ - min_liquidity: 0.7 │ │ - max_volatility: 0.5 │ │ - allowed_types: [FUTURES] │ │ - min_ml_confidence: 0.6 │ └───────────────────────────┬─────────────────────────────────────────┘ │ ▼ ┌───────────────────────────────────┐ │ Query Market Data │ │ - Get all available instruments │ │ - Calculate liquidity scores │ │ - Calculate volatility metrics │ └───────────────┬───────────────────┘ │ ▼ ┌───────────────────────────────────┐ │ Query ML Training Service │ │ - Get ML signal strengths │ │ - Get model confidence scores │ └───────────────┬───────────────────┘ │ ▼ ┌───────────────────────────────────┐ │ Apply Selection Criteria │ │ - Filter by liquidity ≥ 0.7 │ │ - Filter by volatility ≤ 0.5 │ │ - Filter by ML confidence ≥ 0.6 │ └───────────────┬───────────────────┘ │ ▼ ┌───────────────────────────────────┐ │ Output: Universe │ │ [ES.FUT, NQ.FUT, ZN.FUT, 6E.FUT] │ │ Store in database │ └───────────────┬───────────────────┘ │ │ Step 2: Asset Selection (Every 5 minutes) │ ▼ ┌─────────────────────────────────────────────────────────────────────┐ │ Input: Universe + AssetSelectionCriteria │ │ - universe_id: "univ-abc123" │ │ - max_assets: 3 │ │ - min_ml_signal_strength: 0.7 │ └───────────────────────────┬─────────────────────────────────────────┘ │ ▼ ┌───────────────────────────────────┐ │ For Each Instrument in Universe │ │ - Query ML predictions │ │ - Calculate momentum score │ │ - Calculate value score │ │ - Calculate quality score │ └───────────────┬───────────────────┘ │ ▼ ┌───────────────────────────────────┐ │ Compute Composite Scores │ │ composite = w1*ml + w2*momentum │ │ + w3*value + w4*quality│ └───────────────┬───────────────────┘ │ ▼ ┌───────────────────────────────────┐ │ Rank and Select Top N │ │ 1. ES.FUT (score: 0.85) │ │ 2. NQ.FUT (score: 0.78) │ │ 3. ZN.FUT (score: 0.72) │ └───────────────┬───────────────────┘ │ ▼ ┌───────────────────────────────────┐ │ Output: Selected Assets │ │ [ES.FUT, NQ.FUT, ZN.FUT] │ │ Store in database │ └───────────────┬───────────────────┘ │ │ Step 3: Portfolio Allocation (Every 5 minutes) │ ▼ ┌─────────────────────────────────────────────────────────────────────┐ │ Input: Selected Assets + AllocationStrategy + RiskConstraints │ │ - assets: [ES.FUT, NQ.FUT, ZN.FUT] │ │ - strategy: RISK_PARITY │ │ - total_capital: $1,000,000 │ │ - risk_constraints: {max_position: 20%, max_leverage: 2.0} │ └───────────────────────────┬─────────────────────────────────────────┘ │ ▼ ┌───────────────────────────────────┐ │ Get Current Positions │ │ Query Trading Service │ │ - ES.FUT: 10 contracts ($50K) │ │ - NQ.FUT: 0 contracts ($0) │ │ - ZN.FUT: -5 contracts (-$25K) │ └───────────────┬───────────────────┘ │ ▼ ┌───────────────────────────────────┐ │ Calculate Target Weights │ │ (Risk Parity Algorithm) │ │ - ES.FUT: 35% ($350K, 70 contr) │ │ - NQ.FUT: 40% ($400K, 80 contr) │ │ - ZN.FUT: 25% ($250K, 50 contr) │ └───────────────┬───────────────────┘ │ ▼ ┌───────────────────────────────────┐ │ Apply Risk Constraints │ │ - Check position limits │ │ - Check leverage │ │ - Check VaR │ │ - Adjust if needed │ └───────────────┬───────────────────┘ │ ▼ ┌───────────────────────────────────┐ │ Output: Portfolio Allocation │ │ ES.FUT: 35% (Δ+60 contracts) │ │ NQ.FUT: 40% (Δ+80 contracts) │ │ ZN.FUT: 25% (Δ+55 contracts) │ │ Store in database │ └───────────────┬───────────────────┘ │ │ Step 4: Order Generation (Triggered after allocation) │ ▼ ┌─────────────────────────────────────────────────────────────────────┐ │ Input: Allocation + MLSignals + OrderGenerationStrategy │ │ - allocation_id: "alloc-xyz789" │ │ - ml_signals: [ES: BUY(0.8), NQ: BUY(0.75), ZN: BUY(0.7)] │ │ - strategy: ADAPTIVE │ └───────────────────────────┬─────────────────────────────────────────┘ │ ▼ ┌───────────────────────────────────┐ │ For Each Asset in Allocation │ │ - Calculate delta from current │ │ - Determine order side │ │ - Choose order type │ │ - Set price (if limit order) │ └───────────────┬───────────────────┘ │ ▼ ┌───────────────────────────────────┐ │ Generate Orders │ │ 1. BUY ES.FUT 60 @ MARKET │ │ 2. BUY NQ.FUT 80 @ LIMIT $15200 │ │ 3. BUY ZN.FUT 55 @ MARKET │ └───────────────┬───────────────────┘ │ ▼ ┌───────────────────────────────────┐ │ Output: Generated Orders │ │ order_batch_id: "batch-123" │ │ Store in database │ └───────────────┬───────────────────┘ │ │ Step 5: Order Submission (Immediately after generation) │ ▼ ┌─────────────────────────────────────────────────────────────────────┐ │ Input: Order Batch │ │ - order_batch_id: "batch-123" │ │ - orders: [ES BUY 60, NQ BUY 80, ZN BUY 55] │ └───────────────────────────┬─────────────────────────────────────────┘ │ ▼ ┌───────────────────────────────────┐ │ For Each Order │ │ Call Trading Service │ │ SubmitMLOrder(symbol, features) │ └───────────────┬───────────────────┘ │ ▼ ┌───────────────────────────────────┐ │ Trading Service Response │ │ 1. ES: order_id=o1, ACCEPTED │ │ 2. NQ: order_id=o2, ACCEPTED │ │ 3. ZN: order_id=o3, ACCEPTED │ └───────────────┬───────────────────┘ │ ▼ ┌───────────────────────────────────┐ │ Log Submission Results │ │ acceptance_rate: 100% │ │ Store in database │ └───────────────┬───────────────────┘ │ ▼ ┌───────────────────────────────────┐ │ Monitor Execution │ │ StreamAgentActivity() emits │ │ real-time order fill events │ └───────────────────────────────────┘ ``` --- ## Strategy Coordination Flow ``` ┌─────────────────────────────────────────────────────────────────────────┐ │ Strategy Coordination System │ └─────────────────────────────────────────────────────────────────────────┘ Step 1: Strategy Registration ┌────────────────────────────────────────────┐ │ User: tli agent strategy register │ │ --name "ml_ensemble_v1" │ │ --type ML_ENSEMBLE │ │ --config config.yaml │ └───────────────────┬────────────────────────┘ │ ▼ ┌───────────────────────────┐ │ API Gateway │ │ - Authenticate │ │ - Rate Limit │ └───────────┬───────────────┘ │ ▼ ┌───────────────────────────┐ │ Trading Agent Service │ │ RegisterStrategy() │ │ - Validate config │ │ - Store in database │ │ - Generate strategy_id │ └───────────┬───────────────┘ │ ▼ ┌───────────────────────────┐ │ Response │ │ strategy_id: "strat-abc" │ │ status: ENABLED │ └───────────────────────────┘ Step 2: Strategy Execution (Periodic Scheduler) ┌────────────────────────────────────────────┐ │ Scheduler Tick (Every 5 minutes) │ └───────────────────┬────────────────────────┘ │ ▼ ┌───────────────────────────┐ │ Load Active Strategies │ │ Query from database │ │ WHERE status = 'ENABLED' │ └───────────┬───────────────┘ │ ▼ ┌───────────────────────────────────────────────────────────────────┐ │ Strategies: │ │ 1. ml_ensemble_v1 (ML_ENSEMBLE) ENABLED │ │ 2. mean_reversion_v2 (MEAN_REVERSION) DISABLED ← Skip │ │ 3. momentum_v1 (MOMENTUM) ENABLED │ └───────────────────┬───────────────────────────────────────────────┘ │ ▼ ┌───────────────────────────┐ │ Execute ml_ensemble_v1 │ │ - Run universe selection │ │ - Run asset selection │ │ - Generate allocation │ │ - Generate orders │ │ - Submit orders │ └───────────┬───────────────┘ │ ▼ ┌───────────────────────────┐ │ Track Performance │ │ - Log execution results │ │ - Update strategy metrics │ │ - Calculate Sharpe ratio │ └───────────┬───────────────┘ │ ▼ ┌───────────────────────────┐ │ Execute momentum_v1 │ │ (Same flow as above) │ └───────────────────────────┘ Step 3: Strategy Performance Monitoring ┌────────────────────────────────────────────┐ │ User: tli agent performance --window 24h │ └───────────────────┬────────────────────────┘ │ ▼ ┌───────────────────────────┐ │ Trading Agent Service │ │ GetAgentPerformance() │ │ - Query metrics from DB │ │ - Aggregate per strategy │ └───────────┬───────────────┘ │ ▼ ┌───────────────────────────────────────────────────────────────────┐ │ Response: │ │ │ │ Overall Performance: │ │ - Total PnL: $12,500 │ │ - Sharpe Ratio: 1.8 │ │ - Win Rate: 65% │ │ - Total Trades: 247 │ │ │ │ Strategy Breakdown: │ │ 1. ml_ensemble_v1: │ │ - PnL: $8,200 │ │ - Sharpe: 2.1 │ │ - Win Rate: 68% │ │ - Trades: 152 │ │ │ │ 2. momentum_v1: │ │ - PnL: $4,300 │ │ - Sharpe: 1.4 │ │ - Win Rate: 61% │ │ - Trades: 95 │ └────────────────────────────────────────────────────────────────────┘ ``` --- ## Integration Sequence Diagrams ### Trading Agent → Trading Service Integration ``` Trading Agent Trading Service │ │ │ 1. Get Current Positions │ │─────────GetPositions(account_id)────────────────►│ │ │ │◄─────────Positions(ES: 10, NQ: 0)───────────────│ │ │ │ 2. Generate Orders (internal logic) │ │ [ES: BUY 60, NQ: BUY 80] │ │ │ │ 3. Submit Orders │ │─────────SubmitMLOrder(ES.FUT, features)─────────►│ │ │ │ (Execute) │ │◄─────────OrderResponse(order_id=o1)─────────────│ │ │ │─────────SubmitMLOrder(NQ.FUT, features)─────────►│ │ │ │◄─────────OrderResponse(order_id=o2)─────────────│ │ │ │ 4. Stream Order Updates (optional) │ │─────────StreamOrders(account_id)────────────────►│ │ │ │◄─────────OrderEvent(o1, FILLED)─────────────────│ │◄─────────OrderEvent(o2, FILLED)─────────────────│ │ │ │ 5. Get Updated Positions │ │─────────GetPositions(account_id)────────────────►│ │ │ │◄─────────Positions(ES: 70, NQ: 80)──────────────│ │ │ ``` ### Trading Agent → ML Training Service Integration ``` Trading Agent ML Training Service │ │ │ 1. Get ML Predictions for Asset Selection │ │─────────GetMLPredictions(symbols=[ES,NQ,ZN])────►│ │ │ │ (Query Models)│ │◄─────────Predictions(ES:0.85, NQ:0.78, ZN:0.72)─│ │ │ │ 2. Calculate Composite Scores │ │ composite = w*ml_score + (1-w)*other_factors │ │ │ │ 3. Get Model Performance for Weighting │ │─────────GetMLPerformance(window=24h)────────────►│ │ │ │◄─────────Performance(DQN:85%, MAMBA2:78%,...)───│ │ │ │ 4. Adjust Weights Based on Performance │ │ (DQN gets higher weight due to better perf) │ │ │ ``` --- ## Database Schema Diagram ``` ┌──────────────────────────────────────────────────────────────────────┐ │ Trading Agent Database Tables │ └──────────────────────────────────────────────────────────────────────┘ ┌─────────────────────────┐ │ trading_universes │ │─────────────────────────│ │ id UUID │◄─────────┐ │ universe_id TEXT │ │ │ criteria JSONB │ │ │ instruments JSONB │ │ FK │ metrics JSONB │ │ │ created_at TIMESTAMPTZ │ │ │ updated_at TIMESTAMPTZ │ │ └─────────────────────────┘ │ │ ┌─────────────────────────┐ │ │ asset_selections │ │ │─────────────────────────│ │ │ id UUID │ │ │ universe_id TEXT │──────────┘ │ criteria JSONB │ │ asset_scores JSONB │ │ metrics JSONB │ │ selected_at TIMESTAMPTZ │ └─────────────────────────┘ │ │ FK ▼ ┌─────────────────────────┐ │ portfolio_allocations │ │─────────────────────────│ │ id UUID │◄─────────┐ │ allocation_id TEXT │ │ │ strategy JSONB │ │ │ risk_constraints JSONB │ │ FK │ allocations JSONB │ │ │ metrics JSONB │ │ │ total_capital NUMERIC │ │ │ created_at TIMESTAMPTZ │ │ └─────────────────────────┘ │ │ ┌─────────────────────────┐ │ │ order_batches │ │ │─────────────────────────│ │ │ id UUID │ │ │ order_batch_id TEXT │ │ │ allocation_id TEXT │──────────┘ │ orders JSONB │ │ metrics JSONB │ │ submission_results JSONB│ │ created_at TIMESTAMPTZ │ │ submitted_at TIMESTAMPTZ│ └─────────────────────────┘ ┌─────────────────────────┐ │ agent_strategies │ │─────────────────────────│ │ id UUID │ │ strategy_id TEXT │ │ strategy_name TEXT │ │ strategy_type TEXT │ │ status TEXT │ │ config JSONB │ │ performance JSONB │ │ created_at TIMESTAMPTZ │ │ updated_at TIMESTAMPTZ │ └─────────────────────────┘ ┌─────────────────────────┐ │ agent_activity_log │ │─────────────────────────│ │ id BIGSERIAL│ │ activity_type TEXT │ │ event_data JSONB │ │ timestamp TIMESTAMPTZ │ └─────────────────────────┘ ┌─────────────────────────┐ │ agent_performance_metrics│ │─────────────────────────│ │ id BIGSERIAL│ │ metrics JSONB │ │ period_start TIMESTAMPTZ│ │ period_end TIMESTAMPTZ│ │ recorded_at TIMESTAMPTZ│ └─────────────────────────┘ ``` --- ## Deployment Architecture ``` ┌────────────────────────────────────────────────────────────────────┐ │ Docker Compose Deployment │ └────────────────────────────────────────────────────────────────────┘ ┌─────────────────┐ │ Load Balancer │ │ (Optional) │ └────────┬────────┘ │ ┌───────────────────┴───────────────────┐ │ │ ┌───────▼──────┐ ┌────────▼───────┐ │ API Gateway │ │ API Gateway │ │ (50051) │ │ (50051) │ │ Instance 1 │ │ Instance 2 │ └───────┬──────┘ └────────┬───────┘ │ │ └───────────────────┬───────────────────┘ │ ┌───────────────────────────────┴───────────────────────────────┐ │ │ ┌───▼────────────┐ ┌──────────────┐ ┌──────────────┐ ┌────────▼────────┐ │ Trading Agent │ │ Trading │ │ Backtesting │ │ ML Training │ │ Service │ │ Service │ │ Service │ │ Service │ │ (50055) │ │ (50052) │ │ (50053) │ │ (50054) │ └───┬────────────┘ └──────┬───────┘ └──────────────┘ └────────┬────────┘ │ │ │ └──────────────────────┴───────────────────────────────────────┘ │ ┌────────────────┴────────────────┐ │ │ ┌─────▼────────┐ ┌────────▼────────┐ │ PostgreSQL │ │ Redis │ │ (5432) │ │ (6379) │ │ │ │ │ │ - TimescaleDB│ │ - Cache │ │ - Replication│ │ - Pub/Sub │ └──────────────┘ └─────────────────┘ ┌──────────────────────────────────────────────┐ │ Monitoring & Observability │ │ │ │ ┌──────────┐ ┌──────────┐ ┌──────────┐ │ │ │Prometheus│ │ Grafana │ │ InfluxDB │ │ │ │ (9090) │ │ (3000) │ │ (8086) │ │ │ └──────────┘ └──────────┘ └──────────┘ │ └──────────────────────────────────────────────┘ ``` --- ## Monitoring Dashboard Layout ``` ┌────────────────────────────────────────────────────────────────────┐ │ Trading Agent Service - Grafana Dashboard │ ├────────────────────────────────────────────────────────────────────┤ │ │ │ ┌──────────────────────────────────────────────────────────────┐ │ │ │ Agent Health Overview │ │ │ │ ┌──────────┐ ┌──────────┐ ┌──────────┐ ┌──────────┐ │ │ │ │ │ Uptime │ │ API Req │ │ Errors │ │ Latency │ │ │ │ │ │ 99.95% │ │ 1.2K/min │ │ 3 │ │ 45ms P99 │ │ │ │ │ └──────────┘ └──────────┘ └──────────┘ └──────────┘ │ │ │ └──────────────────────────────────────────────────────────────┘ │ │ │ │ ┌──────────────────────────────────────────────────────────────┐ │ │ │ Universe & Selection │ │ │ │ │ │ │ │ Universe Size: 4 instruments │ │ │ │ ┌────────────────────────────────────────────────────┐ │ │ │ │ │ [ES.FUT] [NQ.FUT] [ZN.FUT] [6E.FUT] │ │ │ │ │ └────────────────────────────────────────────────────┘ │ │ │ │ │ │ │ │ Selected Assets: 3 │ │ │ │ ┌────────────────────────────────────────────────────┐ │ │ │ │ │ ES.FUT (score: 0.85) ████████████████████ │ │ │ │ │ │ NQ.FUT (score: 0.78) ████████████████ │ │ │ │ │ │ ZN.FUT (score: 0.72) ██████████████ │ │ │ │ │ └────────────────────────────────────────────────────┘ │ │ │ └──────────────────────────────────────────────────────────────┘ │ │ │ │ ┌──────────────────────────────────────────────────────────────┐ │ │ │ Portfolio Allocation │ │ │ │ │ │ │ │ Total Capital: $1,000,000 │ │ │ │ Deployed: $850,000 (85%) │ │ │ │ │ │ │ │ ┌────────────────────────────────────────────────────┐ │ │ │ │ │ ES.FUT 35% ████████████ │ │ │ │ │ │ NQ.FUT 40% ██████████████ │ │ │ │ │ │ ZN.FUT 25% ████████ │ │ │ │ │ │ Cash 15% ████ │ │ │ │ │ └────────────────────────────────────────────────────┘ │ │ │ │ │ │ │ │ Portfolio Volatility: 12.5% │ │ │ │ Portfolio Sharpe: 1.8 │ │ │ │ VaR (95%): 3.2% │ │ │ └──────────────────────────────────────────────────────────────┘ │ │ │ │ ┌──────────────────────────────────────────────────────────────┐ │ │ │ Order Generation & Execution │ │ │ │ │ │ │ │ Orders Generated (24h): 247 │ │ │ │ Orders Submitted: 245 │ │ │ │ Orders Accepted: 242 (98.8%) │ │ │ │ Orders Rejected: 3 (1.2%) │ │ │ │ │ │ │ │ ┌────────────────────────────────────────────────────┐ │ │ │ │ │ Orders per Hour (Last 24h) │ │ │ │ │ │ 30┤ │ │ │ │ │ │ │ ▄▄ │ │ │ │ │ │ 20┤ ▐██▌ ▄▄ │ │ │ │ │ │ │ ▐████▌ ▐██▌ │ │ │ │ │ │ 10┤ ▐██████▌▐████▌ │ │ │ │ │ │ │▄▄████████████████▄▄ │ │ │ │ │ │ 0└─────────────────────────────────► │ │ │ │ │ │ 0 4 8 12 16 20 24 (hours) │ │ │ │ │ └────────────────────────────────────────────────────┘ │ │ │ └──────────────────────────────────────────────────────────────┘ │ │ │ │ ┌──────────────────────────────────────────────────────────────┐ │ │ │ Strategy Performance │ │ │ │ │ │ │ │ Active Strategies: 2 │ │ │ │ │ │ │ │ Strategy PnL Sharpe Win Rate Trades │ │ │ │ ──────────────────────────────────────────────────────── │ │ │ │ ml_ensemble_v1 $8,200 2.1 68% 152 │ │ │ │ momentum_v1 $4,300 1.4 61% 95 │ │ │ │ ──────────────────────────────────────────────────────── │ │ │ │ Total $12,500 1.8 65% 247 │ │ │ └──────────────────────────────────────────────────────────────┘ │ │ │ └────────────────────────────────────────────────────────────────────┘ ``` --- ## Conclusion These architecture diagrams provide a visual reference for: 1. **System Integration**: How Trading Agent fits into the Foxhunt ecosystem 2. **Internal Architecture**: Component structure within Trading Agent Service 3. **Data Flow**: End-to-end decision pipeline from universe selection to order execution 4. **Strategy Coordination**: How multiple strategies are registered, executed, and monitored 5. **Service Integration**: Detailed interaction patterns between services 6. **Database Schema**: Data persistence and relationships 7. **Deployment**: Docker-based deployment architecture 8. **Monitoring**: Observability and dashboard layout **Companion Document**: `TRADING_AGENT_SERVICE_DESIGN.md` --- **Document Status**: ✅ **READY FOR REFERENCE** **Purpose**: Visual supplement to design document **Usage**: Reference during implementation and code reviews