Um agente autônomo de IA é construído a partir de três módulos isolados: o coletor de dados on-chain (RPC nodes e APIs de indexadores), o núcleo cognitivo (um LLM de baixa latência) e o gateway de execução de transações (Action Layer). Tentar atrelar a sua lógica de trading a modelos comerciais com censura pesada, como o GPT-4o, vai fazer as suas chaves API serem bloqueadas bem no meio de uma alta volatilidade. Os filtros internos de segurança deles costumam barrar o envio de sinais de trading, tratando isso direto como geração de risco financeiro. Para garantir uma automação estável, a boa é usar modelos open-weights sem censura (Llama 3.3 70B, DeepSeek V3), rodando em redes descentralizadas ou acessados via gateways especializados como a Venice AI.
A camada de execução precisa estar colada em uma infraestrutura com o menor ping possível. No setor de contratos perpétuos (perps), a API da Hyperliquid virou o padrão de mercado por rodar em uma appchain L1 dedicada, entregando um tempo de processamento de ordens na casa dos 0.1 segundos. O núcleo cognitivo não tem acesso direto à wallet: o modelo recebe um array de métricas de mercado e cospe uma recomendação em formato JSON. Depois, um script local em Python valida tudo contra limits bem rígidos antes de mandar a transação para a rede.
Se liga no código abaixo, e para ler a documentação da API da Hyperliquid é só acessar aqui: https://hyperliquid.gitbook.io/hyperliquid-docs/for-developers/api/info-endpoint/perpetuals
import osimport jsonimport requestsfrom eth_account import Account# puxando as chaves do ambiente — hardcodar chave privada no código é loucura total
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"):
# puxando o order book e o funding atual direto da appchain da 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 # se a HL estiver moscando, não mexe nas ordens — segurança em primeiro lugardef ask_brain(context):
if not VENICE_KEY:
return {"action": "HOLD", "pct": 0, "leverage": 1}
headers = {"Authorization": f"Bearer {VENICE_KEY}", "Content-Type": "application/json"}
# enquadrando o modelo para ele não cuspir textão. precisamos de JSON puro
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 # matando as alucinações e a criatividade no berço
}
try:
r = requests.post(VENICE_URL, json=payload, headers=headers, timeout=12)
out = r.json()["choices"][0]["message"]["content"].strip()
# limpando os backticks caso o modelo dê bola fora e mande formatação 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):
# disjuntor de segurança. se o modelo surtar, o código corta as asas dele
if decision["action"] not in ["BUY", "SELL"]:
return None
# limitando a alavancagem em até 3x e o tamanho da mão em até 5% do banca
leverage = min(int(decision.get("leverage", 1)), 3)
pct = min(int(decision.get("pct", 0)), 5)
if pct <= 0:
return None
# aplicando 0.3% de slippage para garantir que a ordem execute na hora
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 rodando para o endereço: {acc.address}")
ctx = get_market_data("ETH")
if not ctx:
print("[-] Sem conexão com a HL.")
return
raw_decision = ask_brain(ctx)
final_order = filter_limits(raw_decision, ctx["price"])
if final_order:
print(f"[+] Ordem gerada: {json.dumps(final_order)}")
else:
print("[*] Aguardando condições ideais, posição mantida.")if __name__ == "__main__":
run_pipeline()Automação de Yield Farming em mercados de Lending
No ecossistema de DeFi spot, os agentes geralmente são tunados para gerenciar posições de dívida em pools isolados (como Morpho Blue ou Fluid) ou no clássico Aave V3. O maior desafio aqui é monitorar o Health Factor (HF) sem parar, senão a sua posição vai ser liquidada e pulverizada antes que você perceba. O bot puxa o contrato PoolLens via RPC e calcula o risco seguindo a fórmula padrão:
Se o mercado derreter e o colateral começar a desvalorizar, o próprio agente precisa engatar uma desalavancagem parcial (Self-Deleverage). Para não queimar capital próprio, ele faz malabarismo com flash loans via Balancer ou Uniswap V3. Isso é vital porque em protocolos como o Morpho as penalidades de liquidação são brutais — dá para perder de 10% a 15% do banca em um piscar de olhos.
Se o seu bot fica pulando de pool em pool caçando o melhor APY, a sua lógica de código precisa calcular a taxa de gas na ponta do lápis. O script bate na API da ParaSwap ou da 1inch, puxa as cotações e desconta os custos de gas e slippage do retorno real. Se a ponte de stablecoins entre redes, tipo Arbitrum para Base, demorar mais de 72 horas para se pagar, mandamos o modelo pastar. A transação é travada na camada base do script, não importando o nível de euforia ou a prioridade que o LLM deu nas projeções.
Matriz de riscos para sistemas autônomos
Deixar uma carteira cripto sob o controle total de um LLM é pedir para dar ruim. As redes neurais trazem bugs bizarros e muito específicos que nunca existiram no trading algorítmico tradicional.
- Envenenamento de dados (Data Poisoning)
Atores maliciosos podem inflar transações fakes on-chain ou inundar o mercado com fake news. A IA enxerga isso como o "início de uma super tendência" e sai comprando tudo no topo histórico.
A solução: Verificação multi-fontes. O script deve cruzar os textos caóticos das redes sociais com os volumes reais de trading direto da blockchain. Se o pool não tiver liquidez real, o trade é ignorado. - Quebra de formatação (JSON Break)
O mercado entra em uma volatilidade insana, o modelo pina, esquece de fechar uma aspa, enfia um texto aleatório na resposta ou quebra a estrutura do JSON. O script crasha e o bot morre.
A solução: Try/Catch implacável. Qualquer erro de sintaxe ao fazer o parse do output do LLM deve jogar a lógica imediatamente para o modo HOLD (manter posição). Proteger o patrimônio é prioridade zero. - Frontrunning na rebalanceamento
O bot joga uma transação de rebalanceamento de liquidez no mempool público, virando alvo fácil para os robôs de MEV. O resultado é um slippage bizarro e prejuízo na certa.
A solução: RPCs privados. Todas as transações devem ser enviadas via Flashbots Protect ou BuilderRPC, pulando o mempool público para ninguém farejar as nossas ordens. - Gargalo e latência da rede
Em dias de dump violento, as taxas de gas na L1 disparam para a estratosfera. As transações do bot para injetar margem ficam mofando na fila e a posição acaba sendo liquidada de camarote.
A solução: Buffer de gas e liquidez. Deixe sempre de 15% a 20% do banca parados em tokens nativos (ETH/SOL) e configure o maxFeePerGas com uma folga de pelo menos +50% acima da mediana da rede.
Moral da história: terceirizar a gestão de risco para a parte cognitiva da IA é suicídio financeiro. O modelo funciona muito bem como um analista ágil para caçar distorções e pools lucrativos. Porém, o tamanho da mão, as alavancagens máximas e os gatilhos de stop de emergência precisam estar blindados e cravados direto no código de base.
```
