In letzter Zeit ist KI extrem populär geworden.

Die stärksten Hauptlinien des Marktes in den letzten zwei Jahren drehten sich immer wieder um KI. NVIDIA, AMD, Broadcom, TSMC, Micron, Microsoft, Google, Meta, CoreWeave, Supermicro … In regelmäßigen Abständen sorgt ein Unternehmen plötzlich für Kurssprünge – wegen Quartalszahlen, Aufträgen, Investitionsausgaben, HBM, GPU, Cloud Computing, Rechenzentren und ähnlichen Schlagworten.

Noch interessanter ist, dass sie oft nicht isoliert steigen.

Manchmal bewegt sich NVIDIA zuerst, dann beginnt der Markt nach ASIC, optischen Modulen, Servern, Flüssigkeitskühlung und Strom zu suchen. Manchmal übertreffen die Quartalszahlen von Micron die Erwartungen, und dann fließt das Kapital in HBM, Speicher, Halbleiterausrüstung und Advanced Packaging. Manchmal erhöhen Cloud-Anbieter ihre Investitionsausgaben, und die gesamte KI-Infrastruktur-Kette wird neu bewertet.

Das ist eher eine Art Asset-Rotation innerhalb des KI-Themas. Der Markt kauft nicht einfach eine einzelne Aktie, sondern sucht ständig nach neuen Teilbereichen, neuen Erklärungen und neuen Nachzüglern innerhalb einer großen Erzählung.

Daraus ergibt sich das Problem: Wenn man diese Beziehungen komplett manuell pflegen müsste, wäre das zu aufwändig.

Eine Person kann NVIDIA, AMD, Micron, Microsoft, Google kennen, aber es ist schwierig, die Geschäftsveränderungen, Nachrichten, Branchenzugehörigkeiten und Aktienbewegungen von Dutzenden oder Hunderten von TradFi-Aktienkontrakten kontinuierlich zu verfolgen. Noch komplizierter ist, dass viele Unternehmen nicht nur eine Eigenschaft haben. Google ist sowohl KI-Cloud, als auch Gemini, als auch Werbeplattform; Microsoft ist sowohl Cloud, als auch Copilot, als auch Unternehmenssoftware; Broadcom hat sowohl ASIC, als auch Netzwerkchips und ist auch mit KI-Rechenzentren verbunden.

Also habe ich angefangen zu experimentieren: Können wir mit großen Modellen eine KI-Aktienlandkarte erstellen?

Nicht, dass das große Modell uns direkt sagt, was wir kaufen sollen, sondern es soll das tun, was es besser kann: Unternehmensgeschäfte verstehen, KI-Teilbereiche klassifizieren, Nachrichten ordnen, Ereignisse erklären und bewerten, welche thematisch ähnlichen Aktien von einer Kursbewegung eines Unternehmens betroffen sein könnten. Die wirklichen Handelsentscheidungen überlassen wir weiterhin Preisen, Statistiken und Risikomanagement.

Zuerst die Aktien in die richtigen Aktienkörbe legen

Der erste Schritt der Strategie ist nicht der Handel, sondern der Aufbau einer Landkarte.

Die Börse hat derzeit viele TradFi-Aktienkontrakte, direkt erhältlich sind eine Reihe von Aktienkontrakten wie NVDA, AMD, MU, MSFT, GOOGL, SMCI. Das System filtert zuerst die Aktienkontrakte und behält nur echte EQUITY-Basiswerte.

Ein sehr wichtiges Detail: ETF, Indizes, gehebelte ETFs dürfen nicht hineingemischt werden. Dinge wie QQQ, SOXL, EWT tauchen zwar auch in der Kontraktliste auf, sind aber keine Unternehmensaktien. Wenn man sie in den KI-Aktienkorb legt, werden die späteren statistischen Beziehungen verunreinigt.

Die Kernfilterlogik sieht in etwa so aus:

            python
            
            
def refresh_equity_universe(store, force_reanalyze):
    ms = exchange.GetMarkets()
    symbols = []

    for key, market in ms.items():
        info = market.get("Info", {}) or {}
        sub_type = info.get("underlyingSubType", []) or []
        underlying_type = info.get("underlyingType", "")

        if ".swap" not in key:
            continue
        if "TradFi" not in sub_type:
            continue
        if underlying_type != "EQUITY":
            continue

        symbol = normalize_symbol(key)
        store["markets"][symbol] = {
            "symbol": symbol,
            "contract": key,
            "underlyingType": underlying_type,
            "amountPrecision": market.get("AmountPrecision", 0),
            "pricePrecision": market.get("PricePrecision", 2),
            "ctVal": market.get("CtVal", 1) or 1,
            "minQty": market.get("MinQty", 0) or 0,
        }
        symbols.append(symbol)

