GLM-5.3-Flash Tutorial: Build a Multi-Agent Stock Analyst

Why Use GLM-5.3-Flash for Multi-Agent Application

GLM-5.3-Flash offers an impressive balance of performance, efficiency, and price. For a complete overview, read our GLM-5.3-Flash guide and our comparison piece against Qwen3.8-Flash-Next.

Competitive performance and efficiency

On the Artificial Analysis Intelligence Index, it scores 57, placing it among the leading models and making it competitive with several much more expensive frontier models. For instance:

• GPT-5.6 Sol also scores 57 (with high reasoning effort) but costs over 25x more for input and 40x more for output tokens.

• Claude Sonnet 5 scores even a bit lower, with 55 at its max reasoning effort. It is 20x/30x more expensive for input/output tokens than GLM-5.3-Flash.

It has 320B total parameters, but only around 18B parameters are active per token, allowing it to deliver strong performance while remaining relatively compute-efficient. 

Source: AI Model & API Providers Analysis | Artificial Analysis 

Attractive pricing

As I already mentioned, this performance comes at a comparatively low API pricing. At the time of writing, OpenRouter is offering GLM-5.3-Flash at a 50% discount, at $0.075 per million input tokens and $0.25 per million output tokens. 

Even at its regular price of $0.15/$0.50, it remains cheaper than models such as OpenAI's GPT-5.6 Luna, which costs $0.20/$1.20 (52 on the AA Intelligence Index with max reasoning). This makes it attractive not only for experiments, but also for larger, production-level agent applications. 

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

This matters even more when you are building a multi-agent system, because one user request can trigger many LLM calls behind the scenes. A single LLM agent might call the model several times for reasoning, tool selection, processing tool outputs, and generating its final response. If one agent makes around seven LLM calls and your workflow uses five agents, a single request could easily result in 35 or more LLM calls. 

The exact number depends on how your system is designed, but the point is simple: agentic workflows can become expensive very quickly. Using a capable model with low token pricing, such as GLM-5.3-Flash, can make a significant difference when moving from a small demo to a real production application. 

1. Set Up the Environment for GLM-5.3-Flash

Before building the multi-agent workflow, create API keys for Z.ai, Finnhub, and Tavily.

Create API keys

For Z.ai, make sure you use the regular API, not the GLM Coding Plan. The Coding Plan is intended for supported AI coding tools and should not be used as a general-purpose API for your own multi-agent application.

Generate a regular Z.ai API key and add a small amount of credit to your account. Since GLM-5.3-Flash is inexpensive, you only need a small balance to start testing.

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

You can also create free accounts on Finnhub and Tavily and generate API keys. Their free tiers are enough for testing this project.

Set up the project files

Next, create a .env file in your project folder and add the API keys:

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

Now, create a new Jupyter Notebook. We will first build and test the complete multi-agent workflow here, inspect each agent's output, and fix any issues before turning it into a proper application.

Install necessary libraries

We will use CrewAI to create and coordinate the agents, Finnhub for stock market data, and Tavily for real-time web search. Install the required Python packages:

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

Import libraries and API keys

Next, import the required libraries and load the API keys:

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

Finally, choose the stock you want the agents to analyze:

TICKER = "NVDA"

I will use NVIDIA (NVDA) throughout the notebook, but feel free to replace it with another ticker of your interest, such as AAPL, MSFT, or TSLA.

2. Configure GLM-5.3-Flash and the Data APIs

Now that the API keys are ready, we can connect the services that our agents will use throughout the project.

Start by initializing Finnhub for stock market data and Tavily for web search:

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

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

If you want to build financial agents and are unsure which data source to use, I recommend reading our guide to choosing the right stock market data API.

Next, configure GLM-5.3-Flash as the main LLM for our CrewAI agents. Z.ai provides an OpenAI-compatible API, so we can connect it directly through CrewAI's LLM class:

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 are keeping the temperature low because this application focuses on financial research and analysis, where we want the agents to produce more consistent and focused responses.

