Ein autonomer KI-Agent besteht im Wesentlichen aus drei isolierten Modulen: dem On-Chain-Datenkollektor (RPC-Nodes und Indexer-APIs), dem kognitiven Kern (eine LLM mit minimaler Latenz) und dem Transaction Execution Gateway (Action Layer). Wer versucht, seine Trading-Logik an kommerzielle, stark zensierte Modelle wie GPT-4o zu koppeln, riskiert in Phasen hoher Volatilität prompte API-Sperren. Die internen Sicherheitsfilter dieser Anbieter stufen das Weiterleiten von Trading-Signalen oft direkt als unzulässiges finanzielles Risiko ein. Für eine stabile Automatisierung greift man daher lieber auf unzensierte Open-Weights-Modelle wie Llama 3.3 70B oder DeepSeek V3 zurück, die entweder dezentral gehostet oder über spezialisierte Gateways wie Venice AI angesprochen werden.
Der Execution Layer muss zwingend an eine Infrastruktur mit minimalem Ping angebunden sein. Im Bereich der Kredite und unbefristeten Terminkontrakte (Perpetuals/Perps) hat sich die Hyperliquid API als Goldstandard etabliert – dank ihrer dedizierten L1-Appchain, die Order-Verarbeitungszeiten von unter 0,1 Sekunden ermöglicht. Der kognitive Kern hat dabei keinen direkten Zugriff auf die Wallet: Das Modell füttert sich aus einem Array von Marktmetriken und spuckt lediglich eine Empfehlung im JSON-Format aus. Ein lokales Python-Skript validiert diese dann gegen knallharte Risikolimits, bevor irgendetwas On-Chain geschickt wird.
Hier ist der Code, und die Dokumentation zur Hyperliquid API findet ihr hier: https://hyperliquid.gitbook.io/hyperliquid-docs/for-developers/api/info-endpoint/perpetuals
import osimport jsonimport requestsfrom eth_account import Account# Keys aus den Environment-Variablen ziehen – Private Keys im Code zu hardcoden ist absolut hirnrissig
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"):
# Orderbuch und aktuelles Funding direkt von der Hyperliquid-Appchain abgreifen
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 # Wenn HL laggt, Finger weg von den Ordern – Sicherheit geht vordef ask_brain(context):
if not VENICE_KEY:
return {"action": "HOLD", "pct": 0, "leverage": 1}
headers = {"Authorization": f"Bearer {VENICE_KEY}", "Content-Type": "application/json"}
# Das Modell in ein enges Korsett zwingen, damit es keinen Textmüll labert. Wir brauchen pures JSON
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 # Halluzinationen und Kreativität komplett im Keim ersticken
}
try:
r = requests.post(VENICE_URL, json=payload, headers=headers, timeout=12)
out = r.json()["choices"][0]["message"]["content"].strip()
# Backticks killen, falls das Modell pennt und Code-Formatierung mitsendet
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):
# Die eiserne Reißleine. Wenn das Modell durchdreht, fängt das Skript es ab
if decision["action"] not in ["BUY", "SELL"]:
return None
# Hebel auf max 3x und Volumen auf max 5% der Wallet limitieren
leverage = min(int(decision.get("leverage", 1)), 3)
pct = min(int(decision.get("pct", 0)), 5)
if pct <= 0:
return None
# 0.3% Slippage einpreisen, damit die Order sofort durchgeht
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 gestartet für Adresse: {acc.address}")
ctx = get_market_data("ETH")
if not ctx:
print("[-] Keine Verbindung zu HL.")
return
raw_decision = ask_brain(ctx)
final_order = filter_limits(raw_decision, ctx["price"])
if final_order:
print(f"[+] Order generiert: {json.dumps(final_order)}")
else:
print("[*] Warte auf bessere Konditionen, Position bleibt unverändert.")if __name__ == "__main__":
run_pipeline()Yield Farming Automatisierung auf Lending-Märkten
Im Spot-DeFi-Sektor werden Agenten meist darauf getrimmt, Debt-Positions in isolierten Pools (wie Morpho Blue oder Fluid) oder dem altbewährten Aave V3 zu verwalten. Die größte Challenge hierbei: den Health Factor (HF) permanent im Auge zu behalten – andernfalls wird die Position gnadenlos pulverisiert. Der Bot triggert den PoolLens-Contract via RPC und berechnet das Risiko ganz klassisch:
Rauscht der Markt in den Keller und die Collateral-Werte schmieren ab, muss der Agent eigenständig ein partielles De-Leveraging (Self-Deleverage) einleiten. Um kein eigenes Kapital zu verbrennen, jongliert er mit Flashloans über Balancer oder Uniswap V3. Das ist überlebenswichtig, da beispielsweise bei Morpho die Liquidationsstrafen (Penalties) brutal hoch sind – da verliert man in einer Sekunde mal eben 10-15 % des gesamten Kapitals.
Falls euer Bot auf der Jagd nach fetten APYs ständig zwischen den Pools hin- und hersteppt, müsst ihr eine strikte Gas-Kosten-Kalkulation im Code verankern. Das Skript fragt die aktuellen Kurse bei der ParaSwap- oder 1inch-API ab und zieht Gas-Gebühren sowie Slippage-Verluste direkt von der Rendite ab. Wenn sich das Umschichten von Stablecoins (beispielsweise von Arbitrum zu Base) nicht innerhalb von 72 Stunden amortisiert, schicken wir das Modell direkt in die Wüste. Die Transaktion wird auf der Ebene der Skript-Basislogik blockiert, völlig egal, wie euphorisch die LLM in ihren Prognosen auch sein mag.
Risikomatrix für autonome Systeme
Einer LLM die volle Kontrolle über die Wallet zu überlassen, ist und bleibt ein Himmelfahrtskommando. Neuronale Netze bringen ganz eigene, spezifische Bugs mit, von denen man im traditionellen algorithmischen Handel noch nie gehört hat.
- Data Poisoning (Manipulierte Feeds)
Angreifer faken On-Chain-Transaktionen oder fluten die Kanäle mit Fake News. Die KI wittert den „Beginn eines massiven Bullruns“ und kauft gierig direkt am lokalen Top (Highs) ein.
Die Lösung: Multi-Source-Verifizierung. Das Skript muss das textuelle Rauschen aus Social Media zwingend mit den unbereinigten On-Chain-Handelsvolumina direkt aus der Blockchain abgleichen. Wenn im Pool keine echte Liquidität vorhanden ist, wird der Trade eiskalt ignoriert. - Formatierungsfehler (JSON-Break)
Der Markt dreht völlig hohl, das Modell verfällt in Panik, vergisst ein Anführungszeichen, liefert unerwarteten Freitext mit oder zerlegt die JSON-Struktur. Das Skript schmiert ab, der Bot steht still.
Die Lösung: Rigoroses Try/Catch. Jeder Syntaxfehler beim Parsen des LLM-Outputs muss die Logik augenblicklich in den HOLD-Modus (Position halten) zwingen. Asset-Protection steht über allem. - Frontrunning beim Rebalancing
Der Bot pusht eine Transaktion zum Umschichten von Liquidität in den öffentlichen Mempool, wo MEV-Bots nur darauf warten, ihn abzufischen. Das Ergebnis ist massives Slippage und verbranntes Geld.
Die Lösung: Private RPCs. Alle Transaktionen laufen strikt über Flashbots Protect oder BuilderRPC am öffentlichen Mempool vorbei, damit uns niemand in die Karten schauen kann. - Kaskadierende Netzwerklatenz
Bei Krypto-Crashs schießen die Gas-Preise im L1-Netzwerk instantan durch die Decke. Die Margin-Top-up-Transaktionen des Bots hängen im Nirwana fest und die Position wird seelenruhig liquidiert.
Die Lösung: Gas- und Liquiditätspuffer. Wir halten immer 15-20 % des Depots unberührt in nativen Token (ETH/SOL) auf der Wallet und kalkulieren im maxFeePerGas einen Puffer von mindestens +50 % des aktuellen Netzwerk-Medians ein.
Fazit: Das Risikomanagement an den kognitiven Part zu delegieren, ist reiner Selbstmord. Das Modell glänzt als flexibler Analyst, um versteckte Ineffizienzen und profitable Pools aufzuspüren. Die Positionsgrößen, die maximalen Hebel und die Notausstieg-Trigger (Emergency Exits) gehören jedoch unveränderlich im Code festverdrahtet.
