Tutorial GLM-5.3-Flash: crie um analista de ações multiagente

Por que usar GLM-5.3-Flash em uma aplicação multiagente

GLM-5.3-Flash oferece um equilíbrio impressionante entre desempenho, eficiência e preço. Para uma visão completa, leia nosso guia GLM-5.3-Flash e nossa comparação com o Qwen3.8-Flash-Next.

Desempenho e eficiência competitivos

No Artificial Analysis Intelligence Index, ele marca 57, colocando-o entre os modelos líderes e tornando-o competitivo com vários modelos de fronteira muito mais caros. Por exemplo:

• GPT-5.6 Sol também marca 57 (com esforço de raciocínio high), mas custa mais de 25x para tokens de entrada e 40x para tokens de saída.

• Claude Sonnet 5 fica um pouco abaixo, com 55 em seu esforço de raciocínio max. Ele é 20x/30x mais caro em entrada/saída do que o GLM-5.3-Flash.

Ele tem 320B de parâmetros totais, mas apenas cerca de 18B ficam ativos por token, o que permite alto desempenho com eficiência computacional relativamente boa. 

Fonte: AI Model & API Providers Analysis | Artificial Analysis 

Preço atraente

Como já mencionei, esse desempenho vem com uma precificação de API relativamente baixa. No momento em que escrevo, o OpenRouter está oferecendo GLM-5.3-Flash com 50% de desconto, a US$ 0,075 por milhão de tokens de entrada e US$ 0,25 por milhão de tokens de saída. 

Mesmo no preço padrão de US$ 0,15/US$ 0,50, continua mais barato do que modelos como o GPT-5.6 Luna da OpenAI, que custa US$ 0,20/US$ 1,20 (52 no AA Intelligence Index com raciocínio max). Isso o torna atraente não só para experimentos, mas também para aplicações de agentes maiores, em produção. 

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

Isso importa ainda mais quando você constrói um sistema multiagente, porque um único pedido do usuário pode disparar muitas chamadas de LLM nos bastidores. Um único agente de LLM pode chamar o modelo várias vezes para raciocinar, escolher ferramentas, processar saídas e gerar sua resposta final. Se um agente faz cerca de sete chamadas e seu fluxo usa cinco agentes, um único pedido pode facilmente resultar em 35 ou mais chamadas. 

O número exato depende do design do seu sistema, mas o ponto é simples: fluxos agentic podem ficar caros rapidamente. Usar um modelo capaz com preço de token baixo, como o GLM-5.3-Flash, faz muita diferença ao sair de um demo pequeno para uma aplicação real de produção. 

1. Prepare o ambiente para o GLM-5.3-Flash

Antes de construir o fluxo multiagente, crie as chaves de API para Z.ai, Finnhub e Tavily.

Crie as chaves de API

No Z.ai, garanta que você use a API regular, não o GLM Coding Plan. O Coding Plan é voltado para ferramentas de codificação com suporte e não deve ser usado como API genérica para sua aplicação multiagente.

Gere uma chave de API regular do Z.ai e adicione um pequeno crédito na sua conta. Como o GLM-5.3-Flash é barato, você precisa de um saldo pequeno para começar os testes.

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

Você também pode criar contas gratuitas no Finnhub e no Tavily e gerar as chaves de API. Os planos grátis são suficientes para testar este projeto.

Configure os arquivos do projeto

Em seguida, crie um arquivo .env na pasta do projeto e adicione as chaves de API:

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

Agora, crie um novo Jupyter Notebook. Primeiro vamos construir e testar todo o fluxo multiagente aqui, inspecionar a saída de cada agente e ajustar qualquer problema antes de transformar isso em uma aplicação de verdade.

Instale as bibliotecas necessárias

Usaremos CrewAI para criar e coordenar os agentes, Finnhub para dados do mercado e Tavily para busca na web em tempo real. Instale os pacotes Python necessários:

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

Importe as bibliotecas e as chaves

Agora, importe as bibliotecas necessárias e carregue as chaves de 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")

Por fim, escolha a ação que você quer que os agentes analisem:

TICKER = "NVDA"

Usarei NVIDIA (NVDA) ao longo do notebook, mas fique à vontade para trocar por outro ticker de seu interesse, como AAPL, MSFT ou TSLA.

2. Configure o GLM-5.3-Flash e as APIs de dados

Com as chaves em mãos, podemos conectar os serviços que nossos agentes usarão ao longo do projeto.

Comece inicializando o Finnhub para dados de mercado e o Tavily para buscas na web:

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

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

Se você quer criar agentes para finanças e não sabe qual fonte de dados usar, recomendo ler nosso guia sobre como escolher a API certa de dados de mercado.

Agora, configure o GLM-5.3-Flash como LLM principal dos nossos agentes CrewAI. O Z.ai fornece uma API compatível com a da OpenAI, então podemos conectar diretamente via a classe LLM do 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,
)

Mantemos a temperatura baixa porque esta aplicação foca em pesquisa e análise financeiras, onde queremos respostas consistentes e objetivas.

