TradingAgents: Open Source LLM Trading Framework

Die meisten Multi-Agenten-LLM-Frameworks versprechen mehr, als sie halten. TradingAgents ist eine der seltenen Ausnahmen: Open Source von Tauric Research mit arXiv-Paper, Version 0.2.4, und einer sauberen Rollenverteilung. Das System modelliert einen Research-Desk: Fundamentalanalyse, Sentimentanalyse, Nachrichtenanalyse und technische Analyse liefern Input für eine Bull/Bear-Debatte, danach entscheiden Trader und Risikomanagement-Komitee. Das Ergebnis ist eine strukturierte, protokollierte Entscheidung.

Teste Apidog noch heute

Diese Rezension zeigt, was TradingAgents praktisch leistet, was v0.2.4 mitbringt, wie es sich gegenüber LangGraph und CrewAI einordnet und wie du die darunterliegenden LLM- und Marktdaten-Schnittstellen mit Apidog testest. Wenn du dich mit Agenten-Vertragsschichten beschäftigst, passt der agents.md-Leitfaden für API-Teams gut dazu.

TL;DR

• TradingAgents ist ein Multi-Agenten-LLM-Handelsframework von Tauric Research, arXiv 2412.20138, Open Source und aktuell in Version 0.2.4.
• Es zerlegt den Workflow in spezialisierte Agenten: Fundamentalanalyse, Sentimentanalyse, Nachrichtenanalyse, technische Analyse, Bull/Bear-Forscher, Trader und Risikomanagement.
• v0.2.4 bringt strukturierte Agenten-Ausgaben, LangGraph-Checkpoint-Wiederaufnahme, persistente Entscheidungslogs und Provider-Support für DeepSeek, Qwen, GLM und Azure OpenAI.
• Das Framework läuft mit OpenAI-kompatiblen LLM-Endpunkten. Dadurch kannst du gehostete, lokale und selbst gehostete Modelle austauschen.
• Mit Apidog kannst du Marktdaten-APIs mocken, LLM-Provider-Traffic reproduzieren und Kosten über DeepSeek, OpenAI und Anthropic vergleichen.
• Lade Apidog herunter, wenn du diese Tests in CI integrieren willst, bevor Agenten mit realen Finanzdaten arbeiten.

Was TradingAgents tatsächlich ist

TradingAgents ist ein Python-Paket mit CLI, das einen Handels-Workflow in Rollen zerlegt. Jede Rolle ist ein LLM-Agent mit:

• klarer Aufgabenbeschreibung,
• fokussiertem Toolset,
• LangGraph-Orchestrierung,
• strukturierter Übergabe an den nächsten Schritt.

Der Ablauf ist:

1. Daten sammeln
2. Analysen erzeugen
3. Bull/Bear-Debatte führen
4. Entscheidung formulieren
5. Risiko prüfen
6. Ergebnis protokollieren

Wichtig: Das README beschreibt TradingAgents als Forschungscode, nicht als Anlageberatung. Praktisch heißt das: Nutze es zum Experimentieren mit Multi-Agenten-Workflows, nicht als direkten Produktions-Trading-Bot.

Die technische Stärke liegt in der Rollentrennung:

Rolle	Aufgabe
Fundamentalanalyse-Analyst	Unternehmensfinanzen bewerten
Sentiment-Analyst	soziale Medien und Stimmung auswerten
Nachrichten-Analyst	makroökonomische und aktuelle Nachrichten prüfen
Technischer Analyst	Indikatoren wie MACD und RSI berechnen
Bull-Researcher	Long-These formulieren
Bear-Researcher	Short-These formulieren
Trader	Berichte lesen und Handelsplan ableiten
Risikomanagement	Entscheidung anhand von Constraints prüfen

Dieses Muster ist nicht nur für Trading relevant. Es ist eine gute Referenz für jeden komplexen Agenten-Workflow: Spezialisten, Debatte, Entscheidung, Review und Audit-Log.

Was v0.2.4 ausgeliefert hat

