GLM-5.3-Flash-tutorial: bouw een multi-agent aandelenanalist

Waarom GLM-5.3-Flash gebruiken voor een multi-agentapplicatie

GLM-5.3-Flash biedt een indrukwekkende balans tussen prestaties, efficiëntie en prijs. Voor een compleet overzicht lees je onze GLM-5.3-Flash-gids en onze vergelijking met Qwen3.8-Flash-Next.

Concurrerende performance en efficiëntie

Op de Artificial Analysis Intelligence Index scoort het 57, waarmee het tot de leidende modellen behoort en kan concurreren met aanzienlijk duurdere frontiermodellen. Bijvoorbeeld:

• GPT-5.6 Sol scoort ook 57 (met high reasoning effort) maar kost meer dan 25x zoveel voor input- en 40x zoveel voor outputtokens.

• Claude Sonnet 5 scoort zelfs iets lager, met 55 bij max reasoning effort. Het is 20x/30x duurder voor input-/outputtokens dan GLM-5.3-Flash.

Het heeft in totaal 320B parameters, maar slechts rond 18B parameters zijn actief per token, waardoor het sterke prestaties levert en toch relatief rekenzuinig blijft. 

Bron: AI Model & API Providers Analysis | Artificial Analysis 

Aantrekkelijke prijs

Zoals gezegd komen deze prestaties met relatief lage API-kosten. Op het moment van schrijven biedt OpenRouter GLM-5.3-Flash met 50% korting aan, voor $0,075 per miljoen inputtokens en $0,25 per miljoen outputtokens. 

Zelfs tegen de reguliere prijs van $0,15/$0,50 blijft het goedkoper dan modellen zoals OpenAI's GPT-5.6 Luna, dat $0,20/$1,20 kost (52 op de AA Intelligence Index met max reasoning). Dit maakt het aantrekkelijk niet alleen voor experimenten, maar ook voor grotere agentapplicaties in productie. 

Bron: GLM 5.3 Flash - API Pricing & Benchmarks | OpenRouter 

Dit is des te belangrijker bij het bouwen van een multi-agentsysteem, omdat één gebruikersverzoek achter de schermen veel LLM-calls kan triggeren. Een enkele LLM-agent kan het model meerdere keren aanroepen voor redeneren, toolselectie, het verwerken van tooloutputs en het genereren van het eindantwoord. Als één agent ongeveer zeven LLM-calls doet en je workflow vijf agents gebruikt, kan één verzoek al snel resulteren in 35 of meer LLM-calls. 

Het exacte aantal hangt af van het ontwerp van je systeem, maar de strekking is simpel: agentische workflows kunnen snel duur worden. Een capabel model met lage tokenprijzen, zoals GLM-5.3-Flash, kan een groot verschil maken wanneer je van een kleine demo naar een echte productieapplicatie gaat. 

1. De omgeving voor GLM-5.3-Flash instellen

Voordat we de multi-agentworkflow bouwen, maak je API-sleutels aan voor Z.ai, Finnhub en Tavily.

API-sleutels aanmaken

Gebruik voor Z.ai de reguliere API, niet het GLM Coding Plan. Het Coding Plan is bedoeld voor ondersteunde AI-codingtools en moet niet gebruikt worden als algemene API voor je eigen multi-agentapplicatie.

Genereer een reguliere Z.ai-API-sleutel en zet een klein bedrag aan tegoed op je account. Omdat GLM-5.3-Flash goedkoop is, heb je maar een klein saldo nodig om te beginnen met testen.

Bron: Z.ai API Platform — Start building with GLM-5.3 

Je kunt ook gratis accounts aanmaken op Finnhub en Tavily en API-sleutels genereren. Hun gratis niveaus zijn voldoende om dit project te testen.

De projectbestanden inrichten

Maak vervolgens een .env-bestand in je projectmap en voeg de API-sleutels toe:

ZAI_API_KEY="your_zai_api_key"
FINNHUB_API_KEY="your_finnhub_api_key"
TAVILY_API_KEY="your_tavily_api_key"

