Tutorial GLM-5.3-Flash: Construiește un analist multi-agent pentru acțiuni

De ce să folosești GLM-5.3-Flash pentru o aplicație multi-agent

GLM-5.3-Flash oferă un echilibru remarcabil între performanță, eficiență și preț. Pentru o privire de ansamblu completă, citește ghidul nostru GLM-5.3-Flash și comparativul cu Qwen3.8-Flash-Next.

Performanță și eficiență competitive

Pe Artificial Analysis Intelligence Index, obține un scor de 57, ceea ce îl plasează printre modelele de top și îl face competitiv cu mai multe modele de vârf mult mai scumpe. De exemplu:

• GPT-5.6 Sol obține tot 57 (cu efort de raționare high), dar costă de peste 25x mai mult pentru tokenii de input și de 40x mai mult pentru tokenii de output.

• Claude Sonnet 5 are chiar un pic mai puțin, 55 la efort de raționare max. Este de 20x/30x mai scump pentru input/output comparativ cu GLM-5.3-Flash.

Are 320B parametri în total, dar doar aproximativ 18B parametri sunt activi per token, ceea ce îi permite să ofere performanță puternică rămânând relativ eficient din punct de vedere computațional. 

Sursă: AI Model & API Providers Analysis | Artificial Analysis 

Preț atractiv

După cum am menționat, această performanță vine la un preț API relativ scăzut. La momentul scrierii, OpenRouter oferă GLM-5.3-Flash cu o reducere de 50%, la 0,075 $ per milion de tokeni de input și 0,25 $ per milion de tokeni de output. 

Chiar și la prețul standard de 0,15 $/0,50 $, rămâne mai ieftin decât modele precum GPT-5.6 Luna de la OpenAI, care costă 0,20 $/1,20 $ (52 pe AA Intelligence Index cu raționare max). Asta îl face atractiv nu doar pentru experimente, ci și pentru aplicații agentice mai mari, de nivel de producție. 

Sursă: GLM 5.3 Flash - API Pricing & Benchmarks | OpenRouter 

Acest lucru contează și mai mult când construiești un sistem multi-agent, deoarece o singură cerere a utilizatorului poate declanșa multe apeluri LLM în fundal. Un singur agent LLM ar putea apela modelul de mai multe ori pentru raționare, alegerea instrumentelor, procesarea rezultatelor și generarea răspunsului final. Dacă un agent face aproximativ șapte apeluri LLM și fluxul tău folosește cinci agenți, o singură cerere poate ajunge ușor la 35 sau mai multe apeluri LLM. 

Numărul exact depinde de designul sistemului, dar ideea e simplă: fluxurile agentice pot deveni scumpe rapid. Folosirea unui model capabil cu preț scăzut pe token, precum GLM-5.3-Flash, poate face o diferență majoră când treci de la un demo mic la o aplicație reală de producție. 

1. Configurează mediul pentru GLM-5.3-Flash

Înainte de a construi fluxul multi-agent, creează chei API pentru Z.ai, Finnhub și Tavily.

Creează chei API

Pentru Z.ai, asigură-te că folosești API-ul obișnuit, nu GLM Coding Plan. Coding Plan este destinat instrumentelor de cod asistat suportate de AI și nu ar trebui folosit ca API general pentru propria ta aplicație multi-agent.

Generează o cheie API Z.ai obișnuită și adaugă o sumă mică de credit în cont. Deoarece GLM-5.3-Flash este ieftin, ai nevoie doar de un sold mic pentru a începe testele.

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

Poți crea și conturi gratuite pe Finnhub și Tavily și să generezi chei API. Planurile gratuite sunt suficiente pentru testarea acestui proiect.

Configurează fișierele proiectului

În continuare, creează un fișier .env în folderul proiectului și adaugă cheile API:

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

Acum, creează un nou Jupyter Notebook. Vom construi și testa mai întâi aici fluxul multi-agent complet, vom inspecta ieșirile fiecărui agent și vom remedia eventualele probleme înainte de a-l transforma într-o aplicație propriu-zisă.

Instalează bibliotecile necesare

Vom folosi CrewAI pentru a crea și coordona agenții, Finnhub pentru date de piață, și Tavily pentru căutare web în timp real. Instalează pachetele Python necesare:

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

