Tutorial de GLM-5.3-Flash: crea un analista bursátil multiagente

Por qué usar GLM-5.3-Flash para una aplicación multiagente

GLM-5.3-Flash ofrece un equilibrio muy sólido entre rendimiento, eficiencia y precio. Para una visión completa, lee nuestra guía de GLM-5.3-Flash y nuestra comparativa con Qwen3.8-Flash-Next.

Rendimiento y eficiencia competitivos

En el Artificial Analysis Intelligence Index obtiene 57 puntos, ubicándolo entre los modelos líderes y haciéndolo competitivo frente a varios modelos punteros mucho más caros. Por ejemplo:

• GPT-5.6 Sol también logra 57 (con esfuerzo de razonamiento high) pero cuesta más de 25 veces en tokens de entrada y 40 veces en tokens de salida.

• Claude Sonnet 5 puntúa incluso un poco menos, con 55 en su esfuerzo de razonamiento max. Es 20x/30x más caro en entrada/salida que GLM-5.3-Flash.

Tiene 320B parámetros totales, pero solo unos 18B están activos por token, lo que le permite ofrecer gran rendimiento manteniendo una eficiencia computacional razonable. 

Fuente: AI Model & API Providers Analysis | Artificial Analysis 

Precio atractivo

Como ya he comentado, este rendimiento llega con un precio de API relativamente bajo. En el momento de escribir esto, OpenRouter ofrece GLM-5.3-Flash con un 50% de descuento, a $0.075 por millón de tokens de entrada y $0.25 por millón de tokens de salida. 

Incluso a su precio habitual de $0.15/$0.50, sigue siendo más barato que modelos como GPT-5.6 Luna de OpenAI, que cuesta $0.20/$1.20 (52 en el AA Intelligence Index con razonamiento max). Esto lo hace atractivo no solo para experimentar, sino también para aplicaciones multiagente de mayor escala y en producción. 

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

Esto importa aún más al crear un sistema multiagente, porque una sola solicitud de usuario puede disparar muchas llamadas al LLM en segundo plano. Un único agente LLM puede invocar el modelo varias veces para razonar, elegir herramientas, procesar salidas y generar la respuesta final. Si un agente hace unas siete llamadas y tu flujo usa cinco agentes, una sola solicitud podría acabar en 35 o más llamadas. 

El número exacto depende del diseño de tu sistema, pero la idea es clara: los flujos agentic pueden encarecerse rápido. Usar un modelo capaz y con precio bajo por token, como GLM-5.3-Flash, puede marcar una gran diferencia al pasar de una demo pequeña a una aplicación real en producción. 

1. Configura el entorno para GLM-5.3-Flash

Antes de construir el flujo multiagente, crea claves de API para Z.ai, Finnhub y Tavily.

Crea claves de API

Para Z.ai, asegúrate de usar la API normal, no el GLM Coding Plan. El Coding Plan está pensado para herramientas de código con soporte y no debe usarse como API de propósito general para tu aplicación multiagente.

Genera una clave de API estándar de Z.ai y añade un pequeño saldo a tu cuenta. Como GLM-5.3-Flash es económico, con poco crédito podrás empezar a probar.

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

También puedes crear cuentas gratuitas en Finnhub y Tavily y generar sus claves de API. Sus planes gratis bastan para probar este proyecto.

Prepara los archivos del proyecto

Después, crea un archivo .env en la carpeta del proyecto y añade las claves de API:

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

Ahora crea un nuevo Jupyter Notebook. Primero construiremos y probaremos aquí todo el flujo multiagente, inspeccionaremos la salida de cada agente y arreglaremos cualquier problema antes de convertirlo en una aplicación propiamente dicha.

Instala las librerías necesarias

Usaremos CrewAI para crear y coordinar los agentes, Finnhub para datos bursátiles y Tavily para búsqueda web en tiempo real. Instala los paquetes de Python requeridos:

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

Importa librerías y claves de API

A continuación, importa las librerías necesarias y carga las claves 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 último, elige el valor que quieres que analicen los agentes:

TICKER = "NVDA"

Yo usaré NVIDIA (NVDA) en todo el notebook, pero siéntete libre de cambiarlo por otro ticker que te interese, como AAPL, MSFT o TSLA.

2. Configura GLM-5.3-Flash y las APIs de datos

Ahora que las claves de API están listas, podemos conectar los servicios que usarán nuestros agentes durante el proyecto.

Empieza inicializando Finnhub para datos de mercado y Tavily para búsqueda web:

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

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

Si quieres crear agentes financieros y no tienes claro qué fuente de datos usar, te recomiendo leer nuestra guía para elegir la API de datos bursátiles adecuada.

A continuación, configura GLM-5.3-Flash como LLM principal para nuestros agentes de CrewAI. Z.ai ofrece una API compatible con OpenAI, así que podemos conectarlo directamente mediante la clase 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,
)

Mantenemos la temperatura baja porque esta aplicación se centra en investigación y análisis financieros, donde queremos respuestas más consistentes y enfocadas.