Maak nu een nieuw Jupyter Notebook. We bouwen en testen hier eerst de complete multi-agentworkflow, bekijken de output van elke agent en lossen eventuele problemen op voordat we er een echte applicatie van maken.

Benodigde libraries installeren

We gebruiken CrewAI om de agents te maken en te coördineren, Finnhub voor beursdata en Tavily voor realtime webzoekopdrachten. Installeer de vereiste Python-packages:

!pip install -q crewai crewai-tools finnhub-python tavily-python pandas numpy requests python-dotenv openai

Libraries en API-sleutels importeren

Importeer vervolgens de benodigde libraries en laad de API-sleutels:

import os
import re
import time

import finnhub
import numpy as np
import pandas as pd
import requests

from dotenv import load_dotenv
from openai import OpenAI
from tavily import TavilyClient

from crewai import Agent, Crew, LLM, Process, Task
from crewai.tools import tool
from crewai_tools import TavilySearchTool

# Load environment variables
load_dotenv()

# Disable CrewAI tracing
os.environ.setdefault("CREWAI_TRACING_ENABLED", "false")
os.environ.setdefault("OTEL_SDK_DISABLED", "true")

Kies tot slot het aandeel dat je door de agents wilt laten analyseren:

TICKER = "NVDA"

Ik gebruik NVIDIA (NVDA) in het hele notebook, maar voel je vrij om het te vervangen door een andere ticker die je interesseert, zoals AAPL, MSFT of TSLA.

2. GLM-5.3-Flash en de data-API's configureren

Nu de API-sleutels klaar zijn, kunnen we de services koppelen die onze agents in het project gaan gebruiken.

Begin met het initialiseren van Finnhub voor beursdata en Tavily voor webzoekopdrachten:

finnhub_client = finnhub.Client(
    api_key=os.environ["FINNHUB_API_KEY"]
)

tavily_client = TavilyClient(
    api_key=os.environ["TAVILY_API_KEY"]
)

Als je financiële agents wilt bouwen en niet zeker weet welke databron je moet gebruiken, raad ik onze gids aan voor het kiezen van de juiste aandelenmarkt-data-API.

Configureer vervolgens GLM-5.3-Flash als de hoofd-LLM voor onze CrewAI-agents. Z.ai biedt een OpenAI-compatibele API, dus we kunnen het direct koppelen via de LLM-klasse van CrewAI:

llm = LLM(
    model="openai/glm-5.3-flash",
    api_key=os.environ["ZAI_API_KEY"],
    base_url="https://api.z.ai/api/paas/v4/",
    temperature=0.1,
)

We houden de temperatuur laag omdat deze applicatie draait om financieel onderzoek en analyse, waarbij we consistente en gefocuste antwoorden willen.

Met het model en de markt- en zoek-API's gekoppeld, kunnen we nu de tools bouwen die onze agents gaan gebruiken.

3. Historische marktdata verzamelen

We hebben historische koersdata nodig zodat onze agents kunnen begrijpen hoe het aandeel zich in de tijd heeft ontwikkeld.

Hiervoor gebruiken we de openbare chart-endpoint van Yahoo Finance om dagelijkse open-, hoog-, laag-, slot- en volumedata te verzamelen.

De koershistorie downloaden

HTTP = requests.Session()
HTTP.headers.update({"User-Agent": "glm-stock-swarm/1.0"})


def _yahoo_history(ticker: str, days: int) -> pd.DataFrame:
    end = int(time.time())
    start = end - days * 24 * 60 * 60

    response = HTTP.get(
        f"https://query1.finance.yahoo.com/v8/finance/chart/{ticker}",
        params={
            "period1": start,
            "period2": end,
            "interval": "1d",
            "events": "history",
        },
        timeout=30,
    )
    response.raise_for_status()

    result = response.json()["chart"]["result"][0]
    values = result["indicators"]["quote"][0]

    frame = pd.DataFrame({
        "date": pd.to_datetime(
            result["timestamp"], unit="s", utc=True
        ).tz_localize(None),
        "open": values["open"],
        "high": values["high"],
        "low": values["low"],
        "close": values["close"],
        "volume": values["volume"],
    })

    frame = (
        frame.dropna(subset=["close"])
        .sort_values("date")
        .reset_index(drop=True)
    )

    frame.attrs["source"] = "Yahoo public chart"
    return frame


