TradingAgents en 2026: el framework multiagente de trading con LLM

1. Qué Es TradingAgents (y Por Qué Está en Tendencia)

TradingAgents es un framework open source en Python de Tauric Research que modela una firma de trading con agentes LLM: los analistas reúnen evidencia, los investigadores defienden ambos lados, un trader propone, un equipo de riesgo pone objeciones y un portfolio manager da el visto bueno. Está construido sobre LangGraph y acompaña al paper ‘TradingAgents: Multi-Agents LLM Financial Trading Framework’ de Yijia Xiao, Edward Sun, Di Luo y Wei Wang (arXiv 2412.20138), que arXiv registra como presentación oral en Multi-Agent AI in the Real World.

El impulso es real. El 26 de octubre de 2026 la página de trending semanal de GitHub mostraba 2.461 estrellas nuevas esta semana, y la API reportaba 115.476 estrellas y 22.204 forks. El ritmo de releases es igual de rápido: cinco versiones entre el 18 de septiembre y el 16 de octubre de 2026, de la v0.5.0 a la v0.7.0.

2. La Arquitectura en 4 Pasos

El diagrama del README se corresponde limpiamente con el cableado de tradingagents/graph/setup.py. Esto es lo que de verdad se ejecuta para un ticker en una fecha con los valores por defecto: una ronda de debate y una ronda de riesgo.

3. Quickstart: la v0.7.0 en Cinco Minutos

Estos son los comandos del README. Necesitás Python 3.11 o superior y una API key de un proveedor de LLM; por defecto se usa OpenAI.

Instalación con uv (o pip)

git clone https://github.com/TauricResearch/TradingAgents.git
cd TradingAgents

# Python 3.11+ is required; the README's examples use 3.13
uv venv --python 3.13
source .venv/bin/activate        # Windows (PowerShell): .venv\Scripts\activate
uv pip install .                 # or plain: pip install .

cp .env.example .env             # add OPENAI_API_KEY (the default provider)

Con los valores por defecto, OPENAI_API_KEY es la única clave que necesitás. ALPHA_VANTAGE_API_KEY, FRED_API_KEY (gratis) y TYPESAFE_API_KEY (filtra posts sociales con Jev) son opcionales. SEC EDGAR no pide clave, pero configurá SEC_EDGAR_USER_AGENT con tu nombre y tu email para que la SEC te contacte a vos y no al proyecto.

Correlo desde la CLI: interactivo, o sin preguntas para un job programado

# interactive: tickers, date, provider, research depth...
tradingagents

# headless (cron / Task Scheduler): flags + TRADINGAGENTS_* variables
export TRADINGAGENTS_LLM_PROVIDER=openai TRADINGAGENTS_QUICK_THINK_LLM=gpt-6-luna TRADINGAGENTS_DEEP_THINK_LLM=gpt-6-sol
export TRADINGAGENTS_OUTPUT_LANGUAGE=English TRADINGAGENTS_MAX_DEBATE_ROUNDS=1 TRADINGAGENTS_MAX_RISK_ROUNDS=1
tradingagents --ticker NVDA --date 2026-10-23 --analysts market,news,fundamentals --save --no-show

Cada flag se salta solo su propia pregunta. Sin terminal, una respuesta faltante detiene la corrida antes de empezar y nombra el flag o la variable que falta, así que es seguro programarlo.

O llamalo desde Python

from tradingagents.graph.trading_graph import TradingAgentsGraph
from tradingagents.default_config import DEFAULT_CONFIG

config = DEFAULT_CONFIG.copy()
config["llm_provider"] = "openai"
config["deep_think_llm"] = "gpt-6-sol"     # Research Manager + Portfolio Manager
config["quick_think_llm"] = "gpt-6-luna"   # analysts, researchers, trader, risk debaters
config["max_debate_rounds"] = 1
config["max_risk_discuss_rounds"] = 1

ta = TradingAgentsGraph(selected_analysts=("market", "social", "news", "fundamentals"), config=config)
state, rating = ta.propagate("NVDA", "2026-10-23")
print(rating)                    # Buy / Overweight / Hold / Underweight / Sell, or REVIEW
ta.save_reports(state, "NVDA")   # Markdown + complete_report.html under results_dir