Importă bibliotecile și cheile API

În continuare, importă bibliotecile necesare și încarcă cheile API:

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

La final, alege acțiunea pe care vrei ca agenții să o analizeze:

TICKER = "NVDA"

Eu voi folosi NVIDIA (NVDA) pe tot parcursul notebook-ului, dar poți înlocui cu orice alt ticker de interes, cum ar fi AAPL, MSFT sau TSLA.

2. Configurează GLM-5.3-Flash și API-urile de date

Acum că cheile API sunt gata, putem conecta serviciile pe care agenții noștri le vor folosi în tot proiectul.

Începe prin a inițializa Finnhub pentru date de piață și Tavily pentru căutare web:

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

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

Dacă vrei să construiești agenți financiari și nu ești sigur ce sursă de date să folosești, îți recomand ghidul nostru despre alegerea API-ului potrivit pentru date de piață.

Apoi, configurează GLM-5.3-Flash ca LLM principal pentru agenții noștri CrewAI. Z.ai oferă un API compatibil cu OpenAI, așa că îl putem conecta direct prin clasa LLM a 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,
)

Păstrăm temperatura scăzută deoarece aplicația se concentrează pe cercetare și analiză financiară, unde vrem ca agenții să producă răspunsuri mai consecvente și mai bine focalizate.

Cu modelul, datele de piață și API-urile de căutare web conectate, putem începe să construim instrumentele pe care agenții le vor folosi.

3. Colectează date istorice de piață

În continuare, avem nevoie de date istorice de preț pentru ca agenții să înțeleagă cum a evoluat acțiunea în timp.

Pentru asta, vom folosi endpoint-ul public de grafice al Yahoo Finance pentru a colecta date zilnice de deschidere, maxim, minim, închidere și volum.

Descarcă istoricul prețurilor

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)

Vom colecta aproximativ 450 de zile de istoric, ceea ce ne oferă suficiente date pentru a calcula indicatori pe termen lung precum media mobilă la 200 de zile.

Calculează indicatorii tehnici

În continuare, hai să calculăm câțiva indicatori utilizați frecvent: 

• Media mobilă: media pe ultimele intervale de 20, 50 și 200 de zile
• Relative Strength Index (RSI): scară între 0 și 100 folosită pentru a indica dacă o acțiune este supra-cumpărată (>70) sau supra-vândută (<30)
• Moving Average Convergence/Divergence (MACD): diferența dintre mediile mobile exponențiale (EMA) pe termen scurt și lung

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

Acești indicatori vor fi utili deoarece oferă agentului de analiză tehnică o privire rapidă asupra tendințelor și momentum-ului fără a cere LLM-ului să calculeze totul singur.

Verifică ultimele valori

Acum colectează datele, calculează indicatorii și afișează ultimele rânduri:

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

Ar trebui să vezi cel mai recent preț al acțiunii împreună cu mediile mobile, RSI și MACD, similar cu rezultatul de mai sus.

Ulterior vom transmite aceste date agentului de analiză tehnică pentru a identifica tendințe de preț, momentum și semnale bullish sau bearish.

4. Transformă sursele de date în instrumente CrewAI

Acum că sursele de date funcționează, trebuie să le transformăm în instrumente CrewAI. Asta le permite agenților să le apeleze direct ori de câte ori au nevoie de informații financiare, tehnice sau din știri.

Creează instrumentele pentru date de acțiuni

Mai întâi, creează o mică funcție helper pentru a păstra valorile numerice curate și consecvente:

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

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

Apoi, creează instrumentul pentru fundamente. Folosește Finnhub pentru a prelua ultimul preț al acțiunii, metrici de evaluare, creștere, profitabilitate și alte fundamente ale companiei.

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

Vom crea și un instrument de analiză tehnică folosind datele istorice și indicatorii din secțiunea anterioară.

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

Partea importantă aici este decoratorul @tool. El transformă o funcție Python obișnuită într-un instrument pe care un agent CrewAI îl poate decide să-l apeleze în timpul unei sarcini.

Adaugă instrumentul de căutare web

Pentru știrile companiei și evoluții recente, vom folosi instrumentul de căutare Tavily din CrewAI:

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