Nachdem der Aktienpool bereinigt ist, lässt das System das große Modell ein Profil für jede Aktie erstellen.

Ein Profil bedeutet nicht einfach „das ist eine Technologieaktie“, sondern es muss beurteilt werden, zu welchen KI-Teilbereichen sie gehört. Eine Aktie kann gleichzeitig mehreren Aktienkörben angehören. Google kann zu KI-Cloud, KI-Modellanwendungen, KI-Plattformwerbung gehören; Microsoft zu Cloud und Enterprise-KI-Anwendungen; NVIDIA zu KI-Rechenleistung und KI-Servern; Micron zu KI-Speicher.

Der Schwerpunkt liegt hier: KI-Aktien sind in dieser Ära nicht eindimensional, sondern mehrfach beschriftet.

Jede Aktie hat mehrere Attribute: zu welchen Körben sie gehört, wie hoch die Exposition ist, ob sie in diesem Korb eher Leader oder Follower ist, welche Unternehmen sie beeinflussen könnte und von welchen sie beeinflusst werden könnte.

Ich habe die Ausgabestruktur des großen Modells stark eingeschränkt:

            python
            
            
schema = {
    "symbol": symbol,
    "asset_type": "stock|adr|etf|leveraged_etf|index|fund|other",
    "company_name": "",
    "sector": "",
    "business_summary": "",
    "tradable": False,
    "model_confidence": 0,
    "baskets": [
        {
            "id": "ai_cloud",
            "exposure": 0.0,
            "role": "leader|follower|both|observer",
            "sub_theme": "",
            "reason": ""
        }
    ],
    "search_names": [],
    "event_keywords": [],
    "negative_keywords": [],
    "possible_leaders": [],
    "possible_followers": [],
    "brave_queries": [],
    "reason": ""
}

Am wichtigsten ist hier asset_type. Nur stock und adr können in den Korb aufgenommen werden; ETF, gehebelte ETFs, Indizes, Fonds, Rohstoffe oder Regional-ETFs werden direkt gefiltert.

Außerdem muss reason auf Chinesisch sein, die Feldnamen müssen identisch sein, und die Konfidenz einheitlich von 0 bis 100. Sonst sieht die spätere Live-Seite unordentlich aus.

Brancheninformationen dürfen nicht auf Vermutungen beruhen

Allein die Aktienklassifikation reicht nicht.

KI-Bereiche ändern sich zu schnell. Heute handelt der Markt GPUs, morgen vielleicht HBM, übermorgen optische Module, und einige Tage später Flüssigkeitskühlung, Strom, Cloud-Anbieter-Investitionsausgaben.

Wenn man sich nur auf das Wissen des großen Modells verlässt, ist es schnell veraltet. Daher benötigt das System auch Echtzeit-Informationsquellen.

Hier habe ich BraveSearch eingebunden. Das System durchsucht regelmäßig die Brancheninformationen jedes KI-Aktienkorbs und sucht auch nach Nachrichten zu wichtigen Aktien in den Körben.

Zum Beispiel: Für den KI-Speicher-Korb werden Schlüsselwörter wie Micron, Western Digital, SanDisk, HBM, DRAM, NAND durchsucht; für den KI-Lichtkommunikations-Korb werden Ciena, Credo, Lumentum, AAOI, 800G, 1.6T optische Module durchsucht.

Der Kernprozess der Brancheninformationen ist:

            python
            
            
def refresh_basket_intelligence(store):
    if not BRAVE_KEY:
        return
    if not LLM_API_KEY:
        return

    intel = {}

    for bid, basket in store["baskets"].items():
        members = sorted(
            basket["members"],
            key=lambda x: x.get("exposure", 0),
            reverse=True
        )
        top_symbols = [m["symbol"] for m in members[:8]]

        basket_news = fetch_basket_news(basket, top_symbols)
        stock_news = {}

        for symbol in top_symbols[:6]:
            profile = store["profiles"].get(symbol, {})
            stock_news[symbol] = fetch_stock_news(profile, bid)
            Sleep(800)

        analysis = analyze_basket_intel_with_llm(
            store, basket, top_symbols, basket_news, stock_news
        )

        if analysis:
            analysis["basket"] = bid
            analysis["basket_name"] = basket["name"]
            analysis["symbols"] = top_symbols
            analysis["updatedAt"] = int(time.time())
            intel[bid] = analysis

    store["basket_intel"] = intel