Die Veröffentlichung im April 2026 ist besonders relevant, wenn du TradingAgents ernsthaft evaluieren willst.

Strukturierte Agenten-Ausgaben

Forschungsmanager, Trader und Portfoliomanager geben strukturierte Ergebnisse über die OpenAI Responses API oder Anthropics Tool-Use-Kanal zurück.

Statt Freitext bekommst du typisiertes JSON. Das macht nachgelagerte Automatisierung stabiler, zum Beispiel:

{
  "ticker": "AAPL",
  "decision": "hold",
  "confidence": 0.72,
  "rationale": "Bullish fundamentals offset by short-term valuation risk.",
  "risk_notes": [
    "Earnings volatility",
    "Macro uncertainty"
  ]
}

Das konkrete Schema hängt von der Implementierung ab, aber der wichtige Punkt ist: Parser müssen nicht mehr gegen unstrukturierten Text kämpfen.

LangGraph-Checkpoint-Wiederaufnahme

Langlaufende Ausführungen können pausiert und von einem gespeicherten Checkpoint fortgesetzt werden.

Das ist relevant, wenn:

• eine Marktdaten-API drosselt,
• ein LLM-Provider 429 zurückgibt,
• ein lokales Modell abstürzt,
• ein CI-Job unterbrochen wird.

Ohne Checkpoints müsstest du den kompletten Lauf neu starten. Mit Checkpoints setzt du beim letzten stabilen Zustand fort.

Persistentes Entscheidungslog

Jede Trader-Entscheidung landet in einem SQLite-Log mit:

• Entscheidung,
• Begründung,
• Eingaben,
• Zeitstempel.

Damit kannst du später prüfen:

• Warum wurde ein bestimmter Plan erzeugt?
• Welche Daten lagen vor?
• Welches Modell war beteiligt?
• Welche Agenten haben widersprochen?

Für Experimente ist dieser Audit-Trail wichtiger als die einzelne Empfehlung.

Multi-Provider-Unterstützung

v0.2.4 erweitert die Provider-Matrix um DeepSeek, Qwen, GLM und Azure OpenAI. Vorher waren bereits OpenAI, Anthropic, Gemini und Grok relevant.

Wenn du günstigeres Reasoning testen willst, kannst du zum Beispiel DeepSeek V4 über den OpenAI-kompatiblen Endpunkt verwenden. Wenn du lange Kontexte oder Vision brauchst, testest du Gemini.

Docker und Windows-UTF-8-Fix

Unspektakulär, aber praktisch:

• Dockerfile für reproduzierbare Umgebungen
• behobener Windows-Pfad-Codierungsfehler aus v0.2.3

Gerade für Teams ist Docker wichtig, weil LLM-Experimente sonst schnell an lokalen Python-Umgebungen scheitern.

Die Agentenarchitektur im Detail

Eine typische TradingAgents-Ausführung sieht so aus:

1. Die CLI erhält Tickersymbol und Datum.
2. Das Analysten-Team läuft parallel oder sequenziell:
   • Fundamentalanalyse
   • Sentimentanalyse
   • Nachrichtenanalyse
   • technische Analyse
3. Jeder Analyst ruft eigene Daten ab und schreibt einen Bericht.
4. Der Bull-Researcher formuliert eine Long-These.
5. Der Bear-Researcher formuliert eine Short-These.
6. Beide debattieren.
7. Der Forschungsmanager synthetisiert die Debatte.
8. Der Trader erstellt einen Handelsplan.
9. Das Risikomanagement prüft aus mehreren Perspektiven:
   • aggressiv,
   • konservativ,
   • neutral.
10. Der Portfoliomanager genehmigt oder fordert Überarbeitung.
11. Die finale Entscheidung wird im SQLite-Log gespeichert.

Die teuersten Schritte sind meist:

• Bull/Bear-Debatte
• Risikomanagement-Debatte

