Full Transparency
Under the hood
No black boxes. Tradewink runs concurrent research loops that monitor markets, score setups, and attach written reasoning and risk context — so you can review ideas before you decide. Explore our AI trading research hub to see how we compare platforms and approaches. Public subscriptions are paper-only; separately approved private beta accounts may submit live broker orders. No broker is required to use signals.
System Architecture
From market data to a signal you can review
Data flows through analysis and risk context before a signal is published for review. Automated orders fill in a simulator or a paper/sandbox account. Outcomes from paper or historical review can inform model calibration. Public subscriptions are paper-only; separately approved private beta accounts may submit live broker orders.
Inputs
Data
Live market, filings, macro, and crypto providers. Dedicated options-flow vendors are not in the current stack.
- Polygon
- yfinance
- Alpaca
- Finnhub
- SEC EDGAR
- FRED
- CoinGecko
- Quiver
Analysis
AI research
Scoring and confidence context where enabled. It is not a live-conviction plan feature.
Guardrails
Risk context
Sizing suggestions for the reader, not broker instructions.
Output
Delivery
Signals, journal, and Paper Autopilot. Orders fill in a simulator or a paper/sandbox account. Public subscriptions are paper-only; separately approved private beta accounts may submit live broker orders.
Paper onlyLearning
Feedback
Paper and historical outcomes recalibrate the models.
Feedback loopClosed-trade outcomes update AI models and conviction — they do not change the data providers.
Discord
Slash commands, DMs, Cogs
Web Dashboard
Workspaces, real-time WebSocket
REST API
Scoped keys (Pro and Elite)
App
Composition root + core modules
Domain Services
Watchlist, Strategy, Portfolio
Clerk Auth
RS256 JWT, per-user scoping
Loop Groups
Concurrent, market-hours aware
Strategy + Options + Crypto
Stocks, options, futures, forex
Event Bus
Priority async queue + streams
Data Providers
Polygon, Finnhub, SEC EDGAR, FRED
Real-Time Streams
Alpaca, Polygon, Finnhub, OANDA
PostgreSQL + Redis
Dual DB, 5-layer cache
AI Modules
Routed LLMs, FinBERT, ML, RL
Multi-Agent Teams
Bull/Bear debate, consensus
Self-Improvement
Retrainer, prompt evolution, RAG
Risk Manager
Intraday margin, limits, circuit breaker
Broker Connections
Paper or sandbox accounts only
Per-User Keys
Fernet-encrypted, OAuth2
Concurrent Loops
Dozens of agent loops, running concurrently
Every loop adapts its speed to market conditions. Full speed during market hours, reduced cadence after hours, minimal overnight.
AutonomousAgent initialized — concurrent loops activeMarket Intelligence: Earnings / Insider / SEC / NewsReal-Time Monitoring: Momentum / Macro / Price Moves / NewsStrategy Engine: Scan / Update / Exit / Sell ConfidenceTrade Execution: Screen / Evaluate / Size / AI Score / ExecuteSelf-Improvement: ML Retrainer / Calibration / Prompt EvolutionPortfolio Health: Risk / Trim / Anomaly / Daily PlanningOptions Loops: Scan / Monitor / Wheel / Earnings / GreeksCrypto Loops: Momentum / BTC Dominance / Fear+Greed (24/7)+ futures, forex, and learning loops...All loops market-hours aware / adaptive cadence / self-improvingMarket Intelligence
Scans earnings calendars, insider transactions, SEC filings, and news events across watched tickers.
Real-Time Monitoring
Tracks price movements, volatility regimes, and market-moving news in real time through the event bus.
Strategy Engine
Generates buy/sell strategies via AI, monitors active positions, manages trailing stops, and rotates between factor exposures.
Trade Execution
Signal pipeline: screens candidates, evaluates with AI, attaches size context and risk notes, and publishes ideas for review. Orders run only in a simulator or a paper/sandbox account; Tradewink's public offering is paper trading only.
Self-Improvement
Reviews every trade outcome, retrains ML models, adjusts confidence scores, and A/B tests prompt variations so the system keeps adjusting over time.
Portfolio Health
Monitors portfolio balance, flags overweight positions, detects statistical anomalies, and generates daily trading plans.
Execution Pipeline
From scan to order decision
The day-trading system runs this 6-step pipeline every scan cycle, with safety gates, AI scoring, and risk checks at each step. Orders fill only in a simulator or a paper/sandbox account; Tradewink's public offering is paper trading only.
Pre-Scan Gates
- Consistency checker verifies cross-module state
- HMM regime detection on SPY proxy
- Intraday regime overlay (5-min efficiency ratio)
- Monk mode: skip quiet hours, regime transitions, pre-earnings
- Micro account auto-detection per user
Screen
- Default ticker universe + micro-account universe + Finviz dynamic sourcing
- Volume, ATR%, gap, RSI, relative volume scoring
- S&P 500 heatmap movers merged automatically
- Watchlist tickers prioritized with +15 point boost
Evaluate
- StrategyEngine + IntradayStrategyEngine analysis
- Momentum, mean-reversion, breakout, VWAP, ORB strategies
- Support/resistance integration (pivot, volume, SMA)
- Signal discretization (5-tier: Strong Buy to Strong Sell)
AI Score
- Single routed-model call per candidate (default, fast)
- Conviction 0-100: below the default floor of 60 is rejected; passing scores add a small capped boost
- Pro and Elite: 3-agent team review for top candidates scoring 55+
- Historical trade lessons fed into scoring context
Size & Execute
- Risk-based, ATR-based, half-Kelly (most conservative wins)
- Regime-adjusted sizing + cost-aware modeling
- Smart executor: VWAP/TWAP slicing for large orders
- Risk check, confirmation, broker submit, audit log
Monitor & Exit
- MFE/MAE tracking updated every tick
- Trailing stop with broker sync (cancel old, submit new)
- Regime-shift exit: AI debate on trending-to-choppy flip
- Max hold exit for flat positions (60 min default, configurable)
- Post-trade reflection via AI (lessons stored in DB)
Pipeline runs in both global broker mode (single scan for all) and per-user broker mode (individual scan/evaluate/execute per user).
Deep Dive
Trade loop internals
Every scan cycle runs 13 stages — from lock acquisition to post-trade reflection. Each stage has its own caching, error handling, and performance envelope.
Loop Entry & Lock
- Acquire distributed lock (TTL = scan_interval + 30s)
- Per-user iteration if user_ids present, else global mode
- Interval: config.strategy_scan_interval_secs
- Adaptive threshold adjusts confidence gate on accuracy history
Input
User IDs, config
Output
Lock acquired, user context
Circuit Breaker
- Check session.consecutive_losses >= max_consecutive_losses
- Pause trading for the day if threshold hit
- Configurable threshold (default: 5 consecutive losses)
- Resets on next trading day or manual override
Input
Session state
Output
Continue / pause decision
Regime Detection
- HMM-based (hmmlearn Baum-Welch or manual EM fallback)
- SPY daily closes, 1-year lookback, 10s timeout
- Output: RegimeState {bull, sideways, bear, unknown}
- Cached per-cycle (shared across users): TTL = max(scan_interval, 300s)
- Intraday overlay: 5-min SPY efficiency ratio (trending/choppy/neutral)
Input
SPY OHLCV (1Y daily + 1D 5-min)
Output
RegimeState + intraday regime
Monk Mode & Reconcile
- Quiet hours: skip first/last 15 min of market
- Regime transitions: reduce sizing (not block)
- Pre-earnings quiet period per ticker (applied later)
- Position reconciliation: sync with broker reality
- Handles bracket stop/target fills that happened externally
Input
Time, regime, broker positions
Output
Trade/skip decision, synced positions
Config Snapshot & Tier Detection
- Deep-copy config to ScanContext (prevents user leakage)
- Auto-detect micro account: equity < $1,000
- Micro mode adjusts: min_price=$2.50, max_price=$50, 3% risk
- Per-user pref auto-wiring via config_target fields
- Excluded tickers & sectors applied from user prefs
Input
Broker account, user prefs
Output
ScanContext (isolated config copy)
Candidate Screening
- Universe: default list + micro list + Finviz dynamic + watchlist
- Async concurrent quote + 1Y OHLCV fetch per ticker
- Scoring: RVOL(25) + ATR%(20) + gap(20) + RSI(15) + liquidity(10) + 52W(15)
- Filters: open positions, user exclusions, entry backoff, data integrity
- Watchlist boost: +15 pts
- Output: top-ranked ScreenerCandidates
Input
Ticker universe, quotes, OHLCV
Output
Ranked candidates with scores
Strategy Evaluation
- Max 8 concurrent evaluations (executor pool)
- Per candidate: 3-month daily OHLCV + TechnicalAnalyzer.compute()
- 5+ strategies: momentum, mean-reversion, breakout, VWAP, ORB, gap-fill
- Signal discretization: 5-tier (Strong Buy to Strong Sell)
- Strategy health check: degrade score if Sharpe < 0.25
- Signal quality classification (ML-based, 1-5 tier)
- Support/resistance: pivot levels, volume zones, round numbers, SMA
Input
Candidates + OHLCV + indicators
Output
StrategyReport per candidate
Composite Scoring
- composite = screener_score * (0.4 + 0.6 * adjusted strategy_score)
- Strategy score adjusted by intraday, support/resistance, news, and regime-alignment boosts minus late-entry penalties
- Per-strategy regime multiplier: 0.5x - 1.2x from each strategy's record in the current regime
- RL strategy selector weights by historical performance
- Gate: min_composite_score (40) + min_strategy_score (0.25)
Input
Screener + strategy scores
Output
DayTradeOpportunity list
AI Conviction Scoring
- Single routed-model call per candidate (batched, cost-optimized)
- 512 token max output per call
- TTLCache: 500 entries, 300s TTL, key=(ticker,direction,strategy)
- Context gathered in parallel (5s per-source timeout): earnings, VIX, IV rank, news
- Output: conviction 0-100, top 3 risks, reasoning
- Below 60 (default floor) is rejected; 80+ earns the capped maximum boost
Input
Trade setup + parallel context sources
Output
Conviction score + risks
3-Agent Team Review
- Pro and Elite plans: top candidates scoring 55+ (team_eval_min_score)
- 3 agents: Technical Analyst, Risk Analyst, Execution Strategist
- Strong agreement: +15% score | Moderate: +5% | Disagreement: hard veto
- 45s timeout per candidate
- Candidates below 55 use the single conviction call instead
Input
Opportunity + market context
Output
Consensus + confidence
Position Sizing
- 3 methods computed, most conservative wins:
- Risk-based: (equity * risk%) / (entry - stop), 1% risk per trade by default
- ATR-based: (equity * risk%) / (ATR * multiplier)
- Half-Kelly: kelly_f * 0.5 (optional, uses historical win rate)
- Caps: 8% of account and $15k per day-trade position (micro accounts: 3% risk, up to 25%, fractional shares)
- Slippage modeling: 5 bps + volume-dependent scaling
- Cost-aware: must profit 3x total costs to justify trade
- Correlation-aware: reduce if >0.7 correlated with holdings
Input
Opportunities + account equity
Output
PositionPlan per opportunity
Risk Check & Execution
- Risk gates: daily loss limit, position limits, broker margin, sector concentration
- Confidence gate: min 0.7 (adjustable per risk preset)
- Trade routing: stocks vs options vs crypto (IV rank, account tier)
- Smart executor: VWAP/TWAP slicing for orders > 1% ADV or > $10k
- Broker submission: submit_order() with audit log
- 5 risk presets: ultra-conservative to aggressive
Input
Sized opportunities
Output
ExecutionResult (order ID, fill)
Exit Monitoring Loop
- MFE/MAE tracking updated every tick for analytics
- Trailing stop: near-breakeven floor at 0.8 ATR, ratchet from 1 ATR, tighter trails at 3 and 5 ATR
- Broker stop sync: cancel old + submit new (race-guarded)
- 6 exit triggers: target, stop, strategy flip, regime shift, max hold, EOD
- Regime-shift exit: AI bull/bear debate on trending-to-choppy flip
- Post-trade reflection: AI generates lessons, stored in DB
- Exit backoff: 300-3000s cooldown after N consecutive failures
Input
Live quotes, position state
Output
Exit orders, closed trades, lessons
Common Questions
Architecture FAQ
How many AI loops does Tradewink run?+
The count changes as loops are added, retired, or turned off by feature flags, so this page shows the live number reported by the agent instead of a fixed figure. The loops are grouped by function — market intelligence, real-time monitoring, the strategy engine, trade execution, self-improvement, and portfolio health — and they are market-hours aware, monitoring markets, generating and updating strategies, and learning from outcomes. Orders go to a simulator or a paper/sandbox account. Public subscriptions are paper-only; separately approved private beta accounts may submit live broker orders.
Which brokers does Tradewink support?+
Tradewink's primary product is research and signals. Broker connections are optional and limited to paper or sandbox accounts for Paper Autopilot. Public subscriptions are paper-only; separately approved private beta accounts may submit live broker orders. Coverage varies by broker, and a broker connection is not required to build a watchlist or review signals.
What does 'self-improving' mean?+
A built-in learning loop reviews every trade outcome and feeds it back into the system. It tracks outcomes, retrains ML models, recalibrates confidence scores, and evolves prompts via A/B testing. After each closed position an AI reflection generates lessons that are stored in the database and used as context for future conviction scoring.
How does Tradewink decide whether to take a trade?+
Each candidate flows through a multi-stage day-trade pipeline: pre-scan gates (regime detection, circuit breaker, monk mode), candidate screening, strategy evaluation, composite scoring, AI conviction scoring, a 3-agent team review for top candidates on Pro and Elite plans, position sizing, and a final risk check before any order is submitted. Orders fill in a simulator or a paper/sandbox account. Public subscriptions are paper-only; separately approved private beta accounts may submit live broker orders. Conviction below the default floor of 60 disqualifies a candidate, and a set of hard and soft risk gates guards every order.
Is any of Tradewink written in Rust?+
The orchestration, AI, and broker layers are Python. A small number of measured hot paths are compiled Rust extensions loaded into the same process: the per-candidate support/resistance scan, the market-regime fit behind the pre-scan gate, and several indicator kernels. Each one is a like-for-like port that must return results identical to the Python implementation it replaces, is covered by parity tests that compare every field, and keeps the Python version in the tree behind an environment-variable rollback. Further kernels — the batched screener, the risk Monte Carlo, and the event runtime — are built and running in shadow mode, where they compute results and record parity without serving any trading decision.
What data feeds the architecture?+
The data layer pulls from market data, fundamentals, alternative-data, and streaming providers — including Polygon for bars, quotes, and options chains with yfinance as a fallback; Alpaca, Polygon, Finnhub, and OANDA streams for live events; SEC EDGAR and Finnhub for filings and insider activity; and Quiver Quantitative for congressional-trading context. Data is cached across five layers backed by PostgreSQL and Redis. The current list is on the data sources page.