Conectados el modelo, los datos de mercado y las APIs de búsqueda web, ya podemos construir las herramientas que usarán nuestros agentes.

3. Recopila datos de mercado históricos

Ahora necesitamos precios históricos para que nuestros agentes entiendan cómo se ha comportado la acción a lo largo del tiempo.

Para ello, usaremos el endpoint público de gráficos de Yahoo Finance para obtener datos diarios de apertura, máximo, mínimo, cierre y volumen.

Descarga el historial de precios

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)

Recopilaremos unas 450 jornadas de historial, suficiente para calcular indicadores de largo plazo como la media móvil de 200 días.

Calcula indicadores técnicos

A continuación, calculemos algunos indicadores habituales: 

• Medias móviles: promedio de los últimos 20, 50 y 200 días
• Índice de fuerza relativa (RSI): escala entre 0 y 100 usada para indicar si un valor está sobrecomprado (>70) u sobrevendido (<30)
• MACD (convergencia/divergencia de medias móviles): diferencia entre EMAs de corto y largo plazo

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

Estos indicadores serán útiles porque ofrecen al agente técnico una visión rápida de tendencia y momentum sin tener que pedir al LLM que lo calcule todo.

Revisa los últimos valores

Ahora recoge los datos, calcula los indicadores y muestra las últimas filas:

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

Deberías ver el último precio junto con sus medias móviles, RSI y MACD, similar a la salida anterior.

Más adelante pasaremos estos datos al agente técnico para que identifique tendencia, momentum y señales alcistas o bajistas.

4. Convierte las fuentes de datos en herramientas de CrewAI

Ahora que nuestras fuentes de datos funcionan, debemos convertirlas en herramientas de CrewAI. Así los agentes podrán llamarlas directamente cuando necesiten información financiera, técnica o de noticias.

Crea las herramientas de datos bursátiles

Primero, crea una pequeña función auxiliar para formatear valores numéricos de forma uniforme:

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

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

Después, crea la herramienta de fundamentales. Usa Finnhub para obtener el último precio, métricas de valoración, crecimiento, rentabilidad y otros fundamentales de la compañía.

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