Com o modelo, os dados de mercado e a busca conectados, podemos começar a construir as ferramentas que os agentes vão usar.

3. Coletar dados históricos de mercado

Precisamos de dados históricos de preço para que os agentes entendam como a ação vem se comportando ao longo do tempo.

Para isso, vamos usar o endpoint público de gráficos do Yahoo Finance para coletar dados diários de abertura, máxima, mínima, fechamento e volume.

Baixar o histórico de preços

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)

Vamos coletar cerca de 450 dias de histórico, o suficiente para calcular indicadores de prazo mais longo, como a média móvel de 200 dias.

Calcular indicadores técnicos

Agora, vamos calcular alguns indicadores bem usados: 

• Médias móveis: média dos últimos 20, 50 e 200 dias
• Índice de Força Relativa (RSI): escala entre 0 e 100 que indica sobrecompra (>70) e sobrevenda (<30)
• MACD (Moving Average Convergence/Divergence): diferença entre EMAs de curto e longo prazo

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

Esses indicadores ajudam porque dão ao agente técnico uma visão rápida de tendência e momento, sem precisar pedir ao LLM para calcular tudo.

Revisar os valores mais recentes

Agora colete os dados, calcule os indicadores e exiba as últimas linhas:

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

Você deve ver o preço mais recente junto com as médias móveis, RSI e MACD, parecido com o exemplo acima.

Depois vamos passar esses dados para o agente técnico para identificar tendências, momentum e sinais de alta ou baixa.

4. Transforme as fontes de dados em ferramentas do CrewAI

Com as fontes de dados funcionando, precisamos transformá-las em ferramentas do CrewAI. Assim, os agentes podem chamá-las diretamente sempre que precisarem de informações financeiras, técnicas ou de notícias.

Crie as ferramentas de dados da ação

Primeiro, crie uma pequena função auxiliar para manter os valores numéricos limpos e consistentes:

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

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

Em seguida, crie a ferramenta de fundamentos. Ela usa o Finnhub para obter o preço mais recente, métricas de valuation, crescimento, lucratividade e outros fundamentos da empresa.

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

Também vamos criar uma ferramenta de análise técnica usando os dados históricos e indicadores da seção anterior.

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

A parte importante aqui é o decorador @tool. Ele transforma uma função Python normal em uma ferramenta que um agente CrewAI pode decidir chamar durante uma tarefa.

Adicione a ferramenta de busca na web

Para notícias da empresa e fatos recentes, vamos usar a ferramenta de busca Tavily do CrewAI:

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

Limitamos a busca aos últimos 30 dias e a até cinco resultados, o suficiente para munir os agentes de pesquisa com informação recente sem sobrecarregar com conteúdo desnecessário.

Teste as ferramentas de ações

Antes de criar os agentes, rode diretamente as duas ferramentas personalizadas:

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

Agora você deve ver as métricas fundamentais mais recentes seguidas dos indicadores técnicos da ação selecionada.

5. Monte a equipe de pesquisa multiagente

Com as ferramentas prontas, podemos criar nossa equipe de pesquisa multiagente.

Usaremos três agentes especialistas — um para fundamentos, um para técnicos e um para notícias — além de um gestor de portfólio que combina tudo na avaliação final.

Crie os agentes especialistas

Comece pelo analista fundamentalista:

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

Agora, crie o analista técnico:

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

Depois, crie o analista de notícias financeiras:

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

Cada especialista recebe apenas a ferramenta de que realmente precisa. Isso mantém o fluxo focado e evita que agentes chamem ferramentas irrelevantes.

Crie o gestor de portfólio

Por fim, crie o agente gestor que vai revisar os três relatórios:

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

O gestor de portfólio não precisa de acesso direto às ferramentas de dados. Ele trabalha com os relatórios produzidos pelos três especialistas.

Definir allow_delegation=False mantém o fluxo previsível, enquanto max_iter limita quantos ciclos de raciocínio e uso de ferramentas cada agente pode executar.

6. Atribua tarefas especializadas de pesquisa

Criar agentes define quem eles são. Agora precisamos dizer exatamente o que cada um deve fazer e o que o resultado final deve conter.

Defina as tarefas de pesquisa

Comece com a tarefa de análise fundamentalista:

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

Agora, a tarefa de análise técnica:

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

Para os acontecimentos recentes, crie a tarefa de pesquisa de notícias:

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

Dar a cada agente uma tarefa clara e um formato de saída definido é importante. Isso facilita a comparação pelo gestor de portfólio, em vez de receber respostas totalmente diferentes de cada agente.

Crie a tarefa de decisão final

A tarefa final reúne os três relatórios:

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

A parte-chave é o context. Ele dá ao gestor acesso às saídas das três tarefas, permitindo comparar os sinais fundamental, técnico e de notícias antes de produzir a avaliação final de BUY, HOLD ou SELL.

Neste ponto, nossos agentes, ferramentas e tarefas estão prontos. Agora podemos conectar tudo em um fluxo do CrewAI e rodar a equipe completa de pesquisa.

