Tutoriel GLM-5.3-Flash : créer un analyste boursier multi-agents

Pourquoi utiliser GLM-5.3-Flash pour une application multi-agents

GLM-5.3-Flash offre un excellent équilibre entre performance, efficacité et coût. Pour une vue d’ensemble complète, lisez notre guide GLM-5.3-Flash ainsi que notre comparatif avec Qwen3.8-Flash-Next.

Des performances et une efficacité compétitives

Sur l’Artificial Analysis Intelligence Index, il obtient 57, ce qui le place parmi les meilleurs modèles et le rend concurrentiel face à plusieurs modèles de pointe bien plus onéreux. Par exemple :

• GPT-5.6 Sol obtient également 57 (avec un effort de raisonnement high) mais coûte plus de 25× pour l’entrée et 40× pour les jetons de sortie.

• Claude Sonnet 5 fait légèrement moins bien, avec 55 à son effort de raisonnement max. Il est 20×/30× plus cher qu’GLM-5.3-Flash pour les jetons d’entrée/sortie.

Il compte 320 milliards de paramètres au total, mais seulement environ 18 milliards sont actifs par jeton, ce qui lui permet d’offrir de bonnes performances tout en restant relativement économe en calcul. 

Source : AI Model & API Providers Analysis | Artificial Analysis 

Un prix attractif

Comme indiqué, ces performances s’accompagnent d’un tarif API très compétitif. Au moment d’écrire ces lignes, OpenRouter propose GLM-5.3-Flash à -50 %, à 0,075 $ le million de jetons en entrée et 0,25 $ le million de jetons en sortie. 

Même à son prix courant de 0,15 $/0,50 $, il reste moins cher que des modèles comme GPT-5.6 Luna d’OpenAI, facturé 0,20 $/1,20 $ (score de 52 sur l’AA Intelligence Index en max reasoning). C’est intéressant non seulement pour l’expérimentation, mais aussi pour des applications agents à l’échelle production. 

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

C’est d’autant plus crucial pour un système multi-agents, car une requête utilisateur peut déclencher de nombreux appels LLM en arrière-plan. Un seul agent LLM peut appeler le modèle plusieurs fois pour raisonner, choisir un outil, traiter ses sorties et générer sa réponse finale. Si un agent effectue environ sept appels et que votre flux en mobilise cinq, une requête peut facilement dépasser 35 appels LLM. 

Le nombre exact dépend de votre architecture, mais l’idée est simple : les workflows agentiques peuvent devenir coûteux très vite. Utiliser un modèle performant au coût par jeton faible, comme GLM-5.3-Flash, fait une vraie différence lorsqu’on passe d’une démo à une application en production. 

1. Configurer l’environnement pour GLM-5.3-Flash

Avant de construire le workflow multi-agents, créez des clés API pour Z.ai, Finnhub et Tavily.

Créer les clés API

Pour Z.ai, assurez-vous d’utiliser l’API standard, et non le GLM Coding Plan. Le Coding Plan est destiné aux outils de coding assisté pris en charge et ne doit pas être utilisé comme API généraliste pour votre propre application multi-agents.

Générez une clé API Z.ai standard et créditez légèrement votre compte. GLM-5.3-Flash étant peu coûteux, un petit solde suffit pour commencer les tests.

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

Vous pouvez aussi créer des comptes gratuits sur Finnhub et Tavily et générer des clés API. Leurs offres gratuites suffisent pour tester ce projet.

Mettre en place les fichiers du projet

Créez ensuite un fichier .env dans votre dossier de projet et ajoutez les clés API :

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

Créez maintenant un nouveau Jupyter Notebook. Nous y construirons et testerons d’abord le workflow multi-agents complet, examinerons la sortie de chaque agent et corrigerons d’éventuels problèmes avant d’en faire une application aboutie.

Installer les bibliothèques nécessaires

Nous utiliserons CrewAI pour créer et coordonner les agents, Finnhub pour les données de marché, et Tavily pour la recherche web en temps réel. Installez les packages Python requis :

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

Importer les bibliothèques et les clés API

Importez ensuite les bibliothèques nécessaires et chargez les clés 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")

Enfin, choisissez l’action que vous souhaitez faire analyser par les agents :

TICKER = "NVDA"

J’utiliserai NVIDIA (NVDA) tout au long du notebook, mais n’hésitez pas à remplacer par un autre ticker qui vous intéresse, comme AAPL, MSFT ou TSLA.

2. Configurer GLM-5.3-Flash et les APIs de données

Maintenant que les clés API sont prêtes, connectons les services que nos agents utiliseront tout au long du projet.

Commencez par initialiser Finnhub pour les données de marché et Tavily pour la recherche web :

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

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

Si vous souhaitez créer des agents financiers et hésitez sur la source de données, nous vous recommandons notre guide pour choisir la bonne API de données de marché.

Configurez ensuite GLM-5.3-Flash comme LLM principal de nos agents CrewAI. Z.ai fournit une API compatible OpenAI, nous pouvons donc le connecter directement via la classe LLM de 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,
)

