TradingAgents

Orchestrates a five-phase sequential workflow (Analyst Team → Research Team → Trader Agent → Risk Management Team → Portfolio Manager) using LangGraph state machines, where each phase processes market data and prior outputs to generate progressively refined trading decisions. Implements state propagation across agent boundaries with explicit message passing and reflection loops, enabling structured reasoning chains where later agents build on earlier analysis.

Provides a unified client factory that abstracts six LLM providers (OpenAI, Anthropic, Google, xAI, OpenRouter, Ollama) behind a single interface, enabling runtime provider switching without code changes. Implements provider detection via configuration, model instantiation with provider-specific parameters, and fallback logic for API failures, allowing agents to use different models for different reasoning tasks (deep vs quick thinking).

Implements a trader agent that synthesizes analyst reports and debate outcomes into a unified trading decision with specific execution parameters: action (buy/sell/hold), confidence score (0-1), position size (percentage of portfolio), entry price, stop-loss, and take-profit levels. Uses deep thinking LLM to reason about position sizing based on confidence, volatility, and portfolio constraints. Outputs are structured for downstream execution systems.

Provides a framework for creating custom agents by extending base agent classes and implementing agent-specific logic (data gathering, reasoning, output formatting). Agents are registered in the LangGraph graph and receive state as input, producing outputs that are added to shared state. Supports agent tools (data fetching, calculations) that agents can invoke during reasoning. Enables teams to add domain-specific agents (e.g., ESG analyst, options analyst) without modifying core framework.

Implements a dual-model strategy where complex reasoning tasks (analyst reports, research debate, risk assessment) use deep_think_llm (expensive, high-quality models like Claude 3 Opus), while rapid synthesis tasks use quick_think_llm (fast, cost-effective models like GPT-4o mini). Configuration allows per-task model assignment without code changes. Reduces overall latency and cost compared to using expensive models for all tasks, while maintaining reasoning quality where it matters most.

Implements a vendor router (route_to_vendor) that abstracts market data acquisition across multiple sources (Yahoo Finance, Alpha Vantage, local cache) with automatic fallback logic. When primary vendor fails or rate-limits, the system transparently retries with secondary vendors, and caches results locally to reduce API calls and improve latency. Technical indicators (RSI, MACD, Bollinger Bands) are computed on-demand and cached per ticker.

Implements a two-researcher debate phase where one researcher generates bullish arguments and another generates bearish arguments for a given ticker, using structured prompts that enforce opposing viewpoints. A trader agent then synthesizes both perspectives into a unified trading decision (buy/sell/hold with confidence score and position sizing), ensuring the final decision accounts for both upside and downside risks rather than relying on single-perspective analysis.

Implements a three-agent risk management team (Value-at-Risk agent, Correlation agent, Liquidity agent) that independently evaluates proposed trades against portfolio-level constraints, followed by a Portfolio Manager agent that approves or rejects trades based on aggregated risk assessments. Each risk agent uses deep thinking to analyze different risk dimensions, and the Portfolio Manager synthesizes their outputs with portfolio state to make final approval decisions.

Provides an interactive command-line interface (cli/main.py) using questionary prompts for user configuration, Rich library for real-time formatted output, and a message buffer system that displays agent reasoning, debate transcripts, and risk assessments as they execute. Supports interactive configuration of LLM providers, model names, risk parameters, and data sources, with validation and defaults for each parameter.

Exposes a programmatic Python API (TradingAgentsGraph.propagate()) that allows developers to invoke the trading pipeline from code, passing configuration and ticker symbols, and receiving structured outputs (trading decisions, reasoning traces, risk assessments). The API manages state propagation across agent phases using LangGraph state machines, handling message passing, reflection updates, and phase transitions automatically without requiring manual orchestration.

Implements a configuration system (DEFAULT_CONFIG, config files, environment variables) that centralizes LLM provider selection, model names, risk parameters, and data source configuration. Supports runtime configuration via CLI prompts or programmatic API, with validation and defaults for each parameter. Enables per-agent model assignment (deep_think_llm for complex reasoning, quick_think_llm for rapid tasks) without code changes.

Implements LangGraph-based state management that tracks agent outputs, reasoning traces, and portfolio state across pipeline phases. Includes reflection loops where agents review prior outputs and update memory (e.g., analyst agents reflect on their own reports, risk agents update memory with assessment results). State is propagated between phases via explicit message passing, with each phase reading prior outputs and adding new information to shared state.

Implements four parallel analyst agents (Fundamental, Technical, Sentiment, Macro) that independently analyze a ticker from different perspectives using deep thinking LLM. Each analyst generates a structured report with key findings, signals, and confidence scores. Reports are collected and passed to the research team phase, enabling multi-perspective analysis without sequential bottlenecks. Analysts use market data (OHLCV, technical indicators) and can invoke data tools to fetch additional information.