7. Execute a equipe de pesquisa multiagente

Agora podemos juntar tudo e rodar o fluxo completo de pesquisa de ações.

Crie a crew

Crie uma crew do CrewAI com nossos três especialistas e o gestor de portfólio:

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

Estamos usando Process.sequential, então as tarefas rodam em ordem. Os agentes de fundamentos, técnicos e notícias concluem primeiro suas análises; depois, o gestor recebe os relatórios e produz a avaliação final.

Execute a equipe de pesquisa

Inicie o fluxo de forma assíncrona:

result = await crew.kickoff_async()

Essa etapa pode levar um tempo, pois os agentes fazem múltiplas chamadas de LLM e ferramentas. Nos meus testes, o fluxo completo levou cerca de 4 a 5 minutos.

Quando terminar, exiba o relatório final do gestor:

print(result.raw)

Você deve receber um relatório detalhado parecido com o acima, incluindo:

• Sinal BUY, HOLD ou SELL
• Score geral
• Nível de confiança
• Scores dos especialistas
• Cenário otimista (bull case)
• Cenário pessimista (bear case)
• Catalisadores
• Riscos
• Fontes de apoio

Neste exemplo, os agentes analisaram a NVIDIA de forma independente e depois uniram os achados em um único relatório baseado em evidências. Aqui vemos a vantagem do approach multiagente: em vez de pedir a um único modelo para fazer tudo de uma vez, cada agente foca em sua área e o gestor consolida a pesquisa.

Se tiver problemas para rodar o código acima, incluí também o Jupyter Notebook completo com todo o código e saídas, que você pode revisar ou executar: glm-stock-swarm/stock_analyst_crew.ipynb

8. Construa e execute a interface no terminal

Depois de testar tudo no Jupyter Notebook, converti o fluxo completo em uma interface de usuário no terminal (TUI). Em vez de executar cada célula manualmente, você pode iniciar todo o analista multiagente com um único comando.

O projeto completo, com código e instruções de setup, está no GitHub: repositório glm-stock-swarm no GitHub.

Instale e rode o app

Comece clonando o repositório:

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

Adicione suas chaves de API do Z.ai, Finnhub e Tavily ao arquivo .env, depois instale as dependências com o uv:

uv sync

Por fim, inicie a TUI:

uv run glm-stock-swarm

Analise uma ação

A interface traz um campo simples onde você pode digitar qualquer ticker suportado para iniciar a análise.

Depois de enviar o ticker, você pode acompanhar o trabalho dos agentes. O analista fundamentalista começa, seguido pelo técnico, pelo analista de notícias e, por fim, pelo gestor de portfólio, que consolida tudo na decisão final.

Ao final, a TUI gera um relatório completo direto no terminal, incluindo score fundamental, técnico e de notícias, score geral, confiança, bull case, bear case, riscos, catalisadores e o sinal final de BUY, HOLD ou SELL.

Faça perguntas de acompanhamento

Também adicionei um chat de acompanhamento para você não precisar rodar todo o pipeline multiagente sempre que tiver uma nova dúvida.

Por exemplo, depois de receber uma recomendação de SELL, perguntei se deveria vender a posição inteira ou apenas parte.

Em vez de relançar os quatro agentes, o app usa o contexto do relatório de pesquisa gerado e envia uma resposta de acompanhamento muito mais rápida.

Isso deixa a aplicação mais prática: a pesquisa multiagente — mais cara — roda uma vez, enquanto as perguntas de acompanhamento reaproveitam a análise existente.

Considerações finais

O que vale relatar dos meus testes é a confiabilidade na chamada de ferramentas. Os três especialistas escolheram a ferramenta certa, respeitaram a convenção N/A em vez de tratar dado ausente como zero e retornaram o formato de score+evidências que o gestor precisava. É aí que modelos baratos costumam falhar.

Velocidade é o trade-off. O Artificial Analysis mede o GLM-5.3-Flash em cerca de 45 tokens de saída por segundo na API do Z.ai, o que é baixo para modelos open-weight desse porte — e dá para sentir nos 4 a 5 minutos de uma execução completa da crew. Ele também marca 57 no índice deles, contra 60 do GLM-5.3, então você abre mão de um pouco de qualidade de raciocínio, mas é uma troca justa considerando que paga algo como um décimo do preço.

Nada disso te prende. Migrar para OpenRouter, Hugging Face Inference ou um modelo local via Ollama geralmente significa trocar três coisas: a chave de API, o nome do modelo e a base URL. O mesmo vale para as ferramentas — yfinance faria o trabalho que aqui dividimos entre Finnhub e Yahoo.

O próximo passo que eu daria é ligar isso a uma API de paper trading e agendar uma execução matinal. Mantenha em conta demo. Isso foi feito para ensinar design de agentes, não para operar no mercado.

Se você quer aprender tudo sobre IA agentic do zero, recomendo nossa trilha de habilidades AI Agent Fundamentals como ótimo ponto de partida.