With the model, market data, and web search APIs connected, we can now start building the tools that our agents will use.

3. Collect Historical Market Data

Next, we need historical price data so our agents can understand how the stock has been performing over time.

For this, we will use Yahoo Finance's public chart endpoint to collect daily open, high, low, close, and volume data.

Download the price history

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 will collect about 450 days of history, which gives us enough data to calculate longer-term indicators such as the 200-day moving average.

Calculate technical indicators

Next, let’s calculate a few commonly used indicators: 

• Moving averages: average over the last 20-day, 50-day, and 200-day timeframes
• Relative Strength Index (RSI): Scale between 0 and 100 used to indicate if a stock is overbought (>70) and oversold (<30)
• Moving Average Convergence/Divergence (MACD): Difference of long-term and short-term Exponential Moving Averages (EMAs)

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

These indicators will be useful because they give the technical analysis agent a quick view of trends and momentum without having to ask the LLM to calculate everything itself.

Review the latest values

Now collect the data, calculate the indicators, and display the latest rows:

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

You should see the latest stock price together with its moving averages, RSI, and MACD, similar to the output above.

We will later pass this data to the technical analysis agent so it can identify price trends, momentum, and bullish or bearish signals.

4. Turn the Data Sources Into CrewAI Tools

Now that our data sources are working, we need to turn them into CrewAI tools. This allows the agents to call them directly whenever they need financial, technical, or news information.

Create the stock data tools

First, create a small helper function to keep numerical values clean and consistent:

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

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

Next, create the fundamentals tool. It uses Finnhub to retrieve the latest stock price, valuation metrics, growth, profitability, and other company fundamentals.

@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 will also create a technical analysis tool using the historical data and indicators from the previous section.

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

The important part here is the @tool decorator. It turns a normal Python function into a tool that a CrewAI agent can decide to call during a task.

Add the web search tool

For company news and recent developments, we will use CrewAI's Tavily search tool:

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

We limit the search to the last 30 days and return up to five results, which should give our research agents enough recent information without overwhelming them with unnecessary content.

Test the stock tools

Before creating the agents, run the two custom tools directly:

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

You should now see the latest fundamental metrics followed by the technical indicators for the selected stock.

5. Build the Multi-Agent Research Team

Now that the tools are ready, we can create our multi-agent research team.

We will use three specialist agents, one each for fundamental analysis, technical analysis, and recent news, plus a portfolio manager who combines their findings into the final assessment.

Create the specialist agents

First, create the fundamental analyst:

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

Next, create the technical analyst:

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

Then create the financial news analyst:

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

Each specialist only receives the tool it actually needs. This keeps the workflow focused and prevents agents from calling unrelated tools.

Create the portfolio manager

Finally, create the manager agent that will review all three specialist reports:

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

The portfolio manager does not need direct access to our data tools. Instead, it will work with the reports produced by the three specialist agents.

Setting allow_delegation=False also keeps the workflow predictable, while max_iter limits how many reasoning and tool-use cycles each agent can perform.

6. Assign Specialized Research Tasks

Creating agents defines who they are. Now we need to tell each one exactly what it should do and what its final output should contain.

Define the research tasks

Start with the fundamental analysis task:

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

Next, define the technical analysis task:

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

For recent developments, create the news research task:

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

Giving each agent a clear task and output format is important. It makes their reports easier for the portfolio manager to compare, instead of receiving completely different responses from every agent.

Create the final decision task

The final task brings all three reports together:

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

The key part is context. It gives the portfolio manager access to the outputs from all three specialist tasks, allowing it to compare the fundamental, technical, and news signals before producing the final BUY, HOLD, or SELL assessment.

At this point, our agents, tools, and tasks are all ready. Next, we can connect everything into a CrewAI workflow and run the complete research team.

