Un agente de IA autónomo se compone de tres módulos aislados: un recolector de datos on-chain (nodos RPC y APIs de indexadores), un núcleo cognitivo (un LLM con baja latencia de respuesta) y una pasarela de ejecución de transacciones (Action Layer). Intentar vincular tu lógica de trading a modelos comerciales con censura estricta como GPT-4o va a terminar con tus API keys bloqueadas en plena época de alta volatilidad; sus filtros de seguridad internos suelen clasificar la transmisión de señales de trading como generación de riesgo financiero. Para una automatización estable, se utilizan modelos open-weights sin censura (Llama 3.3 70B, DeepSeek V3) desplegados en hostings descentralizados o accesibles a través de endpoints especializados como Venice AI.
La capa de ejecución se conecta a una infraestructura con el menor ping posible. En el sector de los contratos de futuros perpetuos (perps), la API de Hyperliquid se ha convertido en el estándar de la industria gracias a que corre en una appchain L1 dedicada con una velocidad de procesamiento de órdenes de hasta 0.1 segundos. El núcleo cognitivo no tiene acceso directo a la wallet: el modelo recibe un array de métricas de mercado y devuelve una recomendación en formato JSON, la cual un script local en Python valida contra límites estrictos (hard limits) antes de mandarla a la red.
Acá tienen el código, y pueden leer la documentación de la API de Hyperliquid aquí: https://hyperliquid.gitbook.io/hyperliquid-docs/for-developers/api/info-endpoint/perpetuals
import osimport jsonimport requestsfrom eth_account import Account# Extraemos las llaves del entorno; meter las private keys a fuego en el código es de nivel psiquiátrico
VENICE_URL = "https://api.venice.ai/api/v1/chat/completions"
VENICE_KEY = os.getenv("VENICE_API_KEY", "")
WALLET_KEY = os.getenv("AGENT_PRIVATE_KEY", "0x0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef")def get_market_data(coin="ETH"):
# Parseamos el order book y el funding actual directo de la appchain de Hyperliquid
try:
r = requests.post("https://api.hyperliquid.xyz/info", json={"type": "metaAndAssetCtxs"}, timeout=8)
res = r.json()
universe = res[0]["universe"]
ctxs = res[1]
idx = next(i for i, a in enumerate(universe) if a["name"] == coin)
return {
"ticker": coin,
"price": float(ctxs[idx]["midPrice"]),
"funding": float(ctxs[idx]["funding"]),
"oi": float(ctxs[idx]["openInterest"])
}
except Exception:
return None # Si HL tiene lag, no tocamos las órdenes; la seguridad es lo primerodef ask_brain(context):
if not VENICE_KEY:
return {"action": "HOLD", "pct": 0, "leverage": 1}
headers = {"Authorization": f"Bearer {VENICE_KEY}", "Content-Type": "application/json"}
# Ponemos límites al modelo para que no escupa texto basura. Necesitamos un JSON limpio
prompt = (
"You are a trading bot execution engine. Analyze the metrics. "
"Return JSON ONLY. No markdown blocks, no text explanations. "
"Format: {\"action\": \"BUY\"|\"SELL\"|\"HOLD\", \"pct\": int, \"leverage\": int}"
)
payload = {
"model": "llama-3.3-70b-instruct",
"messages": [
{"role": "system", "content": prompt},
{"role": "user", "content": f"Data: {json.dumps(context)}"}
],
"temperature": 0.1 # Eliminamos alucinaciones y creatividad para máxima precisión
}
try:
r = requests.post(VENICE_URL, json=payload, headers=headers, timeout=12)
out = r.json()["choices"][0]["message"]["content"].strip()
# Volamos los backticks si el modelo se apendejó y metió formato de código
if "```" in out:
out = out.split("```")[1].replace("json", "").strip()
return json.loads(out)
except Exception:
return {"action": "HOLD", "pct": 0, "leverage": 1}def filter_limits(decision, current_price):
# Fusible de seguridad estricto. Si el modelo se vuelve loco, el código lo corta de raíz
if decision["action"] not in ["BUY", "SELL"]:
return None
# Limitamos el apalancamiento a 3x y el volumen al 5% del tamaño de la cuenta (depo)
leverage = min(int(decision.get("leverage", 1)), 3)
pct = min(int(decision.get("pct", 0)), 5)
if pct <= 0:
return None
# Calculamos un slippage del 0.3% para asegurar que la orden se ejecute de inmediato
slip = 1.003 if decision["action"] == "BUY" else 0.997
return {
"coin": "ETH",
"side": decision["action"],
"px": round(current_price * slip, 2),
"lev": leverage,
"size_pct": pct
}def run_pipeline():
if WALLET_KEY != "0x0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef":
acc = Account.from_key(WALLET_KEY)
print(f"[+] Bot ejecutándose para la dirección: {acc.address}")
ctx = get_market_data("ETH")
if not ctx:
print("[-] Sin conexión con HL.")
return
raw_decision = ask_brain(ctx)
final_order = filter_limits(raw_decision, ctx["price"])
if final_order:
print(f"[+] Orden generada: {json.dumps(final_order)}")
else:
print("[*] Esperando condiciones óptimas, la posición sigue sin cambios.")if __name__ == "__main__":
run_pipeline()Automatización de Yield Farming en mercados de préstamo (Lending Markets)
En el sector DeFi spot, a los agentes se les suele entrenar para gestionar posiciones de deuda en pools aislados (estilo Morpho Blue o Fluid) o en el viejo y confiable Aave V3. El mayor dolor de cabeza aquí es calcular constantemente el factor de salud (Health Factor, o sea, el HF), de lo contrario te van a liquidar la posición y dejarla hecha pedazos. El bot consulta el contrato de PoolLens vía RPC y calcula los riesgos por el método clásico:
Si el mercado se va al piso y el colateral empieza a devaluarse, el agente tiene que iniciar por sí mismo un desapalancamiento parcial (Self-Deleverage). Para no quemar su propia liquidez, opera con flashloans a través de Balancer o Uniswap V3. Esto es crítico porque en protocolos como Morpho, la penalización por liquidación (liquidation penalty) es enorme; puedes perder el 10-15% de todo tu capital depositado en un segundo.
Si el bot anda saltando entre pools persiguiendo un APY jugoso, necesitas meter en el código de forma obligatoria un cálculo estricto del costo del gas por transacción. El script consulta la API de ParaSwap o 1inch, obtiene las cotizaciones y descuenta del rendimiento las pérdidas por gas y deslizamiento (slippage). Si el puente de las stablecoins, por ejemplo de Arbitrum a Base, va a tardar más de 72 horas en amortizar su costo, mandamos el modelo a volar. La transacción se bloquea al nivel de la lógica base del script, incluso si el LLM está con prioridad máxima y euforia total en sus predicciones.
Matriz de riesgos para sistemas autónomos
Cederle el control total de la wallet a un LLM siempre es un riesgo monumental. Las redes neuronales traen consigo un montón de bugs muy específicos que en el trading algorítmico tradicional jamás han existido.
- Envenenamiento de datos y feeds (Data Poisoning)
Los atacantes empiezan a inflar transacciones falsas on-chain o a spamear fake news. La IA procesa esto como el "inicio de una fuerte tendencia alcista" y se lanza a comprar en los máximos históricos (en los hais).
Solución: Consulta multifuente. El script debe contrastar el delirio textual de las redes sociales con los volúmenes de trading puros (raw volumes) extraídos directo de la blockchain. Si no hay liquidez real en el pool, ignoramos la señal por completo. - Errores de formato y rotura de estructura (JSON Break)
El mercado entra en una volatilidad salvaje, el modelo entra en pánico, se le olvida cerrar una comilla, mete texto de más en el output o rompe el JSON. El script crashea y el bot se queda colgado.
Solución: Bloques try/except ultra estrictos. Cualquier error sintáctico al parsear la respuesta del LLM debe congelar la lógica de inmediato y pasar a modo HOLD (retención de posiciones). La seguridad de los fondos está por encima de todo. - Frontrunning en los rebalanceos
El bot lanza una transacción para mover liquidez al mempool público, donde los bots de MEV ya lo están cazando. Al final nos comemos un slippage brutal y perdemos pasta en el camino.
Solución: RPCs privados. Todas las transacciones se envían estrictamente mediante Flashbots Protect o BuilderRPC saltándose el mempool público para que nadie pueda trackear nuestros movimientos. - Lag de red en cascada
En una caída fuerte del mercado, el gas en L1 se dispara a la luna. Las transacciones del bot para aportar más margen se quedan atrapadas en la cola como un lastre muerto, y la posición termina siendo liquidada sin que puedas hacer nada.
Solución: Reserva estratégica de gas y liquidez. Siempre dejamos un 15-20% del depósito intocable en los tokens nativos (ETH/SOL) en el balance y configuramos en el maxFeePerGas un margen de mínimo un +50% sobre el valor mediano actual de la red.
De todo esto se deduce que dejar la gestión de riesgos en manos de la parte cognitiva es un suicidio financiero. El modelo es excelente únicamente como un analista flexible para detectar correlaciones ocultas y pools rentables. Pero el tamaño de las posiciones, los apalancamientos máximos y los disparadores de salida de emergencia (emergency exits) tienen que estar grabados a fuego (hardcoded) en el código base.
