GLM-5.3-Flash-handledning: Bygg en multiagent-aktieanalytiker

Varför använda GLM-5.3-Flash för multiagent-applikation

GLM-5.3-Flash erbjuder en imponerande balans mellan prestanda, effektivitet och pris. För en komplett översikt, läs vår GLM-5.3-Flash-guide och vår jämförelse med Qwen3.8-Flash-Next.

Konkurrenskraftig prestanda och effektivitet

På Artificial Analysis Intelligence Index får den 57, vilket placerar den bland de ledande modellerna och gör den konkurrenskraftig med flera betydligt dyrare frontmodeller. Till exempel:

• GPT-5.6 Sol får också 57 (med high resonemangsinsats) men kostar över 25× mer för inmatningstokens och 40× mer för utmatningstokens.

• Claude Sonnet 5 ligger till och med något lägre, med 55 vid sin max resonemangsinsats. Den är 20×/30× dyrare för in-/utmatningstokens än GLM-5.3-Flash.

Den har totalt 320B parametrar, men endast cirka 18B parametrar är aktiva per token, vilket gör att den kan leverera stark prestanda och samtidigt vara relativt beräkningseffektiv. 

Källa: AI Model & API Providers Analysis | Artificial Analysis 

Attraktiv prissättning

Som jag redan nämnt kommer denna prestanda med ett jämförelsevis lågt API-pris. När detta skrivs erbjuder OpenRouter GLM-5.3-Flash med 50% rabatt, för $0,075 per miljon inmatningstokens och $0,25 per miljon utmatningstokens. 

Även till ordinarie pris $0,15/$0,50 är den billigare än modeller som OpenAI:s GPT-5.6 Luna, som kostar $0,20/$1,20 (52 på AA Intelligence Index med max resonemang). Det gör den attraktiv inte bara för experiment, utan även för större agentapplikationer i produktion. 

Källa: GLM 5.3 Flash - API Pricing & Benchmarks | OpenRouter 

Detta spelar ännu större roll när du bygger ett multiagentsystem, eftersom en användarförfrågan kan trigga många LLM-anrop i bakgrunden. En enda LLM-agent kan anropa modellen flera gånger för resonemang, verktygsval, bearbetning av verktygsutdata och generering av sitt slutliga svar. Om en agent gör cirka sju LLM-anrop och ditt arbetsflöde använder fem agenter kan en enda förfrågan lätt resultera i 35 eller fler LLM-anrop. 

Det exakta antalet beror på hur ditt system är utformat, men poängen är enkel: agentiska arbetsflöden kan bli dyra väldigt snabbt. Att använda en kapabel modell med låg tokenkostnad, som GLM-5.3-Flash, kan göra stor skillnad när du går från en liten demo till en riktig produktionsapplikation. 

1. Ställ in miljön för GLM-5.3-Flash

Innan vi bygger multiagent-arbetsflödet, skapa API-nycklar för Z.ai, Finnhub och Tavily.

Skapa API-nycklar

För Z.ai, se till att du använder det vanliga API:et, inte GLM Coding Plan. Coding Plan är avsedd för stödda AI-kodningsverktyg och ska inte användas som ett allmänt API för din egen multiagent-applikation.

Generera en vanlig Z.ai-API-nyckel och sätt in en liten summa på ditt konto. Eftersom GLM-5.3-Flash är billigt behöver du bara ett litet saldo för att börja testa.

Källa: Z.ai API Platform — Börja bygga med GLM-5.3 

Du kan också skapa gratis konton på Finnhub och Tavily och generera API-nycklar. Deras gratisnivåer räcker för att testa det här projektet.

Ställ in projektfilerna

Skapa sedan en .env-fil i din projektmapp och lägg till API-nycklarna:

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

Skapa nu en ny Jupyter Notebook. Vi bygger och testar först det kompletta multiagent-arbetsflödet här, granskar varje agents utdata och åtgärdar eventuella problem innan vi gör om det till en riktig applikation.

Installera nödvändiga bibliotek

Vi använder CrewAI för att skapa och koordinera agenterna, Finnhub för börsdata och Tavily för webbsökning i realtid. Installera de nödvändiga Python-paketen:

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