Dort werden Reasoning-Modelle relevant. Kleine Modelle können sich in Wiederholungen verlieren oder inkonsistente Argumente liefern. Reasoning-Modelle wie DeepSeek V4 im Denkmodus, GPT-5.5 oder Claude 4.5 erzeugen eher strukturierte Gegenargumente.

Warum du die LLM-Schicht mit einem API-Tool testen solltest

In der Praxis brechen TradingAgents-Läufe meist an zwei Stellen:

1. Marktdaten-APIs
2. LLM-Provider-APIs

Marktdaten-APIs sind instabil

Typische Probleme:

• Rate Limits in Free Tiers
• Felder ändern Namen
• Felder verschwinden
• neue Felder kommen hinzu
• Provider liefern leicht unterschiedliche Semantik

Beispiel: Ein Lauf funktioniert am Dienstag, bricht aber am Mittwoch, weil ein Anbieter regularMarketTime in regular_market_time geändert hat.

LLM-Provider sind ebenfalls nicht trivial

Auch LLM-Schnittstellen unterscheiden sich:

• DeepSeek V4 Denkmodus kann Kosten erhöhen.
• OpenAI Responses API hat eigene Antwortstrukturen.
• Anthropic Tool Use liefert Inhaltsblöcke, die Parser beachten müssen.
• OpenAI-kompatibel heißt nicht automatisch identisch.

Du brauchst deshalb wiederholbare API-Sammlungen mit Assertions. Dafür eignet sich Apidog. Ein ähnliches Testmuster auf Protokollebene wird im MCP Server Testing Playbook beschrieben.

Marktdaten-APIs in Apidog mocken

Ziel: Deine Tests sollen nicht von Yahoo Finance, FinnHub, Polygon oder OpenBB abhängen.

Schritt 1: Upstream-Endpunkte definieren

Lege in Apidog ein Projekt an und erfasse die Endpunkte, die TradingAgents nutzt.

Beispiele:

GET /quote/AAPL
GET /fundamentals/AAPL
GET /news?symbol=AAPL
GET /indicators/rsi?symbol=AAPL

Speichere zu jeder Anfrage Beispielantworten aus echten Provider-Antworten.

Schritt 2: Mock-Server aktivieren

Aktiviere den Apidog-Mock-Server und zeige die TradingAgents-Konfiguration auf die Mock-URL.

Konzeptionell sieht das so aus:

export MARKET_DATA_BASE_URL="https://mock.apidog.local/project-id"

Der konkrete Konfigurationsname hängt vom jeweiligen Tool/Provider-Adapter ab. Wichtig ist: Die Agenten rufen jetzt deterministische Fixtures ab.

Das Ergebnis:

• keine Rate-Limit-Probleme in Tests,
• reproduzierbare Agenten-Ausgaben,
• schnellere CI-Läufe,
• bessere Regressionstests.

Schritt 3: Provider-Abweichungen prüfen

Führe regelmäßig Live-Requests gegen die echten Provider aus und vergleiche sie mit deinen gespeicherten Fixtures.

Prüfe auf:

• entfernte Felder,
• neue Felder,
• umbenannte Felder,
• geänderte Datentypen,
• geänderte Nullability.

Dieses Pattern entspricht der Contract-First-API-Entwicklung.

LLM-Provider-Schicht testen

Bevor du Läufe skalierst, solltest du drei Dinge testen.

1. Kosten pro Rolle messen

Führe einen einzelnen Ticker durch alle Agenten und erfasse Token-Nutzung pro Rolle.

Beispielhafte Tabelle:

Rolle	Input Tokens	Output Tokens	Kosten
Fundamentalanalyse	8.000	1.200	niedrig
Sentimentanalyse	5.000	900	niedrig
Bull/Bear-Debatte	30.000	6.000	hoch
Risikomanagement	18.000	4.000	hoch

Die Bull/Bear-Debatte ist häufig 3- bis 5-mal teurer als einzelne Analystenläufe. Wenn nicht, kann das ein Hinweis sein, dass das Modell zu knapp oder oberflächlich argumentiert.