def get_price_history(ticker: str, days: int = 450) -> pd.DataFrame:
    return _yahoo_history(ticker.strip().upper(), days)

We verzamelen ongeveer 450 dagen aan historie, wat genoeg is om langeretermijnindicatoren zoals het 200-daags voortschrijdend gemiddelde te berekenen.

Technische indicatoren berekenen

Laten we vervolgens een paar veelgebruikte indicatoren berekenen: 

• Voortschrijdende gemiddelden: gemiddelde over de laatste 20-, 50- en 200-daagse periodes
• Relative Strength Index (RSI): schaal tussen 0 en 100 die aangeeft of een aandeel overbought (>70) of oversold (<30) is
• Moving Average Convergence/Divergence (MACD): verschil tussen lange en korte Exponential Moving Averages (EMA's)

def add_indicators(frame: pd.DataFrame) -> pd.DataFrame:
    if frame.empty:
        return frame.copy()

    result = frame.copy()
    result.attrs.update(frame.attrs)

    # Moving averages
    result["SMA20"] = result["close"].rolling(20).mean()
    result["SMA50"] = result["close"].rolling(50).mean()
    result["SMA200"] = result["close"].rolling(200).mean()

    # RSI
    delta = result["close"].diff()
    gain = delta.clip(lower=0)
    loss = -delta.clip(upper=0)

    avg_gain = gain.ewm(
        alpha=1 / 14, min_periods=14, adjust=False
    ).mean()

    avg_loss = loss.ewm(
        alpha=1 / 14, min_periods=14, adjust=False
    ).mean()

    result["RSI14"] = 100 - (
        100 / (1 + avg_gain / avg_loss.replace(0, np.nan))
    )

    # MACD
    result["EMA12"] = result["close"].ewm(
        span=12, adjust=False
    ).mean()

    result["EMA26"] = result["close"].ewm(
        span=26, adjust=False
    ).mean()

    result["MACD"] = result["EMA12"] - result["EMA26"]

    return result

Deze indicatoren zijn nuttig omdat ze de technische agent snel zicht geven op trends en momentum, zonder dat we het LLM alles zelf laten uitrekenen.

De laatste waarden bekijken

Verzamel nu de data, bereken de indicatoren en toon de laatste rijen:

history = add_indicators(
    get_price_history(TICKER)
)

if len(history) < 200:
    raise RuntimeError(
        f"Need at least 200 daily observations; received {len(history)}."
    )

print(
    f"Loaded {len(history)} rows "
    f"from {history.attrs['source']}."
)

history.tail(3)[
    [
        "date",
        "close",
        "SMA20",
        "SMA50",
        "SMA200",
        "RSI14",
        "MACD",
    ]
]

Je zou de meest recente koers moeten zien, samen met de voortschrijdende gemiddelden, RSI en MACD, vergelijkbaar met de bovenstaande output.

We geven deze data later door aan de technische agent zodat die prijstrends, momentum en bullish of bearish signalen kan identificeren.

4. De databronnen omzetten in CrewAI-tools

Nu onze databronnen werken, moeten we ze omzetten in CrewAI-tools. Zo kunnen de agents ze direct aanroepen wanneer ze financiële, technische of nieuwsinfo nodig hebben.

De aandelendatatools maken

Maak eerst een kleine helperfunctie om numerieke waarden netjes en consistent te houden:

def _number(value, decimals: int = 2) -> str:
    if value is None or pd.isna(value):
        return "N/A"

    return f"{float(value):,.{decimals}f}"

Maak vervolgens de fundamentals-tool. Deze gebruikt Finnhub om de laatste koers, waarderingsmaatstaven, groei, winstgevendheid en andere bedrijfsfundamenten op te halen.

@tool("Get Stock Fundamentals")
def get_fundamentals(ticker: str) -> str:
    """Get current price and company fundamentals from Finnhub for one ticker."""

    ticker = ticker.strip().upper()

    quote = finnhub_client.quote(ticker)
    metrics = finnhub_client.company_basic_financials(ticker, "all")
    m = metrics.get("metric", {})

    return f"""Ticker: {ticker}
Source: Finnhub
Current price: {_number(quote.get('c'))}
Previous close: {_number(quote.get('pc'))}
Daily change %: {_number(quote.get('dp'))}
Day high / low: {_number(quote.get('h'))} / {_number(quote.get('l'))}
Market cap (USD millions): {_number(m.get('marketCapitalization'))}
52-week high / low: {_number(m.get('52WeekHigh'))} / {_number(m.get('52WeekLow'))}
Normalized annual P/E: {_number(m.get('peNormalizedAnnual'))}
Annual P/B: {_number(m.get('pbAnnual'))}
Annual P/S: {_number(m.get('psAnnual'))}
ROE TTM: {_number(m.get('roeTTM'))}
Net margin TTM: {_number(m.get('netProfitMarginTTM'))}
Revenue growth TTM YoY: {_number(m.get('revenueGrowthTTMYoy'))}
EPS growth TTM YoY: {_number(m.get('epsGrowthTTMYoy'))}
Annual debt/equity: {_number(m.get('totalDebt/totalEquityAnnual'))}"""

We maken ook een tool voor technische analyse met de historische data en indicatoren uit de vorige sectie.

@tool("Analyze Stock Technicals")
def get_technicals(ticker: str) -> str:
    """Calculate price trends, returns, moving averages, RSI, and MACD."""

    ticker = ticker.strip().upper()
    frame = add_indicators(get_price_history(ticker))

    if len(frame) < 200:
        return (
            f"Technical data unavailable for {ticker}: "
            "fewer than 200 observations."
        )

    latest = frame.iloc[-1]

    return f"""Ticker: {ticker}
Source: {frame.attrs.get('source', 'unknown')}
Last market date: {latest['date'].date()}
Close: {_number(latest['close'])}
SMA20 / SMA50 / SMA200: {_number(latest['SMA20'])} / {_number(latest['SMA50'])} / {_number(latest['SMA200'])}
RSI14: {_number(latest['RSI14'])}
MACD: {_number(latest['MACD'])}
20-day return: {_number((latest['close'] / frame['close'].iloc[-21] - 1) * 100)}%
50-day return: {_number((latest['close'] / frame['close'].iloc[-51] - 1) * 100)}%
Price vs SMA20: {_number((latest['close'] / latest['SMA20'] - 1) * 100)}%
Price vs SMA50: {_number((latest['close'] / latest['SMA50'] - 1) * 100)}%
Price vs SMA200: {_number((latest['close'] / latest['SMA200'] - 1) * 100)}%"""

Het belangrijkste hier is de @tool-decorator. Die verandert een normale Python-functie in een tool die een CrewAI-agent tijdens een taak kan aanroepen.

De webzoektool toevoegen

Voor bedrijfsnieuws en recente ontwikkelingen gebruiken we de Tavily-zoektool van CrewAI:

web_search = TavilySearchTool(
    api_key=os.environ["TAVILY_API_KEY"],
    topic="news",
    search_depth="advanced",
    days=30,
    max_results=5,
)

We beperken de zoekopdracht tot de laatste 30 dagen en geven maximaal vijf resultaten terug. Dat geeft onze onderzoeksagents voldoende recente informatie zonder ze te overspoelen met onnodige content.

De aandelentools testen

Voordat we de agents maken, voer je de twee aangepaste tools direct uit:

print(get_fundamentals.run(ticker=TICKER))
print()
print(get_technicals.run(ticker=TICKER))

Je zou nu de laatste fundamentele maatstaven moeten zien, gevolgd door de technische indicatoren voor het geselecteerde aandeel.

5. Het multi-agent onderzoeksteam bouwen

Nu de tools klaar zijn, kunnen we ons multi-agent onderzoeksteam maken.

We gebruiken drie specialistische agents—één voor fundamentele analyse, één voor technische analyse en één voor recent nieuws—plus een portfoliomanager die hun bevindingen combineert tot de eindbeoordeling.

De specialistische agents maken

Maak eerst de fundamentele analist:

fundamental_agent = Agent(
    role="Fundamental Analyst",
    goal=(
        "Evaluate financial health, growth, profitability, "
        "valuation, and balance-sheet risk."
    ),
    backstory=(
        "You are a careful long-term equity analyst. "
        "Use the fundamentals tool and never invent a figure. "
        "Treat N/A as missing, not as zero."
    ),
    tools=[get_fundamentals],
    llm=llm,
    allow_delegation=False,
    max_iter=4,
    verbose=False,
)

Maak vervolgens de technische analist:

technical_agent = Agent(
    role="Technical Analyst",
    goal=(
        "Determine whether the current price setup is "
        "bullish, bearish, or neutral."
    ),
    backstory=(
        "You interpret indicators calculated by Python. "
        "Never guess market prices or indicator values."
    ),
    tools=[get_technicals],
    llm=llm,
    allow_delegation=False,
    max_iter=4,
    verbose=False,
)

Maak daarna de financieel-nieuwsanalist:

news_agent = Agent(
    role="Financial News Analyst",
    goal=(
        "Find material recent developments and distinguish "
        "confirmed reporting from speculation."
    ),
    backstory=(
        "You are a skeptical financial-news researcher. "
        "Prioritize primary and reputable sources, dates, and links."
    ),
    tools=[web_search],
    llm=llm,
    allow_delegation=False,
    max_iter=5,
    verbose=False,
)

Elke specialist krijgt alleen de tool die hij daadwerkelijk nodig heeft. Dit houdt de workflow gefocust en voorkomt dat agents niet-relevante tools aanroepen.

De portfoliomanager maken

Maak tenslotte de manager-agent die alle drie de specialistische rapporten beoordeelt:

manager_agent = Agent(
    role="Portfolio Manager",
    goal=(
        "Combine the specialist reports into a balanced, "
        "evidence-based research signal."
    ),
    backstory=(
        "You lead an equity research team. "
        "Weigh bullish and bearish evidence, use HOLD when evidence "
        "is mixed, and never add unsupported facts."
    ),
    llm=llm,
    allow_delegation=False,
    max_iter=4,
    verbose=False,
)

De portfoliomanager heeft geen directe toegang tot onze datatools nodig. In plaats daarvan werkt die met de rapporten van de drie specialisten.

Door allow_delegation=False in te stellen blijft de workflow voorspelbaar, terwijl max_iter beperkt hoeveel redeneer- en tool-gebruikcycli elke agent mag uitvoeren.

6. Gespecialiseerde onderzoekstaken toewijzen

Agents maken bepaalt wie ze zijn. Nu moeten we elk precies vertellen wat het moet doen en wat de uiteindelijke output moet bevatten.

De onderzoekstaken definiëren

Begin met de taak voor fundamentele analyse:

fundamental_task = Task(
    description=(
        f"Analyze {TICKER}'s growth, profitability, valuation, "
        "balance sheet, and business quality. "
        "Use Get Stock Fundamentals. "
        "Return a Fundamental Score from 0-100, strongest positive, "
        "biggest risk, and note all material missing data."
    ),
    expected_output=(
        "A concise fundamental assessment with a 0-100 score, "
        "evidence, strongest positive, biggest risk, "
        "and missing-data note."
    ),
    agent=fundamental_agent,
)

Definieer vervolgens de taak voor technische analyse:

technical_task = Task(
    description=(
        f"Analyze {TICKER}'s technical setup. "
        "Use Analyze Stock Technicals. "
        "Consider SMA20/50/200, RSI14, MACD, recent returns, and trend. "
        "Return Technical Score 0-100, Bullish/Neutral/Bearish signal, "
        "trend, momentum, and main technical risk."
    ),
    expected_output=(
        "A concise technical assessment with score, signal, trend, "
        "momentum, data source, and main risk."
    ),
    agent=technical_agent,
)

Maak voor recente ontwikkelingen de nieuwsonderzoekstaak:

news_task = Task(
    description=(
        f"Research the most important recent news for {TICKER}, "
        "focusing on the last 30 days: earnings, guidance, analyst "
        "revisions, products, partnerships, M&A, regulation, lawsuits, "
        "management, and industry developments. "
        "Use Tavily Search. "
        "Return News Score 0-100, sentiment, positive and negative "
        "catalysts, publication dates, and source URLs. "
        "Ignore low-quality speculation."
    ),
    expected_output=(
        "A sourced recent-news assessment with score, sentiment, "
        "catalysts, dates, and clickable URLs."
    ),
    agent=news_agent,
)

Elke agent een duidelijke taak en outputformaat geven is belangrijk. Het maakt hun rapporten gemakkelijker te vergelijken voor de portfoliomanager, in plaats van totaal verschillende antwoorden van elke agent te krijgen.

De definitieve besluittaak maken

De laatste taak brengt alle drie de rapporten samen:

decision_task = Task(
    description=(
        f"Review all three specialist reports and make the final "
        f"educational research assessment for {TICKER}. "
        "Return exactly one signal: BUY, HOLD, or SELL. "
        "Use HOLD when evidence is mixed or confidence is insufficient. "
        "Base every claim only on the supplied reports."
    ),
    expected_output=(
        "Ticker; Signal; Overall Score /100; Confidence %; "
        "Fundamental, Technical, and News scores; Bull Case; "
        "Bear Case; Main Catalyst; Main Risk; Final Explanation; "
        "Sources; and an educational-not-financial-advice disclaimer."
    ),
    agent=manager_agent,
    context=[
        fundamental_task,
        technical_task,
        news_task,
    ],
)

Het sleutelonderdeel is context. Dit geeft de portfoliomanager toegang tot de outputs van alle drie de specialistische taken, zodat die de fundamentele, technische en nieuwssignalen kan vergelijken voordat de definitieve KOOP-, HOUD- of VERKOOP-beoordeling wordt geproduceerd.

Op dit punt zijn onze agents, tools en taken klaar. Nu kunnen we alles verbinden in een CrewAI-workflow en het complete onderzoeksteam draaien.

7. De multi-agent research-crew draaien

Nu kunnen we alles samenbrengen en de volledige aandelenonderzoeksworkflow draaien.

De crew maken

Maak een CrewAI-crew met onze drie specialisten en de portfoliomanager:

crew = Crew(
    agents=[
        fundamental_agent,
        technical_agent,
        news_agent,
        manager_agent,
    ],
    tasks=[
        fundamental_task,
        technical_task,
        news_task,
        decision_task,
    ],
    process=Process.sequential,
    verbose=False,
    tracing=False,
)

We gebruiken Process.sequential, zodat de onderzoekstaken op volgorde worden uitgevoerd. De fundamentele, technische en nieuwsagents ronden eerst hun analyses af, waarna de portfoliomanager die rapporten ontvangt om de eindbeoordeling te maken.

Het onderzoeksteam draaien

Start de workflow asynchroon:

result = await crew.kickoff_async()

Deze stap kan even duren omdat de agents meerdere LLM- en toolcalls doen. In mijn test duurde de volledige onderzoeksworkflow zo'n 4 tot 5 minuten.

Toon, zodra het klaar is, het eindrapport van de portfoliomanager:

print(result.raw)

Je zou een gedetailleerd rapport moeten krijgen zoals hierboven, met onder meer:

• KOOP-, HOUD- of VERKOOP-signaal
• Totale score
• Vertrouwensniveau
• Scores per specialist
• Bull case
• Bear case
• Katalysatoren
• Risico's
• Ondersteunende bronnen

In dit voorbeeld analyseerden de agents NVIDIA onafhankelijk en combineerden ze hun bevindingen tot één op bewijs gebaseerd onderzoeksrapport. Hier zie je het voordeel van de multi-agentbenadering: in plaats van één model alles in één keer te laten doen, focust elke agent op zijn eigen domein en brengt de portfoliomanager al het onderzoek samen.

Als je problemen ondervindt bij het uitvoeren van de bovenstaande code, heb ik ook het volledige Jupyter Notebook met alle code en outputs toegevoegd, dat je kunt bekijken of zelf draaien: glm-stock-swarm/stock_analyst_crew.ipynb

8. De terminal-UI bouwen en draaien

Na alles in het Jupyter Notebook te hebben getest, heb ik de complete workflow omgezet in een terminal user interface (TUI). In plaats van elke notebookcel handmatig te draaien, kun je nu de hele multi-agent aandelenanalist met één commando starten.

Het complete project, inclusief de code en installatie-instructies, staat op GitHub: glm-stock-swarm GitHub-repository.

De app installeren en draaien

Begin met het klonen van de repository:

git clone https://github.com/kingabzpro/glm-stock-swarm.git
cd glm-stock-swarm

Voeg je Z.ai-, Finnhub- en Tavily-API-sleutels toe aan het .env-bestand en installeer daarna alle dependencies met uv:

uv sync

Start ten slotte de TUI:

uv run glm-stock-swarm

Een aandeel analyseren

De interface biedt een eenvoudig invoerveld waarin je elke ondersteunde aandelenticker kunt invullen om de analyse te starten.

Zodra je de ticker verzendt, kun je de agents één voor één aan het werk zien. De fundamentele analist begint, gevolgd door de technische analist, de nieuwsanalist en tenslotte de portfoliomanager, die alles samenvoegt tot het eindoordeel.

Aan het einde genereert de TUI een volledig rapport direct in de terminal, met de fundamentalscore, technische score, nieuwsscore, totaalscore, vertrouwen, bull case, bear case, risico's, katalysatoren en het definitieve KOOP-, HOUD- of VERKOOP-signaal.

Vervolgvragen stellen

Ik heb ook een vervolgchat toegevoegd zodat je niet de hele multi-agentpipeline opnieuw hoeft te draaien telkens als je een nieuwe vraag hebt.

Zo vroeg ik na een VERKOOP-aanbeveling bijvoorbeeld of ik de hele positie of slechts een deel ervan zou moeten verkopen.

In plaats van alle vier de agents opnieuw te starten, gebruikt de applicatie de context van het gegenereerde onderzoeksrapport en stuurt het een veel snellere vervolgrespons.

Dit maakt de applicatie praktischer, omdat de dure multi-agentanalyse één keer draait, terwijl vervolgvragen de bestaande analyse kunnen hergebruiken.

Tot slot

Wat het vermelden waard is uit mijn testruns, is de betrouwbaarheid van toolaanroepen. Alle drie de specialisten kozen de juiste tool, respecteerden de N/A-conventie in plaats van ontbrekende data als nul te behandelen, en leverden het score-plus-bewijsformaat dat de portfoliomanager nodig had. Dáár gaat het bij goedkope modellen vaak mis.

Snelheid is de keerzijde. Artificial Analysis klokt GLM-5.3-Flash op zo'n 45 outputtokens per seconde via de API van Z.ai, wat aan de lage kant is voor open-weight modellen van deze grootte, en dat merk je in de 4 tot 5 minuten die een volledige crew-run duurt. Het scoort ook 57 op hun intelligence-index tegenover 60 voor GLM-5.3, dus je levert een beetje redeneerkwaliteit in, maar dat is een prima ruil gezien je ongeveer een tiende van de prijs betaalt.

Niets hiervan legt je vast. Overschakelen naar OpenRouter, Hugging Face Inference of een lokaal model via Ollama betekent meestal drie dingen aanpassen: de API-sleutel, de modelnaam en de base-URL. Hetzelfde geldt voor de tools, waar yfinance het werk kan doen dat Finnhub en Yahoo hier verdelen.

De volgende stap die ik zou nemen is dit koppelen aan een paper-trading-API en een ochtendanalyse in te plannen. Houd het wel op een demo-account. Dit is gebouwd om agentdesign te onderwijzen, niet om te traden.

Wil je alles over agentische AI vanaf de basis leren, dan raad ik onze AI Agent Fundamentals-skill track aan als uitstekend startpunt.