Importera bibliotek och API-nycklar

Importera sedan de nödvändiga biblioteken och ladda API-nycklarna:

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")

Välj till sist den aktie du vill att agenterna ska analysera:

TICKER = "NVDA"

Jag kommer att använda NVIDIA (NVDA) genom hela notebooken, men känn dig fri att byta till en annan ticker som intresserar dig, som AAPL, MSFT eller TSLA.

2. Konfigurera GLM-5.3-Flash och data-API:erna

Nu när API-nycklarna är klara kan vi koppla de tjänster som våra agenter ska använda genom projektet.

Börja med att initiera Finnhub för börsdata och Tavily för webbsökning:

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

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

Om du vill bygga finansiella agenter och är osäker på vilken datakälla du ska använda rekommenderar jag att läsa vår guide om att välja rätt API för börsdata.

Konfigurera sedan GLM-5.3-Flash som huvud-LLM för våra CrewAI-agenter. Z.ai tillhandahåller ett OpenAI-kompatibelt API, så vi kan koppla det direkt via CrewAI:s LLM-klass:

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,
)

Vi håller temperaturen låg eftersom den här applikationen fokuserar på finansiell research och analys, där vi vill att agenterna ska ge mer konsekventa och fokuserade svar.

Med modell, marknadsdata och webbsöknings-API:er anslutna kan vi nu börja bygga verktygen som våra agenter ska använda.

3. Samla in historisk marknadsdata

Nästa steg är historiska prisdata så att våra agenter kan förstå hur aktien har utvecklats över tid.

För detta använder vi Yahoo Finance:s publika diagrame*ndpoint för att hämta dagliga öppnings-, högsta-, lägsta-, stängnings- och volymdata.

Ladda ned kurshistorik

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)

Vi samlar in cirka 450 dagars historik, vilket ger oss tillräckligt med data för att beräkna längre indikatorer som 200-dagars glidande medelvärde.

Beräkna tekniska indikatorer

Låt oss nu beräkna några vanliga indikatorer: 

• Glidande medelvärden: medelvärde över de senaste 20, 50 och 200 dagarna
• Relative Strength Index (RSI): Skala mellan 0 och 100 som indikerar om en aktie är överköpt (>70) eller översåld (<30)
• Moving Average Convergence/Divergence (MACD): Skillnad mellan långsiktiga och kortsiktiga exponentiella glidande medelvärden (EMA)

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

Dessa indikatorer är användbara eftersom de ger den tekniska analysagenten en snabb bild av trender och momentum utan att behöva be LLM:en att räkna ut allt själv.

Granska de senaste värdena

Samla nu in data, beräkna indikatorerna och visa de senaste raderna:

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",
    ]
]

Du bör se det senaste aktiepriset tillsammans med dess glidande medelvärden, RSI och MACD, liknande resultatet ovan.

Vi skickar senare dessa data till den tekniska analysagenten så att den kan identifiera pristrender, momentum och hausse- eller baisse-signaler.

4. Gör datakällorna till CrewAI-verktyg

När våra datakällor fungerar behöver vi göra om dem till CrewAI-verktyg. Det gör att agenterna kan anropa dem direkt när de behöver finansiell, teknisk eller nyhetsinformation.

Skapa verktygen för aktiedata

Skapa först en liten hjälpfunktion för att hålla numeriska värden rena och konsekventa:

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

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

Skapa sedan verktyget för fundamenta. Det använder Finnhub för att hämta det senaste aktiepriset, värderingsmått, tillväxt, lönsamhet och andra bolagsfundamenta.

@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'))}"""

Vi skapar också ett verktyg för teknisk analys med hjälp av de historiska data och indikatorer som vi tog fram i föregående avsnitt.