Nous gardons une température basse, car cette application porte sur la recherche et l’analyse financières : nous voulons des réponses plus cohérentes et ciblées.

Avec le modèle, les données de marché et la recherche web configurés, nous pouvons commencer à créer les outils dont nos agents auront besoin.

3. Collecter les données de marché historiques

Nous avons besoin de prix historiques pour que nos agents comprennent l’évolution de l’action dans le temps.

Pour cela, nous utiliserons l’endpoint public de graphiques de Yahoo Finance afin de récupérer les données quotidiennes d’ouverture, haut, bas, clôture et volume.

Télécharger l’historique des prix

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)

Nous collecterons environ 450 jours d’historique, suffisant pour calculer des indicateurs de long terme comme la moyenne mobile à 200 jours.

Calculer les indicateurs techniques

Calculons maintenant quelques indicateurs courants : 

• Moyennes mobiles : moyennes sur 20, 50 et 200 jours
• Relative Strength Index (RSI) : échelle de 0 à 100 indiquant la surachat (>70) ou la survente (<30)
• Moving Average Convergence/Divergence (MACD) : différence entre EMAs long terme et court terme

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

Ces indicateurs seront utiles : l’agent d’analyse technique obtient ainsi une vue rapide des tendances et du momentum sans demander au LLM de tout calculer.

Vérifier les dernières valeurs

Récupérez maintenant les données, calculez les indicateurs et affichez les dernières lignes :

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

Vous devriez voir le dernier cours de l’action accompagné de ses moyennes mobiles, du RSI et du MACD, comme ci-dessus.

Nous transmettrons ensuite ces données à l’agent d’analyse technique pour identifier tendances, momentum et signaux haussiers/baissiers.

4. Transformer les sources de données en outils CrewAI

Maintenant que nos sources de données fonctionnent, transformons-les en outils CrewAI. Les agents pourront ainsi les appeler directement lorsqu’ils auront besoin d’informations financières, techniques ou d’actualités.

Créer les outils de données boursières

Commencez par une petite fonction d’aide pour formater proprement les valeurs numériques :

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

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

Créez ensuite l’outil des fondamentaux. Il utilise Finnhub pour récupérer le dernier cours, les métriques de valorisation, la croissance, la rentabilité et d’autres fondamentaux de l’entreprise.

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

Nous créerons aussi un outil d’analyse technique en utilisant les historiques et indicateurs de la section précédente.

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

L’élément important ici est le décorateur @tool. Il transforme une fonction Python classique en outil qu’un agent CrewAI peut décider d’appeler pendant une tâche.

Ajouter l’outil de recherche web

Pour les actualités et développements récents, nous utiliserons l’outil de recherche Tavily de CrewAI :

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

Nous limitons la recherche aux 30 derniers jours avec un maximum de cinq résultats, ce qui devrait fournir suffisamment d’informations récentes sans noyer les agents.

Tester les outils boursiers

Avant de créer les agents, exécutez directement les deux outils personnalisés :

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

Vous devriez désormais voir les derniers indicateurs fondamentaux suivis des indicateurs techniques pour l’action choisie.

5. Construire l’équipe de recherche multi-agents

Maintenant que les outils sont prêts, nous pouvons créer notre équipe de recherche multi-agents.

Nous utiliserons trois agents spécialistes — fondamentaux, techniques et actualités — et un gérant de portefeuille qui combine leurs conclusions pour produire l’évaluation finale.

Créer les agents spécialistes

Commencez par l’analyste des fondamentaux :

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

Créez ensuite l’analyste technique :

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

Puis l’analyste des actualités financières :

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

Chaque spécialiste ne reçoit que l’outil dont il a réellement besoin. Cela garde le flux ciblé et évite les appels d’outils hors sujet.

Créer le gérant de portefeuille

Créez enfin l’agent manager qui passera en revue les trois rapports :

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

Le gérant n’a pas besoin d’un accès direct aux outils de données : il travaille à partir des rapports produits par les trois spécialistes.

Mettre allow_delegation=False garde le flux prévisible, et max_iter limite le nombre de cycles raisonnement+outils par agent.

6. Attribuer des tâches de recherche spécialisées

Créer des agents définit qui ils sont. Nous devons maintenant préciser à chacun ce qu’il doit faire et ce que doit contenir sa sortie finale.

Définir les tâches de recherche

Commencez par la tâche d’analyse fondamentale :

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

Définissez ensuite la tâche d’analyse technique :

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

Pour les développements récents, créez la tâche d’actualités :

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

Donner à chaque agent une tâche claire et un format de sortie harmonisé est essentiel. Le gérant de portefeuille peut ainsi comparer plus facilement leurs rapports, plutôt que de recevoir des réponses hétérogènes.

Créer la tâche de décision finale

La dernière tâche réunit les trois rapports :

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

La clé est le context : il donne au gérant accès aux sorties des trois spécialistes, lui permettant de comparer signaux fondamentaux, techniques et actualités avant de produire l’évaluation finale BUY, HOLD ou SELL.

À ce stade, nos agents, outils et tâches sont prêts. Connectons le tout dans un workflow CrewAI et lançons l’équipe de recherche complète.