propagate() devuelve el estado final y el rating. selected_analysts acepta market, social (la clave interna del analista de Sentimiento), news y fundamentals; sacá los que no necesites.

La evaluación propia del repo: una grilla ticker × fecha

# CLI
tradingagents backtest NVDA,AAPL --start 2026-06-01 --end 2026-08-01 --every 7

# Python
from tradingagents.backtest import iter_grid, run_backtest, summarize

dates = iter_grid("2026-06-01", "2026-08-01", every_n_days=7)
result = run_backtest(["NVDA", "AAPL"], dates, config, selected_analysts=["market", "news"])
print(summarize(result).render())

Cada celda se puntúa por el alpha realizado frente al benchmark regional del instrumento (SPY para tickers de EE.UU.) durante holding_period_days, 5 por defecto, agrupado por rating. Desde la v0.7.0 una decisión entra en el primer cierre posterior a su fecha, porque una corrida lee noticias publicadas después del cierre de ese día. Te dice si los ratings apuntan en la dirección correcta. No cobra costos, no dimensiona posiciones ni compone una cartera.

4. Proveedores de Datos y Tubería Point-in-Time

Buena parte de la ingeniería reciente fue a la parte poco vistosa que decide si una corrida histórica es honesta: qué puede ver cada agente en una fecha pasada. Los valores por defecto de default_config.py:

5. Qué Prueba el Backtest del Paper, y Qué No

El paper (v7) hace el backtest del 1 de enero al 29 de marzo de 2024. El texto menciona Apple, Nvidia, Microsoft, Meta y Google; la Tabla 1 reporta AAPL, GOOGL y AMZN frente a buy-and-hold y cuatro estrategias basadas en reglas (MACD, KDJ+RSI, ZMR y SMA). Los modelos base fueron gpt-4o-mini y gpt-4o como pensadores rápidos y o1-preview como pensador profundo. Estas son las filas de TradingAgents:

Hay que reconocer que los autores señalan la anomalía ellos mismos. Dicen que el Sharpe más alto “supera nuestro rango empírico esperado”, lo atribuyen a que hubo pocos retrocesos en ese período y explican que limitaron la prueba a tres meses porque cada predicción requería 11 llamadas al LLM y más de 20 llamadas a herramientas.

La fuga por la tubería de datos es la otra mitad. Desde el paper, los mantenedores publicaron correcciones de look-ahead en cuatro versiones: filtrado de Alpha Vantage (v0.3.1), macro de FRED, sentimiento social y memory log (v0.4.0), integridad point-in-time en todas las rutas con fecha (v0.5.0) y puntuación desde el primer cierre posterior a cada decisión (v0.7.0). Es lo que hacen los buenos mantenedores, y también muestra con qué facilidad un pipeline de LLM se filtra el futuro. El paper no me permite saber qué código produjo la Tabla 1, así que leo sus números como una demo, no como evidencia.

Para evaluarlo por tu cuenta, aplicá la misma disciplina que a cualquier estrategia: datos point-in-time, splits walk-forward, costos y un Sharpe deflactado que cuente cada configuración que probaste. Lo explico paso a paso en mi tutorial de validación de backtests, y cada cambio de prompt o de modelo cuenta como un trial nuevo.

6. Cuánto Cuesta una Corrida: Llamadas, Tokens, Dólares

El costo escala con las llamadas al LLM, y el grafo permite contarlas. Según graph/setup.py y conditional_logic.py, un ticker-día queda así:

Llamadas al LLM por ticker-día, leídas del grafo de la v0.7.0

LLM calls for one ticker on one date (v0.7.0 graph)

  N =  Σ (r_a + 1)   market, news, fundamentals analysts   r_a = tool rounds used (cap: max_tool_rounds = 20)
     + 1             sentiment analyst                      fetches its sources first, no tool loop
     + 2·D           bull + bear turns                      D = max_debate_rounds (default 1)
     + 3·R           aggressive, conservative, neutral      R = max_risk_discuss_rounds (default 1)
     + 3             research manager, trader, portfolio manager
     + m             one reflection per past decision settled during the run

  defaults, one tool round per analyst: 6 + 1 + 2 + 3 + 3 = 15 calls
  deep tier = research manager + portfolio manager = 2 calls; quick tier = everything else

  cost = Σ_quick (tokens_in · 0.10 + tokens_out · 0.50) / 1M     gpt-6-luna, $ per 1M tokens
       + Σ_deep  (tokens_in · 2.00 + tokens_out · 10.00) / 1M    gpt-6-sol  (standard tier, ≤272K context)