2. Ausgabeform validieren

Für strukturierte Agenten-Ausgaben solltest du JSONPath-Assertions definieren.

Beispiele:

$.decision exists
$.confidence is number
$.rationale exists
$.risk_notes is array

Damit erkennst du sofort, wenn ein Provider plötzlich Freitext oder eine inkompatible Tool-Use-Struktur zurückgibt.

3. Provider-Parität vergleichen

Wenn du von OpenAI zu DeepSeek V4 wechselst, sollten einzelne Entscheidungen variieren dürfen. Über viele Läufe sollten die Schlussfolgerungen aber vergleichbar bleiben.

Praktischer Test:

1. Wähle 50 Ticker.
2. Führe alle Ticker mit Provider A aus.
3. Führe dieselben Ticker mit Provider B aus.
4. Vergleiche das persistente Entscheidungslog.
5. Miss Abweichungen bei:
   • buy / hold / sell,
   • Confidence,
   • Risikobewertung,
   • Begründungsmustern.

Der DeepSeek V4 API-Leitfaden zeigt die Request-Form. Der GPT-5.5 API-Leitfaden deckt die OpenAI-Seite ab. Mit Apidogs Response-Diff kannst du Unterschiede visuell vergleichen.

Minimaler TradingAgents-Lauf

Der Quickstart sieht ungefähr so aus:

git clone https://github.com/TauricResearch/TradingAgents
cd TradingAgents
pip install -r requirements.txt

export OPENAI_API_KEY="sk-..."
export FINNHUB_API_KEY="..."

python -m tradingagents.cli \
  --ticker AAPL \
  --date 2026-04-30 \
  --models gpt-5.5 \
  --rounds 2

Zwei Debattenrunden sind der kleinste sinnvolle Lauf. Die Ergebnisse landen in tradingagents/results/ als JSON und Markdown-Zusammenfassung.

Wenn du für reasoning-intensive Rollen DeepSeek V4 Pro testen willst:

export DEEPSEEK_API_KEY="sk-..."

python -m tradingagents.cli \
  --ticker AAPL \
  --date 2026-04-30 \
  --models deepseek-v4-pro \
  --provider deepseek \
  --rounds 2

Dasselbe Muster funktioniert für Qwen 3.6, GLM 5 oder lokale Modelle über Ollama oder vLLM. Der Beitrag zu den besten lokalen LLMs von 2026 behandelt lokale Bereitstellung.

Häufige Fallstricke

Zu kleines Modell verwenden

Ein 7B-Modell kann die Bull/Bear-Debatte in Wiederholungen treiben. Für sinnvolle Debatten brauchst du mindestens mittlere Reasoning-Qualität.

Realistische Untergrenze:

• DeepSeek V4 Flash
• Qwen 3.6 32B
• GPT-5.5
• Claude 4.5

Marktdaten-Caching überspringen

Jeder Analyst kann eigene Daten abrufen. Ohne Caching erzeugt ein einzelner Lauf schnell 4 bis 8 Provider-Requests.

Aktiviere Caching, sonst verbrauchst du Rate Limits unnötig.

Forschungscode als Trading-Bot behandeln

TradingAgents ist Forschungscode. Backtest-Ergebnisse hängen ab von:

• Modell,
• Prompt-Seed,
• Debattenlänge,
• Datenqualität,
• Provider-Antworten.

Behandle jede Ausgabe als Hypothese, nicht als Strategie.

Token-Verbrauch nicht protokollieren

Ein einzelner Ticker-Lauf kann je nach Modell und Runden zwischen 0,10 und 5 US-Dollar kosten.

Protokolliere:

• Modell,
• Agentenrolle,
• Input Tokens,
• Output Tokens,
• Kosten,
• Laufzeit,
• Fehler.

Die Replay-Historie von Apidog hilft, Ausreißer zu finden. Eine Endlosschleife in der Debatte kann schnell teuer werden.

Provider fest verdrahten