Limităm căutarea la ultimele 30 de zile și returnăm până la cinci rezultate, ceea ce ar trebui să ofere agenților de cercetare suficiente informații recente fără să-i copleșească cu conținut inutil.

Testează instrumentele pentru acțiuni

Înainte de a crea agenții, rulează direct cele două instrumente personalizate:

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

Ar trebui să vezi acum cele mai recente metrici fundamentale urmate de indicatorii tehnici pentru acțiunea selectată.

5. Construiește echipa de cercetare multi-agent

Acum că instrumentele sunt gata, putem crea echipa noastră de cercetare multi-agent.

Vom folosi trei agenți specialiști, câte unul pentru analiza fundamentală, analiza tehnică și știrile recente, plus un manager de portofoliu care combină concluziile lor în evaluarea finală.

Creează agenții specialiști

Mai întâi, creează analistul fundamental:

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

Apoi, creează analistul tehnic:

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

Apoi creează analistul de știri financiare:

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

Fiecare specialist primește doar instrumentul de care are nevoie. Asta menține fluxul concentrat și previne agenții să apeleze instrumente nerelevante.

Creează managerul de portofoliu

În final, creează agentul manager care va revizui toate cele trei rapoarte ale specialiștilor:

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

Managerul de portofoliu nu are nevoie de acces direct la instrumentele noastre de date. În schimb, va lucra cu rapoartele produse de cei trei agenți specialiști.

Setarea allow_delegation=False menține fluxul previzibil, iar max_iter limitează numărul de cicluri de raționare și utilizare a instrumentelor pe care le poate face fiecare agent.

6. Atribuie sarcini de cercetare specializate

Crearea agenților definește cine sunt. Acum trebuie să le spunem fiecăruia exact ce ar trebui să facă și ce ar trebui să conțină ieșirea sa finală.

Definește sarcinile de cercetare

Începe cu sarcina de analiză fundamentală:

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

Apoi, definește sarcina de analiză tehnică:

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

Pentru evoluții recente, creează sarcina de cercetare a știrilor:

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

A oferi fiecărui agent o sarcină clară și un format de ieșire este important. Le face rapoartele mai ușor de comparat pentru managerul de portofoliu, în loc să primească răspunsuri complet diferite de la fiecare agent.

Creează sarcina de decizie finală

Sarcina finală reunește toate cele trei rapoarte:

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

Partea-cheie este context. Îi oferă managerului de portofoliu acces la rezultatele tuturor celor trei sarcini ale specialiștilor, permițându-i să compare semnalele din fundamente, tehnice și știri înainte de a produce evaluarea finală CUMPĂRĂ, PĂSTREAZĂ sau VINDE.

În acest punct, agenții, instrumentele și sarcinile noastre sunt gata. În continuare, putem conecta totul într-un flux CrewAI și rula echipa completă de cercetare.

7. Rulează echipa de cercetare multi-agent

Acum putem pune totul cap la cap și rula fluxul complet de cercetare a acțiunilor.

Creează echipa

Creează o echipă CrewAI care conține cei trei agenți specialiști și managerul de portofoliu:

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

Folosim Process.sequential, astfel încât sarcinile de cercetare rulează pe rând. Agenții de fundamente, tehnici și știri își finalizează analizele mai întâi, iar apoi managerul de portofoliu primește aceste rapoarte pentru a produce evaluarea finală.

Rulează echipa de cercetare

Pornește fluxul asincron:

result = await crew.kickoff_async()

Acest pas poate dura ceva deoarece agenții fac mai multe apeluri LLM și către instrumente. În testul meu, fluxul complet de cercetare a durat aproximativ 4–5 minute.

După finalizare, afișează raportul final al managerului de portofoliu:

print(result.raw)

Ar trebui să obții un raport detaliat similar cu rezultatul de mai sus, incluzând:

• Semnal CUMPĂRĂ, PĂSTREAZĂ sau VINDE
• Scor general
• Nivel de încredere
• Scorurile specialiștilor
• Scenariu pozitiv (bull case)
• Scenariu negativ (bear case)
• Catalizatori
• Riscuri
• Surse suport