Con los valores por defecto y una ronda de herramientas por analista llegás a 15 llamadas, y a más cuando los analistas usan rondas extra. Dos de ellas son del nivel deep. Con los precios estándar de OpenAI para los modelos por defecto del README, GPT-6 Sol cuesta $2 / $10 por millón de tokens de entrada / salida y GPT-6 Luna $0.10 / $0.50, una diferencia de 20× por token.

Un ejemplo resuelto (los tamaños en tokens son supuestos míos, no mediciones)

# ASSUMED token sizes, not measurements: replace them with your own numbers
LUNA = (0.10, 0.50)    # $ per 1M tokens, input / output (OpenAI standard tier)
SOL = (2.00, 10.00)

def cost(calls, tokens_in, tokens_out, price):
    return calls * (tokens_in * price[0] + tokens_out * price[1]) / 1e6

quick = cost(18, 8_000, 1_000, LUNA)   # 18 quick calls, 8K in / 1K out each
deep = cost(2, 20_000, 3_000, SOL)     # 2 deep calls, 20K in / 3K out (reasoning tokens bill as output)
print("quick $%.3f + deep $%.3f = $%.2f per ticker-day" % (quick, deep, quick + deep))
# quick $0.023 + deep $0.140 = $0.16 per ticker-day

Con esos supuestos, un ticker-día cuesta unos $0.16, y las dos llamadas deep son cerca del 85%. Un ticker en cada sesión durante un mes (~21 sesiones) sale unos $3.40; la grilla del paper (3 tickers × ~61 sesiones) costaría unos $30. Tus números van a moverse con el volumen de noticias, las rondas de herramientas y el esfuerzo de razonamiento, así que medilos.

Medí tu costo real con el contador de la propia CLI

from cli.stats_handler import StatsCallbackHandler   # the counter behind the CLI footer

stats = StatsCallbackHandler()
ta = TradingAgentsGraph(config=config, callbacks=[stats])
_, rating = ta.propagate("NVDA", "2026-10-23")
s = stats.get_stats()
print(rating, s["llm_calls"], s["tokens_in"], s["tokens_out"])   # both tiers summed

El pie de la CLI interactiva ya muestra llamadas al LLM, llamadas a herramientas y tokens de entrada y salida. Desde Python, pasá el mismo handler. Suma ambos niveles, así que valorá el total a precio de Sol para una cota superior y a precio de Luna para una inferior, o revisá el uso por modelo en el panel de tu proveedor.

7. Cómo Enchufar un Modelo Más Barato o Local

Cambiar de modelo es un cambio de configuración. El README lista OpenAI, Google, Anthropic, xAI, DeepSeek, Qwen, GLM, MiniMax, Mistral, Kimi, Groq, NVIDIA NIM, OpenRouter, Azure OpenAI, AWS Bedrock, Ollama y cualquier servidor compatible con OpenAI.

Tres formas de abaratar o pasar a local

# A) everything local with Ollama (default endpoint http://localhost:11434/v1)
#    first: ollama pull qwen3:latest && ollama pull glm-4.7-flash:latest
config["llm_provider"] = "ollama"
config["quick_think_llm"] = "qwen3:latest"
config["deep_think_llm"] = "glm-4.7-flash:latest"

# B) quick tier local, the two managers in the cloud (a provider per tier, v0.6.0+)
config["llm_provider"] = "openai"
config["deep_think_llm"] = "gpt-6-sol"
config["quick_think_provider"] = "ollama"
config["quick_think_llm"] = "qwen3:latest"

# C) any OpenAI-compatible server: vLLM, LM Studio, llama.cpp
config["llm_provider"] = "openai_compatible"
config["backend_url"] = "http://localhost:8000/v1"   # LM Studio: http://localhost:1234/v1
config["quick_think_llm"] = config["deep_think_llm"] = "<the model your server serves>"

Las sugerencias de Ollama en la CLI son qwen3:latest (8B), gpt-oss:latest (20B) y glm-4.7-flash:latest (30B), y ‘Custom model ID’ acepta cualquier modelo que hayas descargado. Definí OLLAMA_BASE_URL para un ollama-serve remoto. Con Docker hay un perfil listo: docker compose --profile ollama run --rm tradingagents-ollama.