v0.2.0 brachte Multi-Provider-Support genau dafür, Modelle austauschbar zu machen.

Teste kleine Chargen über mehrere Provider, bevor du dich festlegst:

AAPL, MSFT, NVDA, TSLA, AMZN

Vergleiche danach das Entscheidungslog.

Wo Apidog in den Entwicklungszyklus passt

Apidog ist besonders nützlich an drei Stellen.

1. API-Design vor Live-Integration

Bevor du TradingAgents mit echten Providern verbindest, skizziere jeden Marktdaten-Endpunkt als Anfrage mit Beispielkörper.

Das zwingt dich zu klären:

• Welche Felder nutzt das Framework wirklich?
• Welche Felder sind optional?
• Welche Antworttypen kommen vor?
• Welche Provider sind austauschbar?

Viele Teams merken dabei, dass sie teure Datenfelder kaum verwenden.

2. Lokale CI mit Mocks

Der Mock-Server ersetzt externe Provider während Unit- und Integrationstests.

Vorteile:

• Tests laufen schneller.
• Tests funktionieren am Wochenende.
• Keine Rate-Limit-Abhängigkeit.
• Keine API-Schlüssel in CI für einfache Tests nötig.

Dieses Pattern wird auch in API-Tests ohne Postman beschrieben.

3. Regression-Diff gegen Live-Provider

Führe regelmäßig Live-Requests gegen die echten Provider aus und diff sie gegen Fixtures.

Das ist ein günstiger Alarm für:

Die Datenschicht hat sich geändert.
Agenten könnten jetzt falsche oder unvollständige Informationen verarbeiten.

Warum das über Trading hinaus wichtig ist

TradingAgents ist ein klares Open-Source-Beispiel für agentenbasierte Zerlegung. Das Muster lässt sich direkt übertragen auf:

• Kunden-Support-Triage: Agenten pro Tickettyp, Debatte, Entscheidung
• Code-Review: Sicherheits-, Performance- und Stil-Agenten plus Synthese
• Compliance-Review: Datenanalyse, Risikoanalyse, Entscheidungsausschuss
• Research-Zusammenfassung: mehrere spezialisierte Leser, Debatte, Synthese

Wenn du einen mehrstufigen Agenten-Workflow baust, lohnt sich ein Blick in den TradingAgents-Code. Wiederverwendbar sind vor allem:

• klare Rollen,
• explizite Debattenphase,
• strukturierte Entscheidungen,
• persistente Logs,
• testbare API-Grenzen.

Genau deshalb passt das Framework gut zu Apidog: Agenten-Workflows sind nur so stabil wie ihre Schnittstellen.

Praxisbeispiele

Quant-Research

Ein Quant-Student vergleicht DeepSeek V4, GPT-5.5 und Claude 4.5 auf demselben Korb von 30 Tickern.

Workflow:

1. Fixtures für Marktdaten in Apidog speichern.
2. Pro Provider denselben Lauf ausführen.
3. Requests und Responses erfassen.
4. Entscheidungslogs vergleichen.
5. Kosten pro Entscheidung berechnen.

Interne Code-Reviews

Ein Fintech-Ingenieur übernimmt nicht den Trading-Code, sondern das Multi-Agenten-Muster.

Agentenrollen:

• Security Reviewer
• Performance Reviewer
• Naming/Style Reviewer
• Synthesizer

Der Synthesizer schreibt den finalen PR-Kommentar. Angegebene Gesamtkosten pro PR: etwa 0,04 US-Dollar.

Solo-Developer-Watchlist

Ein Solo-Entwickler führt TradingAgents nachts für eine Watchlist von 10 Tickern aus.

Setup:

• Entscheidungen in Postgres speichern
• Live-Marktdaten nur für echte Läufe nutzen
• Apidog-Mock-Server für Wochenendtests einsetzen
• Provider-Kosten regelmäßig vergleichen

Fazit