Der Zweck dieses Schritts ist es, für jeden KI-Teilsektor einen dynamischen Hintergrund zu erstellen.

Das große Modell analysiert die über BraveSearch abgerufenen Nachrichten und gibt Sektortrends, Kernkatalysatoren, Kernrisiken, Kandidaten für Leader, Kandidaten für Follower sowie die Beziehungen aus, die anschließend gezielt validiert werden müssen.

Dies unterscheidet sich von der direkten Frage an das große Modell: „Wie siehst du den KI-Speichersektor?“ Wir füttern es zuerst mit den Echtzeitnachrichten und lassen es dann zusammenfassen.

Kein nachrichtengetriebener Handel, zuerst die Preisabweichung

Anfangs dachte ich auch über einen nachrichtengetriebenen Ansatz nach.

Wenn z. B. ein Unternehmen über den Erwartungen liegende Quartalszahlen meldet, sollte das große Modell bewerten, welche Aktien davon profitieren, und dann direkt Signale generieren. Aber bei näherer Überlegung: Dieser Weg ist sehr verrauscht. Es gibt zu viele Nachrichten, viele scheinen wichtig, aber der Markt reagiert nicht darauf.

Also habe ich die Logik umgedreht.

Zuerst den Preis betrachten, dann die Nachrichten.

Wenn alle Aktien in einem Basket relativ stabil sind, beobachtet das System nur. Erst wenn eine Aktie deutlich von der Durchschnittsperformance des Sektors abweicht und zum aktuellen Leader wird, fragt das System nach: Warum bewegt sie sich?

Dafür wird der interne ZScore des Baskets verwendet.

Einfach ausgedrückt: Es wird geprüft, ob eine Aktie im Vergleich zu den anderen Aktien desselben Sektors ungewöhnlich stark oder schwach ist. Wenn eine Aktie plötzlich ausbricht, während die anderen Aktien im selben Basket noch nicht synchron reagieren, besteht möglicherweise eine Streuungsmöglichkeit.

Der Kernlogik zur Berechnung des Basket-ZScores sieht wie folgt aus:

            python
            
            
def calc_basket_zscores(store, symbols):
    returns = {}
    min_len = 999999

    for symbol in symbols:
        bars = get_records(
            store["markets"][symbol]["contract"],
            KLINE_PERIOD,
            SYNC_WINDOW + 10
        )
        if len(bars) < SYNC_WINDOW + 2:
            return None

        r = calc_returns(bars)[-SYNC_WINDOW:]
        returns[symbol] = r
        min_len = min(min_len, len(r))

    latest = {s: returns[s][-1] for s in symbols}
    avg_latest = mean(list(latest.values()))
    dev_series = {s: [] for s in symbols}

    for i in range(min_len):
        row = [returns[s][-min_len + i] for s in symbols]
        row_avg = mean(row)
        for s in symbols:
            dev_series[s].append(returns[s][-min_len + i] - row_avg)

    zscores = {}
    max_abs = 0
    for s in symbols:
        sigma = std(dev_series[s])
        z = (latest[s] - avg_latest) / sigma if sigma > 0 else 0
        zscores[s] = round(z, 3)
        max_abs = max(max_abs, abs(z))

    return {"zscores": zscores, "maxAbs": max_abs}

Wenn die maximale Abweichung eines Baskets den Ausbruchsschwellenwert überschreitet, wechselt das System in den Zustand BREAKOUT_DETECTED.

Zu diesem Zeitpunkt wird nicht sofort gehandelt, sondern die Ursache untersucht.

Nachrichten dienen nur der Erklärung, statistische Beziehungen der Validierung

Sobald beim Leader ein Preisausbruch auftritt, ruft das System seine aktuellen Nachrichten ab und lässt das große Modell bewerten, ob diese Nachricht die Preisbewegung erklären kann.

Dabei wird jedoch nicht einfach gefragt: „Ist diese Nachricht bullish?“

Das System übergibt dem großen Modell den aktuellen Basket, die Sektorinformationen, den Echtzeit-Preisstatus, den ZScore des Leaders, Kandidaten für Follower, bereits validierte statistische Beziehungen und die über BraveSearch abgerufenen Nachrichten.

Das große Modell muss Folgendes beantworten:

(1) Kann diese Nachricht die Preisabweichung des Leaders erklären?
(2) Stimmt die Richtung der Nachricht mit der Preisrichtung überein?
(3) Ist der Handel erlaubt?
(4) Welche Follower werden beeinflusst?
(5) Wie groß ist der Einfluss auf jeden Follower?
(6) Warum könnten diese Follower betroffen sein?

Der Kern der Ursachenermittlung sieht wie folgt aus:

            python
            
            
def explain_breakout_with_news(store, bid, leader, direction, leader_z, followers, edges):
    if not BRAVE_KEY:
        return None
    if not LLM_API_KEY:
        return None

    profile = store["profiles"].get(leader, {})
    news = fetch_stock_news(profile, bid)
    if not news:
        return None

    event = analyze_breakout_news_with_llm(
        store, bid, leader, direction, leader_z,
        followers, edges, news
    )
    if not event:
        return None

    if not event.get("explains_price_move"):
        return None

    expected_direction = "bullish" if direction == "long" else "bearish"
    if event.get("direction") != expected_direction:
        return None

    event["confidence"] = normalize_confidence(event.get("confidence", 0))
    if event["confidence"] < MIN_NEWS_CONFIDENCE:
        return None

    if not event.get("trade_allowed"):
        return None

    return event

Aber selbst wenn das Large Model sagt, dass ein bestimmter Follower betroffen sein könnte, kann man nicht sofort handeln.

Man muss auch die statistischen Beziehungen der K-Linien betrachten.

Das System berechnet innerhalb jedes Korbs die historischen Verbindungen zwischen den Aktien, z. B. ob der Target oft folgt, wenn der Source ausbricht, wie hoch die Korrelation ist, was die optimale Verzögerungsperiode ist und wie hoch die durchschnittliche Folge-Rendite ist.

Nur wenn die statistische Beziehung für eine Source -> Target bestanden wird, wird daraus eine aktive Kante (active edge).

            python
            
            
def rebuild_basket_stats(store):
    edges = []

    for bid, basket in store["baskets"].items():
        symbols = [
            m["symbol"] for m in basket["members"]
            if m["symbol"] in store["markets"]
        ]

        for source in symbols:
            for target in symbols:
                if source == target:
                    continue

                metric = validate_pair(store, source, target)
                if not metric:
                    continue

                source_exp = basket_member_info(basket, source).get("exposure", 0)
                target_exp = basket_member_info(basket, target).get("exposure", 0)

                score = clamp(
                    metric["corr"] * 0.3 +
                    metric["follow"] * 0.4 +
                    min(source_exp, target_exp) * 0.3,
                    0, 1
                )

                edge = {
                    "basket": bid,
                    "source": source,
                    "target": target,
                    "corr": round(metric["corr"], 3),
                    "follow": round(metric["follow"], 3),
                    "lag": metric["lag"],
                    "avgReturn": round(metric["avgReturn"], 6),
                    "sample": metric["sample"],
                    "score": round(score, 3),
                    "active": (
                        score >= MIN_EDGE_SCORE and
                        metric["corr"] >= MIN_CORR and
                        metric["follow"] >= MIN_FOLLOW_SUCCESS
                    ),
                    "updatedAt": int(time.time()),
                }
                edges.append(edge)

    store["edges"] = edges

Dieser Schritt ist wichtig.

Das Large Model versteht Logik gut, aber der Markt folgt nicht unbedingt der Logik. Die statistische Beziehung dient der Überprüfung: Wurde diese Logik in der Vergangenheit bereits am Markt gehandelt?

Gehandelt wird die Ausbreitung, nicht das Hinterherjagen nach Höchstständen

Diese Strategie hat nicht das Ziel, dem Leader hinterherzujagen.

Der Leader ist bereits ausgebrochen – direkt hinterherzujagen führt leicht dazu, dass man auf dem Höhepunkt kauft. Die Strategie zielt eigentlich auf die Ausbreitungschancen innerhalb desselben AI-Korbs ab.

Das bedeutet: Der Leader hat sich bereits bewegt, die Nachrichten sind plausibel erklärt, aber einige Follower haben noch nicht vollständig reagiert. Wenn diese Follower und der Leader historisch tatsächlich eine Verbindung (Korrelation) haben, könnte es kurzfristige Folgechancen geben.

Im Breakout-Scan werden zuerst die aktiven Kanten (active edges) gesucht, dann die verzögerten Follower:

            python
            
            