În acest exemplu, agenții au analizat NVIDIA independent și apoi și-au combinat concluziile într-un singur raport de cercetare bazat pe dovezi. Aici vedem în sfârșit beneficiul abordării multi-agent: în loc să ceri unui singur model să facă totul deodată, fiecare agent se concentrează pe propria arie înainte ca managerul de portofoliu să reunească toată cercetarea.

Dacă întâmpini probleme la rularea codului de mai sus, am inclus și Jupyter Notebook-ul complet cu tot codul și rezultatele, pe care îl poți consulta sau rula: glm-stock-swarm/stock_analyst_crew.ipynb

8. Construiește și rulează interfața din terminal

După testarea tuturor componentelor în Jupyter Notebook, am convertit fluxul complet într-o interfață de utilizator în terminal (TUI). În loc să rulezi manual fiecare celulă din notebook, acum poți lansa întregul analist multi-agent pentru acțiuni cu o singură comandă.

Proiectul complet, inclusiv codul și instrucțiunile de configurare, este disponibil pe GitHub: repository-ul glm-stock-swarm pe GitHub.

Instalează și rulează aplicația

Începe prin a clona repository-ul:

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

Adaugă cheile tale API Z.ai, Finnhub și Tavily în fișierul .env, apoi instalează toate dependențele cu uv:

uv sync

În final, pornește TUI:

uv run glm-stock-swarm

Analizează o acțiune

Interfața oferă o căsuță de input în care poți introduce orice ticker suportat pentru a începe analiza.

După ce trimiți tickerul, poți urmări cum lucrează agenții pe rând. Analistul fundamental începe primul, urmat de analistul tehnic, analistul de știri și, în final, managerul de portofoliu, care combină totul în decizia finală.

La final, TUI generează un raport complet direct în terminal, incluzând scorul fundamental, scorul tehnic, scorul știrilor, scorul general, încrederea, scenariul pozitiv, scenariul negativ, riscurile, catalizatorii și semnalul final CUMPĂRĂ, PĂSTREAZĂ sau VINDE.

Pune întrebări ulterioare

Am adăugat și un chat pentru întrebări ulterioare, ca să nu fie nevoie să rulezi întregul pipeline multi-agent de fiecare dată când ai o nouă întrebare.

De exemplu, după ce am primit o recomandare de VÂNZARE, am întrebat dacă ar trebui să vând întreaga poziție sau doar o parte.

În loc să lanseze din nou toți cei patru agenți, aplicația folosește contextul din raportul de cercetare generat și trimite un răspuns ulterior mult mai rapid.

Asta face aplicația mai practică, deoarece cercetarea multi-agent, care este costisitoare, rulează o dată, în timp ce întrebările ulterioare pot reutiliza analiza existentă.

Gânduri finale

Ceea ce merită menționat din rulările mele de test este fiabilitatea apelării instrumentelor. Toți cei trei specialiști au ales instrumentul potrivit, au respectat convenția N/A în loc să trateze datele lipsă ca zero și au returnat formatul cu scor și dovezi de care avea nevoie managerul de portofoliu. De obicei aici dau greș modelele ieftine.

Viteza este compromisă. Artificial Analysis măsoară GLM-5.3-Flash la aproximativ 45 de tokeni de ieșire pe secundă pe API-ul Z.ai, ceea ce este la limita inferioară pentru modelele open-weight de această dimensiune, și simți asta în cele 4–5 minute pe care le ia o rulare completă a echipei. De asemenea, obține 57 pe indicele lor de inteligență față de 60 pentru GLM-5.3, deci renunți la puțină calitate a raționării, dar este un compromis bun având în vedere că plătești cam o zecime din preț.

Nimic din toate acestea nu te blochează. Trecerea la OpenRouter, Hugging Face Inference sau un model local prin Ollama înseamnă de obicei schimbarea a trei lucruri: cheia API, numele modelului și URL-ul de bază. La fel și pentru instrumente, unde yfinance ar putea face treaba pe care Finnhub și Yahoo o împart aici.

Următorul pas pe care l-aș face este conectarea la un API de paper-trading și programarea unei rulari dimineața. Ține-l însă pe un cont demo. Acesta a fost construit pentru a preda designul agenților, nu pentru tranzacționare.

Dacă vrei să înveți totul despre AI agentic de la zero, îți recomand AI Agent Fundamentals ca un excelent punct de pornire.