También crearemos una herramienta técnica usando los históricos e indicadores de la sección 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)}%"""

La parte clave aquí es el decorador @tool. Convierte una función normal de Python en una herramienta que un agente de CrewAI puede decidir llamar durante una tarea.

Añade la herramienta de búsqueda web

Para noticias y novedades de la empresa, usaremos la herramienta de búsqueda de Tavily de CrewAI:

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

Limitamos la búsqueda a los últimos 30 días y devolvemos hasta cinco resultados, suficiente para ofrecer información reciente sin saturar a los agentes con ruido.

Prueba las herramientas bursátiles

Antes de crear los agentes, ejecuta directamente las dos herramientas personalizadas:

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

Ahora deberías ver las métricas fundamentales más recientes seguidas de los indicadores técnicos de la acción seleccionada.

5. Construye el equipo de investigación multiagente

Con las herramientas listas, podemos crear nuestro equipo de investigación multiagente.

Usaremos tres agentes especialistas: uno en fundamentales, otro en técnicos y otro en noticias recientes, además de un gestor de cartera que combine sus conclusiones en la evaluación final.

Crea los agentes especialistas

Primero, el analista 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,
)

Después, el 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,
)

Luego, el analista de noticias financieras:

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 solo recibe la herramienta que necesita. Así el flujo se mantiene enfocado y evitamos llamadas a herramientas no relacionadas.

Crea el gestor de cartera

Por último, crea el agente gestor que revisará los tres informes especializados:

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

El gestor de cartera no necesita acceso directo a nuestras herramientas de datos. Trabajará con los informes de los tres especialistas.

Configurar allow_delegation=False mantiene el flujo predecible, y max_iter limita cuántos ciclos de razonamiento y uso de herramientas puede realizar cada agente.

6. Asigna tareas de investigación especializadas

Crear agentes define quiénes son. Ahora debemos indicar a cada uno exactamente qué debe hacer y qué debe incluir su salida final.

Define las tareas de investigación

Empieza con la tarea de análisis 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,
)

Ahora, define la tarea 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 las novedades recientes, crea la tarea de noticias:

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 una tarea y un formato de salida claros es importante. Facilita que el gestor de cartera compare informes, en lugar de recibir respuestas totalmente distintas de cada agente.

Crea la tarea de decisión final

La tarea final reúne los tres informes:

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 parte clave es context. Da al gestor de cartera acceso a las salidas de las tres tareas especializadas, permitiéndole comparar señales fundamentales, técnicas y de noticias antes de producir la evaluación final de COMPRA, MANTENER o VENDER.

En este punto, agentes, herramientas y tareas están listos. Ahora conectaremos todo en un flujo de CrewAI y ejecutaremos el equipo completo.

7. Ejecuta el equipo de investigación multiagente

Ya podemos poner todo en marcha y ejecutar el flujo completo de investigación bursátil.

Crea el crew

Crea un crew de CrewAI con nuestros tres especialistas y el gestor de cartera:

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

Usamos Process.sequential, así que las tareas se ejecutan en orden. Los agentes de fundamentales, técnicos y noticias completan su análisis primero, y el gestor de cartera recibe esos informes para producir la evaluación final.

Ejecuta el equipo de investigación

Inicia el flujo de forma asíncrona:

result = await crew.kickoff_async()

Este paso puede tardar porque los agentes realizan múltiples llamadas al LLM y a herramientas. En mis pruebas, el flujo completo tardó unos 4 a 5 minutos.

Una vez finalice, muestra el informe del gestor de cartera:

print(result.raw)

Deberías obtener un informe detallado, que incluya:

• Señal de COMPRA, MANTENER o VENDER
• Puntuación global
• Nivel de confianza
• Puntuaciones de especialistas
• Escenario alcista (bull case)
• Escenario bajista (bear case)
• Catalizadores
• Riesgos
• Fuentes de apoyo

En este ejemplo, los agentes analizaron NVIDIA de forma independiente y luego combinaron sus conclusiones en un único informe fundamentado. Aquí es donde se aprecia el beneficio del enfoque multiagente: en vez de pedir a un modelo que lo haga todo a la vez, cada agente se centra en su área y el gestor reúne toda la investigación.

Si tienes problemas al ejecutar el código anterior, también he incluido el Jupyter Notebook completo con todo el código y salidas, que puedes revisar o ejecutar tú mismo: glm-stock-swarm/stock_analyst_crew.ipynb

8. Crea y ejecuta la interfaz en terminal

Tras probar todo en el Jupyter Notebook, convertí el flujo completo en una interfaz de usuario en terminal (TUI). En lugar de ejecutar cada celda a mano, ahora puedes lanzar el analista multiagente con un solo comando.

El proyecto completo, con código e instrucciones de instalación, está disponible en GitHub: repositorio glm-stock-swarm en GitHub.

Instala y ejecuta la app

Empieza clonando el repositorio:

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

Añade tus claves de API de Z.ai, Finnhub y Tavily al archivo .env y luego instala todas las dependencias con uv:

uv sync

Por último, lanza la TUI:

uv run glm-stock-swarm

Analiza una acción

La interfaz ofrece un cuadro de entrada sencillo para que introduzcas cualquier ticker compatible y empieces el análisis.

Una vez envíes el ticker, podrás ver cómo trabajan los agentes uno a uno. Empieza el analista fundamental, seguido del técnico, el de noticias y, por último, el gestor de cartera, que combina todo para la decisión final.

Al final, la TUI genera un informe completo directamente en la terminal, con la puntuación de fundamentales, técnicos y noticias, la puntuación global, la confianza, bull case, bear case, riesgos, catalizadores y la señal final de COMPRA, MANTENER o VENDER.

Haz preguntas de seguimiento

También añadí un chat de seguimiento para que no tengas que volver a ejecutar todo el pipeline multiagente cada vez que tengas otra duda.

Por ejemplo, tras recibir una recomendación de VENDER, pregunté si debía vender toda la posición o solo una parte.

En lugar de lanzar de nuevo los cuatro agentes, la aplicación usa el contexto del informe generado y envía una respuesta de seguimiento mucho más rápida.

Esto hace la aplicación más práctica: la investigación multiagente, que es cara, se ejecuta una vez, mientras que las preguntas posteriores reutilizan el análisis existente.

Reflexiones finales

Lo más destacable de mis pruebas es la fiabilidad al llamar herramientas. Los tres especialistas eligieron bien la herramienta, respetaron la convención N/A en vez de tratar datos faltantes como cero y devolvieron el formato de puntuación y evidencias que necesitaba el gestor. Ahí es donde los modelos baratos suelen fallar.

La contrapartida es la velocidad. Artificial Analysis mide GLM-5.3-Flash en unas 45 tokens de salida por segundo con la API de Z.ai, que está en el rango bajo para modelos open-weight de su tamaño, y se nota en los 4 a 5 minutos que tarda una ejecución completa del crew. También puntúa 57 en su índice frente a 60 de GLM-5.3, así que cedes un poco de calidad de razonamiento, pero es un buen intercambio considerando que pagas aproximadamente una décima parte.

Nada de esto te ata a una plataforma. Cambiar a OpenRouter, Hugging Face Inference o un modelo local con Ollama suele implicar tres cosas: la clave de API, el nombre del modelo y la URL base. Lo mismo con las herramientas, donde yfinance podría hacer el trabajo que aquí reparten Finnhub y Yahoo.

El siguiente paso que daría sería conectarlo a una API de paper trading y programar una ejecución por la mañana. Eso sí, mantenlo en una cuenta demo. Esto está pensado para enseñar diseño de agentes, no para operar.

Si quieres aprender sobre IA agentic desde cero, te recomiendo nuestro itinerario de habilidades AI Agent Fundamentals como un gran punto de partida.