@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)}%"""

Den viktiga delen här är @tool-dekorationen. Den gör om en vanlig Python-funktion till ett verktyg som en CrewAI-agent kan välja att anropa under en uppgift.

Lägg till webbsökningsverktyget

För bolagsnyheter och senaste händelser använder vi CrewAI:s Tavily-sökningsverktyg:

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

Vi begränsar sökningen till de senaste 30 dagarna och returnerar upp till fem resultat, vilket bör ge våra researchagenter tillräckligt med färsk information utan att överväldiga dem med onödigt innehåll.

Testa aktieverktygen

Innan vi skapar agenterna, kör de två anpassade verktygen direkt:

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

Du bör nu se de senaste fundamentala nyckeltalen följt av tekniska indikatorer för den valda aktien.

5. Bygg multiagent-forskningsteamet

Nu när verktygen är klara kan vi skapa vårt multiagent-forskningsteam.

Vi använder tre specialistagenter, en för fundamentalanalys, en för teknisk analys och en för senaste nyheter, plus en portföljförvaltare som kombinerar deras slutsatser till den slutliga bedömningen.

Skapa specialistagenterna

Skapa först fundamental-analytikern:

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,
)

Skapa sedan den tekniska analytikern:

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,
)

Skapa sedan nyhetsanalytikern:

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,
)

Varje specialist får bara det verktyg den faktiskt behöver. Det håller arbetsflödet fokuserat och hindrar agenterna från att anropa orelaterade verktyg.

Skapa portföljförvaltaren

Skapa slutligen den ansvariga agenten som ska granska alla tre specialistrapporterna:

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,
)

Portföljförvaltaren behöver inte direkt tillgång till våra dataverktyg. I stället arbetar den med rapporterna från de tre specialistagenterna.

Att sätta allow_delegation=False håller också arbetsflödet förutsägbart, medan max_iter begränsar hur många resonemangs- och verktygsanropscykler varje agent får göra.

6. Tilldela specialiserade researchuppgifter

Att skapa agenter definierar vem de är. Nu behöver vi tala om för var och en exakt vad den ska göra och vad dess slutliga utdata ska innehålla.

Definiera researchuppgifterna

Börja med fundamentalanalysen:

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,
)

Definiera sedan uppgiften för teknisk analys:

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,
)

För senaste händelser, skapa uppgiften för nyhetsresearch:

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,
)

Att ge varje agent en tydlig uppgift och ett utdataformat är viktigt. Det gör deras rapporter enklare för portföljförvaltaren att jämföra, i stället för att få helt olika svar från varje agent.

Skapa den slutliga beslutsuppgiften

Den slutliga uppgiften för samman alla tre rapporterna:

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,
    ],
)

Nyckeldelen är context. Den ger portföljförvaltaren tillgång till utdata från alla tre specialistuppgifterna, så att den kan jämföra fundamental-, teknisk- och nyhetssignal innan den producerar den slutliga KÖP-, BEHÅLL- eller SÄLJ-bedömningen.

Vid det här laget är våra agenter, verktyg och uppgifter redo. Nu kan vi koppla ihop allt i ett CrewAI-arbetsflöde och köra hela forskningsteamet.

7. Kör multiagent-forskningsbesättningen

Nu kan vi sätta ihop allt och köra det kompletta arbetsflödet för aktieresearch.

Skapa besättningen

Skapa en CrewAI-besättning med våra tre specialistagenter och portföljförvaltaren:

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,
)

Vi använder Process.sequential, så forskningsuppgifterna körs i ordning. Fundamental-, teknisk- och nyhetsagenterna gör klart sin analys först, och portföljförvaltaren får sedan dessa rapporter för att producera den slutliga bedömningen.

Kör forskningsteamet

Starta arbetsflödet asynkront:

result = await crew.kickoff_async()

Detta steg kan ta lite tid eftersom agenterna gör flera LLM- och verktygsanrop. I mitt test tog det kompletta arbetsflödet cirka 4 till 5 minuter att bli klart.

När det är klart, visa den slutliga rapporten från portföljförvaltaren:

print(result.raw)

Du bör få en utförlig rapport liknande resultatet ovan, inklusive:

• KÖP-, BEHÅLL- eller SÄLJ-signal
• Övergripande poäng
• Konfidensnivå
• Specialistpoäng
• Haussescenario
• Baissescenario
• Katalysatorer
• Risker
• Underbyggande källor

I det här exemplet analyserade agenterna NVIDIA oberoende och kombinerade sedan sina slutsatser till en enda evidensbaserad researchrapport. Här ser vi fördelen med multiagent-ansatsen: i stället för att be en modell göra allt på en gång fokuserar varje agent på sitt område innan portföljförvaltaren sammanför all research.

Om du stöter på problem med att köra koden ovan har jag även inkluderat hela Jupyter Notebook med all kod och alla utdata, som du kan granska eller köra själv: glm-stock-swarm/stock_analyst_crew.ipynb

8. Bygg och kör terminalgränssnittet

Efter att ha testat allt i Jupyter Notebook konverterade jag hela arbetsflödet till ett terminalgränssnitt (TUI). I stället för att köra varje notebook-cell manuellt kan du nu starta hela multiagent-aktieanalytikern med ett enda kommando.

Hela projektet, inklusive kod och installationsinstruktioner, finns på GitHub: glm-stock-swarm GitHub-repo.

Installera och kör appen

Börja med att klona repot:

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

Lägg till dina Z.ai-, Finnhub- och Tavily-API-nycklar i .env-filen och installera sedan alla beroenden med uv:

uv sync

Starta till sist TUI:n:

uv run glm-stock-swarm

Analysera en aktie

Gränssnittet har en enkel inmatningsruta där du kan ange valfri stödd aktieticker för att starta analysen.

När du skickar in tickern kan du se agenterna arbeta en efter en. Fundamental-analytikern börjar, följd av teknisk analytiker, nyhetsanalytiker och till sist portföljförvaltaren, som kombinerar allt till det slutliga beslutet.

I slutet genererar TUI:n en komplett rapport direkt i terminalen, inklusive fundamentalpoäng, teknisk poäng, nyhetspoäng, totalpoäng, konfidens, haussescenario, baissescenario, risker, katalysatorer och den slutliga KÖP-, BEHÅLL- eller SÄLJ-signalen.

Ställ följdfrågor

Jag lade också till en uppföljande chatt så att du inte behöver köra om hela multiagent-pipelinen varje gång du har en ny fråga.

Till exempel, efter att ha fått en SÄLJ-rekommendation frågade jag om jag borde sälja hela positionen eller bara en del av den.

I stället för att starta alla fyra agenterna igen använder applikationen kontexten från den genererade researchrapporten och skickar ett mycket snabbare uppföljningssvar.

Det gör applikationen mer praktisk eftersom den dyra multiagent-researchen körs en gång, medan följdfrågor kan återanvända den befintliga analysen.

Avslutande tankar

Det som är värt att rapportera från mina testkörningar är tillförlitligheten i verktygsanrop. Alla tre specialisterna valde rätt verktyg, respekterade N/A-konventionen i stället för att behandla saknade data som noll, och returnerade det poäng-och-evidens-format som portföljförvaltaren behövde. Det är oftast där billiga modeller fallerar.

Hastighet är avvägningen. Artificial Analysis mäter GLM-5.3-Flash till ungefär 45 utgående tokens per sekund på Z.ai:s API, vilket är i det lägre spannet för öppet viktade modeller av den här storleken, och det märks i de 4 till 5 minuter en fullständig besättning körs. Den får också 57 på deras intelligensindex jämfört med 60 för GLM-5.3, så du ger upp lite resonemangskvalitet, men det är en bra avvägning med tanke på att du bara betalar ungefär en tiondel av priset.

Inget av detta låser in dig. Att byta till OpenRouter, Hugging Face Inference eller en lokal modell via Ollama innebär oftast att ändra tre saker: API-nyckeln, modellnamnet och bas-URL:en. Samma sak för verktygen, där yfinance kan göra jobbet som Finnhub och Yahoo delar på här.

Nästa steg jag skulle ta är att koppla detta till ett pappershandels-API och schemalägga en morgonkörning. Håll det dock på ett demokonto. Detta byggdes för att lära ut agentdesign, inte för att handla.

Om du vill lära dig allt om agentisk AI från grunden rekommenderar jag vår AI Agent Fundamentals-kompetensbana som en utmärkt startpunkt.