7. Exécuter l’équipe de recherche multi-agents

Rassemblons maintenant tous les éléments et exécutons le flux d’analyse boursière complet.

Créer la crew

Créez une crew CrewAI avec nos trois spécialistes et le gérant de portefeuille :

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

Nous utilisons Process.sequential, pour exécuter les tâches dans l’ordre : fondamentaux, techniques et actualités d’abord ; puis le gérant produit l’évaluation finale.

Lancer l’équipe de recherche

Démarrez le workflow de façon asynchrone :

result = await crew.kickoff_async()

Cette étape peut prendre du temps, les agents effectuant plusieurs appels LLM et outils. Lors de mes tests, l’analyse complète a pris environ 4 à 5 minutes.

Une fois terminée, affichez le rapport final du gérant :

print(result.raw)

Vous devriez obtenir un rapport détaillé semblable à l’exemple ci-dessus, comprenant :

• Un signal BUY, HOLD ou SELL
• Un score global
• Un niveau de confiance
• Les scores des spécialistes
• Le scénario haussier (bull case)
• Le scénario baissier (bear case)
• Les catalyseurs
• Les risques
• Les sources d’appui

Dans cet exemple, les agents ont analysé NVIDIA de manière indépendante puis combiné leurs conclusions en un rapport de recherche fondé sur des preuves. C’est là que l’approche multi-agents montre son intérêt : plutôt que de tout demander à un seul modèle, chaque agent traite son domaine avant que le gérant ne rassemble l’ensemble.

Si vous rencontrez des difficultés pour exécuter le code, j’ai également inclus le Jupyter Notebook complet avec tout le code et les sorties, à consulter ou exécuter : glm-stock-swarm/stock_analyst_crew.ipynb

8. Créer et exécuter l’interface terminal

Après avoir tout testé dans le Jupyter Notebook, j’ai converti le workflow complet en interface utilisateur en terminal (TUI). Au lieu d’exécuter manuellement chaque cellule, vous pouvez lancer tout l’analyste boursier multi-agents avec une seule commande.

Le projet complet, incluant le code et les instructions d’installation, est disponible sur GitHub : dépôt GitHub glm-stock-swarm.

Installer et lancer l’app

Commencez par cloner le dépôt :

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

Ajoutez vos clés API Z.ai, Finnhub et Tavily au fichier .env, puis installez toutes les dépendances avec uv :

uv sync

Enfin, lancez la TUI :

uv run glm-stock-swarm

Analyser une action

L’interface propose un simple champ où saisir n’importe quel ticker pris en charge pour démarrer l’analyse.

Une fois le ticker soumis, vous pouvez suivre le travail des agents l’un après l’autre : fondamentaux, techniques, actualités, puis gérant de portefeuille qui consolide tout pour la décision finale.

À la fin, la TUI génère un rapport complet directement dans le terminal, incluant score fondamental, score technique, score actualités, score global, confiance, bull case, bear case, risques, catalyseurs et le signal final BUY, HOLD ou SELL.

Poser des questions de suivi

J’ai également ajouté un chat de suivi pour éviter de relancer tout le pipeline multi-agents à chaque nouvelle question.

Par exemple, après une recommandation SELL, j’ai demandé s’il fallait vendre l’intégralité de la position ou seulement une partie.

Au lieu de relancer les quatre agents, l’application réutilise le contexte du rapport généré et renvoie une réponse de suivi beaucoup plus rapide.

Cela rend l’application plus pratique : la recherche multi-agents, coûteuse, s’exécute une fois, tandis que les questions de suivi réutilisent l’analyse existante.

Pour conclure

Le point saillant de mes tests : la fiabilité des appels d’outils. Les trois spécialistes ont choisi le bon outil, respecté la convention N/A (données manquantes ≠ zéro) et renvoyé le format score+preuves attendu par le gérant. C’est souvent là que les modèles bon marché trébuchent.

La vitesse est la contrepartie. Artificial Analysis mesure GLM-5.3-Flash à environ 45 jetons de sortie par seconde via l’API de Z.ai, ce qui est dans le bas de la fourchette pour des open-weights de cette taille — et cela se ressent dans les 4 à 5 minutes d’un run complet. Il obtient aussi 57 sur leur indice d’intelligence contre 60 pour GLM-5.3 : vous perdez un peu en raisonnement, mais le compromis est intéressant puisqu’on paie environ un dixième du prix.

Rien n’est figé. Passer à OpenRouter, Hugging Face Inference ou un modèle local via Ollama revient souvent à changer trois éléments : la clé API, le nom du modèle et l’URL de base. Idem pour les outils, où yfinance pourrait regrouper ce que Finnhub et Yahoo se partagent ici.

La prochaine étape serait de relier cela à une API de paper-trading et de planifier un run matinal. Gardez-le toutefois sur un compte démo. Cet outil sert à enseigner la conception d’agents, pas à trader.

Pour apprendre l’IA agentique de A à Z, nous vous recommandons notre parcours de compétences AI Agent Fundamentals comme excellent point de départ.