TradingAgents ist ein funktionierendes Beispiel dafür, wie man ein Multi-Agenten-LLM-System baut, das strukturierte Entscheidungen statt Chats produziert. v0.2.4 macht das Framework deutlich praktischer: strukturierte Ausgaben, Checkpoint-Wiederaufnahme, Audit-Trail und Multi-Provider-Unterstützung.

Der kritische Punkt bleibt die Testbarkeit. Wenn Marktdaten- und LLM-Schnittstellen instabil sind, werden auch die Agenten instabil. Deshalb lohnt sich die Kombination mit Apidog.

Fünf Takeaways:

• TradingAgents zerlegt Trading in spezialisierte Agenten mit klaren Rollen.
• v0.2.4 ergänzt strukturierte Ausgaben, LangGraph-Checkpoints und neue Provider.
• Marktdaten-Provider solltest du in Apidog mocken, damit Tests deterministisch laufen.
• LLM-Provider-Parität solltest du messen, bevor du Modelle austauschst.
• Das Muster aus Spezialisten, Debatte, Entscheidung und Log ist auf viele Agenten-Workflows übertragbar.

Nächster Schritt: Klone das Repository, führe einen einzelnen Ticker gegen dein bevorzugtes LLM aus und leite die Upstream-Aufrufe über einen Apidog-Mock-Server. Nach etwa einer Stunde weißt du, ob das Framework zu deinem Workflow passt.

FAQ

Ist TradingAgents sicher mit echtem Geld zu verwenden?

Das Repository weist explizit darauf hin, dass es Forschungscode und keine Finanzberatung ist. Behandle Ausgaben als Hypothesen. Wer es mit einem Live-Broker verbindet, trägt das Risiko selbst; die Betreuer unterstützen diesen Einsatz nicht.

Welcher LLM-Anbieter bietet das beste Kosten-Qualitäts-Verhältnis?

Für viele Workloads Anfang 2026 ist DeepSeek V4 Flash mit Denkmodus deutlich günstiger als GPT-5.5 und erreicht bei der Bull/Bear-Debatte eine vergleichbare Qualität. Details zur Request-Form stehen im DeepSeek V4 API-Leitfaden.

Kann ich TradingAgents auf lokalen Modellen ausführen?

Ja. v0.2.0 fügte Multi-Provider-Unterstützung hinzu. Ollama, vLLM und LM Studio stellen OpenAI-kompatible Endpunkte bereit, die das Framework nutzen kann. Modelloptionen findest du im Beitrag zu den besten lokalen LLMs von 2026.

Wie mocke ich die Marktdaten-APIs?

Definiere jeden Provider-Endpunkt in Apidog, aktiviere den Mock-Server und richte die Tool-Konfiguration des Frameworks auf die Mock-URL aus. Dasselbe Muster ist in API-Testtools für QA-Ingenieure dokumentiert.

Was ist die Mindesthardware?

Wenn du gehostete LLMs wie OpenAI, Anthropic oder DeepSeek nutzt, reicht ein Laptop mit Python 3.10+. Wenn du lokale Modelle betreibst, hängt die Hardware vom Modell ab:

• 24 GB GPU: DeepSeek V4 Flash oder Qwen 3.6 32B
• 8 GB GPU: Llama 5.1 8B

Kleinere Modelle reduzieren meist die Qualität der Debatte.

Unterstützt es Simulationen nach Börsenschluss und am Wochenende?

Ja, sofern die Marktdatenanbieter historische Daten liefern. Das Framework kann für ein beliebiges Datum ausgeführt werden. Live-Handel ist ein separates Problem, das TradingAgents explizit nicht löst.

Wie vergleicht es sich mit anderen Multi-Agenten-Frameworks?

TradingAgents ist stark auf Trading zugeschnitten. CrewAI, AutoGen und LangGraph sind allgemeiner. Wenn du ein konkretes Multi-Agenten-Muster lernen willst, lies TradingAgents. Wenn du ein generisches Agentensystem bauen willst, starte mit LangGraph und übernimm nur die passenden Architekturideen.