7. Run the Multi-Agent Research Crew

Now we can bring everything together and run the complete stock research workflow.

Create the crew

Create a CrewAI crew containing our three specialist agents and the portfolio manager:

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 are using Process.sequential, so the research tasks run in order. The fundamental, technical, and news agents complete their analysis first, and the portfolio manager then receives those reports to produce the final assessment.

Run the research team

Start the workflow asynchronously:

result = await crew.kickoff_async()

This step can take some time because the agents are making multiple LLM and tool calls. In my test, the complete research workflow took around 4 to 5 minutes to finish.

Once it is complete, display the final portfolio manager report:

print(result.raw)

You should get a detailed report similar to the output above, including:

• BUY, HOLD, or SELL signal
• Overall score
• Confidence level
• Specialist scores
• Bull case
• Bear case
• Catalysts
• Risks
• Supporting sources

In this example, the agents analyzed NVIDIA independently and then combined their findings into a single evidence-based research report. This is where we can finally see the benefit of the multi-agent approach: instead of asking one model to do everything at once, each agent focuses on its own area before the portfolio manager brings all the research together.

If you face any issues running the above code, I have also included the complete Jupyter Notebook with all the code and outputs, which you can review or run yourself: glm-stock-swarm/stock_analyst_crew.ipynb

8. Build and Run the Terminal UI

After testing everything inside the Jupyter Notebook, I converted the complete workflow into a terminal user interface (TUI). Instead of running each notebook cell manually, you can now launch the entire multi-agent stock analyst with a single command.

The complete project, including the code and setup instructions, is available on GitHub: glm-stock-swarm GitHub repository.

Install and run the app

Start by cloning the repository:

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

Add your Z.ai, Finnhub, and Tavily API keys to the .env file, then install all the dependencies with uv:

uv sync

Finally, launch the TUI:

uv run glm-stock-swarm

Analyze a stock

The interface provides a simple input box where you can enter any supported stock ticker to start the analysis.

Once you submit the ticket, you can watch the agents work one by one. The fundamental analyst starts first, followed by the technical analyst, news analyst, and finally the portfolio manager, who combines everything into the final decision.

At the end, the TUI generates a complete report directly inside the terminal, including the fundamental score, technical score, news score, overall score, confidence, bull case, bear case, risks, catalysts, and the final BUY, HOLD, or SELL signal.

Ask follow-up questions

I also added a follow-up chat so you do not have to rerun the entire multi-agent pipeline each time you have another question.

For example, after receiving a SELL recommendation, I asked whether I should sell the entire position or only part of it.

Instead of launching all four agents again, the application uses the context from the generated research report and sends a much quicker follow-up response.

This makes the application more practical because the expensive multi-agent research runs once, while follow-up questions can reuse the existing analysis.

Final Thoughts

The thing worth reporting from my test runs is tool-calling reliability. All three specialists picked the right tool, respected the N/A convention instead of treating missing data as zero, and returned the score-and-evidence format the portfolio manager needed. That is usually where cheap models fall over.

Speed is the trade-off. Artificial Analysis clocks GLM-5.3-Flash at roughly 45 output tokens per second on Z.ai's API, which is on the low end for open-weight models of its size, and you feel it in the 4 to 5 minutes a full crew run takes. It also scores 57 on their intelligence index against 60 for GLM-5.3, so you are giving up a little reasoning quality, but that is a good trade considering you pay only roughly a tenth of the price.

None of this locks you in. Swapping to OpenRouter, Hugging Face Inference, or a local model through Ollama usually means changing three things: the API key, the model name, and the base URL. Same for the tools, where yfinance would do the job that Finnhub and Yahoo split here.

The next step I would take is wiring this to a paper-trading API and scheduling a morning run. Keep it on a demo account, though. This was built to teach agent design, not to trade.

If you want to learn everything about agentic AI from ground up, I recommend our AI Agent Fundamentals skill track as a great starting point.