def scan_price_breakouts(store):
    for bid, rt in store["realtime"].items():
        if rt["state"] != "BREAKOUT_DETECTED":
            continue

        leader = rt["leader"]
        z = 0
        for m in rt["members"]:
            if m["symbol"] == leader:
                z = m["z"]

        direction = "long" if z > 0 else "short"

        edges = [
            e for e in store["edges"]
            if e["active"] and e["basket"] == bid and e["source"] == leader
        ]

        followers = []
        for e in edges:
            target_rt = find_realtime_member(rt, e["target"])
            if target_rt and abs(target_rt["z"]) < BREAKOUT_THRESHOLD * 0.75:
                followers.append(e["target"])

        if not followers:
            continue

Erst wenn die Nachrichten-Rückverfolgung (News Tracing) ebenfalls bestanden ist, wird ein bestätigtes Signal (confirmed signal) generiert.

Die gehandelten Objekte sind hauptsächlich die Follower.

Wenn derzeit keine Position gehalten wird, wird gemäß der Signalrichtung eröffnet. Wenn für denselben Kontrakt bereits eine gleichgerichtete Position besteht, wird aufgestockt. Wenn eine entgegengesetzte Position besteht, wird diese zuerst geschlossen und dann gemäß der neuen Richtung eröffnet.

            python
            
            
def execute_symbol_trade(store, signal, symbol, detail):
    direction = signal["direction"]

    if TRADE_MODE != "trade":
        return open_or_add_position(store, signal, symbol, detail, add_mode=False)

    pos = get_position_by_symbol(symbol)
    if pos:
        pos_dir = position_direction(pos)

        if pos_dir == direction:
            return open_or_add_position(store, signal, symbol, detail, add_mode=True)

        close_existing_position(store, symbol, pos, "reverse_signal")
        Sleep(1000)

    return open_or_add_position(store, signal, symbol, detail, add_mode=False)

Das liegt auch daran, dass viele Aktien gleichzeitig in mehreren Körben vorkommen. Eine Aktie kann im AI-Cloud-Korb ein Follower sein, im AI-App-Korb aber Mitglied einer anderen Logik. Signale aus verschiedenen Körben können sie gleichzeitig beeinflussen, daher muss die Richtung für denselben Kontrakt einheitlich behandelt werden.

Risikomanagement: Erst einfach, aber zwingend vorhanden

Beim Risikomanagement werden derzeit harte Stop-Loss (hard stop loss) und Trailing-Stop-Loss (trailing stop loss) eingesetzt.

Wenn der Verlust einen Schwellenwert erreicht, wird ausgestiegen; wenn der Gewinn einen bestimmten Bereich erreicht, wird ein Trailing-Stop-Loss aktiviert. Wenn der Drawdown vom maximalen unrealisierten Gewinn zu groß ist, wird der Gewinn gesichert und die Position geschlossen.

            python
            
            
def monitor_positions(store):
    for pos in exchange.GetPosition() or []:
        symbol = position_symbol(pos)
        if symbol not in store["markets"]:
            continue

        state = _G(position_state_key(symbol)) or {}
        market = store["markets"][symbol]
        ticker = exchange.GetTicker(market["contract"])

        direction = position_direction(pos)
        pnl_pct = (
            (ticker["Last"] - pos["Price"]) /
            pos["Price"] * 100 *
            (1 if direction == "long" else -1)
        )

        if pnl_pct > state.get("peakPnlPct", 0):
            state["peakPnlPct"] = pnl_pct

        if not state.get("trailActive") and state.get("peakPnlPct", 0) >= TRAIL_ACTIVATE_PCT:
            state["trailActive"] = True

        hard_stop = False
        if state.get("stop"):
            hard_stop = (
                ticker["Last"] <= state["stop"]
                if direction == "long"
                else ticker["Last"] >= state["stop"]
            )

        trail_hit = False
        if state.get("trailActive"):
            giveback = state.get("peakPnlPct", 0) - pnl_pct
            allowed = max(
                1.5,
                state.get("peakPnlPct", 0) * TRAIL_GIVEBACK_PCT / 100.0
            )
            trail_hit = giveback >= allowed

        if hard_stop or trail_hit:
            close_existing_position(
                store, symbol, pos,
                "hard_stop" if hard_stop else "trailing_stop"
            )

Dies ist noch nicht die finale Risikokontrolle, aber für die erste Beobachtung im Live-Handel reicht es aus.

Später müssen noch die Gesamtposition auf Kontenebene, das Engagement pro Sektor, das tägliche Verlustlimit, die Ausführungsbestätigung und die Begrenzung der Nachkaufanzahl hinzugefügt werden.