8. Cómo lo Pondría en Paper Trading (Sugerencia Mía, No Parte del Repo)

La idea es simple. Después de cada cierre, corré el grafo para un universo pequeño y fijo, traducí el rating de cinco niveles a una posición objetivo con una regla escrita antes del primer día y enviá órdenes de mercado que Alpaca encola para la sesión siguiente. Solo largos, para que la primera versión sea simple.

Un loop mínimo de paper trading con Alpaca (alpaca-py)

# My sketch, not part of TradingAgents. Run it after the close; orders queue for the next session.
import os
from alpaca.trading.client import TradingClient
from alpaca.trading.requests import MarketOrderRequest
from alpaca.trading.enums import OrderSide, TimeInForce
from tradingagents.agents.rating import is_review

UNIVERSE = ("NVDA", "AAPL", "MSFT")   # examples, not picks
SLOT = 10                             # max shares per ticker in the paper account
TARGET = {"Buy": 1.0, "Overweight": 0.5, "Underweight": 0.0, "Sell": 0.0}   # long-only; Hold = no change

client = TradingClient(os.environ["APCA_API_KEY_ID"], os.environ["APCA_API_SECRET_KEY"], paper=True)
held = {p.symbol: int(float(p.qty)) for p in client.get_all_positions()}

def rebalance(ticker, rating):
    if is_review(rating) or rating not in TARGET:    # REVIEW or Hold: leave the position alone
        return
    delta = round(TARGET[rating] * SLOT) - held.get(ticker, 0)
    if delta:
        client.submit_order(order_data=MarketOrderRequest(
            symbol=ticker,
            qty=abs(delta),
            side=OrderSide.BUY if delta > 0 else OrderSide.SELL,
            time_in_force=TimeInForce.DAY,           # after the close: queued for the next trading day
        ))

for ticker in UNIVERSE:
    _, rating = ta.propagate(ticker, "2026-10-23")   # the session that just closed
    print(ticker, rating)                            # log it next to the report path
    rebalance(ticker, rating)

El mapeo (Buy a un slot completo, Overweight a la mitad, Hold sin cambios, Underweight y Sell a cero) es una elección arbitraria mía. Lo importante es fijarlo antes de empezar y no ajustarlo nunca con los resultados del paper trading. Alpaca encola para el siguiente día hábil las órdenes DAY enviadas después del cierre.

9. Casos de Uso Donde Brilla

Donde creo que se gana sus estrellas:

10. Cuándo NO Usarlo

Y donde yo lo mantendría lejos:

Conclusión

TradingAgents es una de las mejores referencias open source que conozco para estructurar agentes LLM como una mesa de trading, y la v0.7.0 se toma los datos point-in-time mucho más en serio que la mayoría de los proyectos de este espacio. Vale la pena estudiar la arquitectura aunque nunca operes su salida.

Los retornos son otra historia. El trimestre del paper es una demo, los modelos por defecto de hoy ya vieron ese trimestre y la evaluación propia del repo puntúa la dirección sin costos. Si lo probás, correlo hacia adelante en paper después de los cortes, medí tu costo real por ticker-día y exigile lo mismo que a cualquier otro bot.

Si vas a construir el bot alrededor, empezá por mi guía para construir bots de trading para la parte de ejecución y riesgo que un rating todavía necesita.

Fuentes

• TauricResearch/TradingAgents en GitHub (README, v0.7.0)
• Xiao, Sun, Luo y Wang — TradingAgents: Multi-Agents LLM Financial Trading Framework (arXiv 2412.20138, v7)
• CHANGELOG de TradingAgents (correcciones de look-ahead de la v0.3.1 a la v0.7.0)
• default_config.py de TradingAgents (modelos, rondas, límite de herramientas, proveedores de datos)
• Precios de la API de OpenAI (gpt-6-sol y gpt-6-luna, nivel estándar)
• Página del modelo GPT-6 Sol en OpenAI (corte de conocimiento; la de Luna indica el 18 de mayo de 2026)
• Alpaca — Paper Trading (lo que la simulación no tiene en cuenta)
• Alpaca — Orders at Alpaca (time in force, órdenes después del cierre)