Wie weit ist das System jetzt?

Das System kann bereits einen relativ vollständigen Forschungszyklus abbilden.

Es kann automatisch TradFi-Aktienkontrakte scannen, automatisch ein Long-Basket-Profil durch KI-Modelle erstellen lassen, automatisch KI-Unterbranchen aufbauen, automatisch über BraveSearch Branchen- und Aktieninformationen abrufen, automatisch Branchen-Intelligence zusammenfassen, automatisch die Echtzeit-Stärke jedes Baskets erkennen, automatisch die Folgerelationen der Aktien innerhalb des Baskets statistisch auswerten und bei einem Ausbruch des Leaders eine Ursachenanalyse über Nachrichten durchführen.

Wenn die Nachrichtenerklärung plausibel ist, die Richtung übereinstimmt und die statistische Beziehung dies stützt, erzeugt das System ein "confirmed signal". Im Standardmodus wird nur gewarnt, nicht live gehandelt; erst im "trade"-Modus wird getradet.

Auf der Live-Seite werden nicht mehr nur Logs angezeigt, sondern eine tabellarische Übersicht mit: Systemüberblick, Echtzeitstatus des Baskets, Branchen-Intelligence, letzte Signale, letzte Trades und letzte Schritte. So kann man klar erkennen, an welchem Schritt das System hängt: Nur eine Preisauffälligkeit, oder fehlt die Nachrichtenerklärung, oder erfüllen die Folger die Bedingungen nicht, oder hat die Risikokontrolle eingegriffen.

Was noch nicht ausgereift ist

Ehrlich gesagt, dieses System kann noch nicht als ausgereifte automatisierte Handelsstrategie bezeichnet werden.

Es ist eher ein KI-gestütztes Themen-Rotations-Forschungsframework, das bereits "Aktienprofil, Branchen-Intelligence, Preisauffälligkeit, Nachrichten-Ursachenanalyse, statistische Validierung, Handelssignal" miteinander verknüpfen kann, aber noch weiter validiert werden muss.

Am dringendsten ist die Verbesserung in folgenden Bereichen:

(1) Qualität der Aktienprofile. Das KI-Modell nimmt manchmal Randaktien in den Basket auf, daher muss der asset_type erzwungen werden, um ETFs, Indizes und Länderfonds auszuschließen.

(2) Qualität der Nachrichten. Die über BraveSearch gefundenen Nachrichten sind nicht immer relevant; das Modell muss beurteilen können, welche Nachrichten den Kurs tatsächlich erklären.

(3) Statistische Beziehungen. Historische Folgerelationen garantieren nicht ihre zukünftige Gültigkeit – eine kontinuierliche Nachbereitung ist erforderlich.

(4) Handelsrisikokontrolle. Vor dem automatischen Handel muss die Positionsgröße auf Kontenebene, das Sektorengagement, der Tagesverlust und die Ausführungsbestätigung ergänzt werden.

Daher ist es derzeit besser, den Notify-Modus zu nutzen und die Qualität der "confirmed signals" zu beobachten.

Wenn sich nach einer Weile herausstellt, dass die Signale Marktbewegungen tatsächlich erklären können und die Folger häufig darauf reagieren, kann man mit kleiner Position auf Live-Handel umstellen.

Fazit

Diese Strategie bedeutet nicht, dass die KI direkt Orders aufgibt.

Ich bin stets der Meinung, dass die am besten geeignete Rolle großer Modelle in einem Handelssystem nicht darin besteht, "mir zu sagen, was ich kaufen soll", sondern uns dabei zu helfen, Informationsstrukturen zu verarbeiten, die manuell nur schwer auf dem neuesten Stand zu halten sind: Unternehmensgeschäft, Branchenzugehörigkeit, Echtzeit-Nachrichten, Ereigniserklärungen, Kapitalflusswege, potenziell betroffene Akteure.

Der eigentliche Handel sollte weiterhin auf Preis, Statistik und Risikokontrolle basieren.

Eine quantitative Strategie im KI-Zeitalter sollte nicht einfach nur eine weitere KI-Schnittstelle anbinden, sondern Echtzeitdaten, Themen-Graphen, Nachrichtenereignisse, Preisstruktur, Handelsausführung und Rückblick-Erklärung miteinander verknüpfen.

Die KI-Aktien-Graphen-Strategie ist ein Versuch in diese Richtung.

Strategie-Quellcode: KI-Industriekette TradFi-Kontrakt-Graphen-Handelssystem