Agent AI otonom biasanya dirakit dari tiga modul terisolasi: pengumpul data on-chain (node RPC dan API indexer), core kognitif (LLM dengan latensi respons rendah), dan gateway eksekusi transaksi (Action Layer). Kalau kalian nekat mengikat logika trading ke model komersial yang disensor ketat seperti GPT-4o, siap-siap aja API key kalian di-ban saat volatilitas pasar lagi tinggi. Filter keamanan internal mereka sering mendeteksi transmisi sinyal trading sebagai bentuk pembuatan risiko finansial. Untuk otomatisasi yang stabil, pilihan terbaik jatuh pada model tanpa sensor berbasis open-weights (seperti Llama 3.3 70B atau DeepSeek V3) yang di-deploy di hosting terdesentralisasi atau diakses lewat gateway khusus seperti Venice AI.
Execution layer wajib dikoneksikan ke infrastruktur dengan ping paling minimal. Di sektor perpetual contracts (perps), Hyperliquid API sudah jadi standar emas berkat operasionalnya di appchain L1 mandiri yang punya kecepatan pemrosesan order hingga 0,1 detik. Core kognitif tidak punya akses langsung ke wallet: model hanya menerima tumpukan metrik pasar lalu memuntahkan rekomendasi dalam format JSON, yang kemudian divalidasi oleh skrip Python lokal berdasarkan batas risiko (risk limit) super ketat sebelum akhirnya disiarkan ke jaringan.
Ini kodenya, dan buat yang mau baca dokumentasi Hyperliquid API bisa cek di sini: https://hyperliquid.gitbook.io/hyperliquid-docs/for-developers/api/info-endpoint/perpetuals
import osimport jsonimport requestsfrom eth_account import Account# ambil key dari env, nge-hardcode private key di script itu cari penyakit namanya
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"):
# parsing orderbook dan funding rate terbaru langsung dari appchain 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 # kalau HL lagi lag, jangan sentuh order, safety firstdef ask_brain(context):
if not VENICE_KEY:
return {"action": "HOLD", "pct": 0, "leverage": 1}
headers = {"Authorization": f"Bearer {VENICE_KEY}", "Content-Type": "application/json"}
# kurung modelnya biar gak kebanyakan mukadimah text. kita butuh json bersih
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 # pangkas halusinasi dan kreativitas model
}
try:
r = requests.post(VENICE_URL, json=payload, headers=headers, timeout=12)
out = r.json()["choices"][0]["message"]["content"].strip()
# babat backticks kalau modelnya bebal dan malah bungkus pake markdown code block
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):
# sekring darurat. kalau modelnya mulai ngaco, skrip bakal langsung mangkas
if decision["action"] not in ["BUY", "SELL"]:
return None
# batasi leverage maksimal 3x dan volume maksimal 5% dari modal
leverage = min(int(decision.get("leverage", 1)), 3)
pct = min(int(decision.get("pct", 0)), 5)
if pct <= 0:
return None
# siapkan slippage 0.3% biar order langsung keisi tanpa nunggu
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 aktif untuk address: {acc.address}")
ctx = get_market_data("ETH")
if not ctx:
print("[-] Gagal konek ke HL.")
return
raw_decision = ask_brain(ctx)
final_order = filter_limits(raw_decision, ctx["price"])
if final_order:
print(f"[+] Order berhasil dibuat: {json.dumps(final_order)}")
else:
print("[*] Belum masuk kondisi ideal, posisi aman tidak berubah.")if __name__ == "__main__":
run_pipeline()Otomatisasi Yield Farming di Lending Market
Di sektor spot DeFi, agen AI biasanya dilatih untuk mengelola posisi utang (debt position) di pool terisolasi seperti Morpho Blue, Fluid, atau pemain lama Aave V3. Masalah paling pelik di sini adalah keharusan menghitung Health Factor (HF) secara terus-menerus tanpa jeda, kalau meleset dikit saja posisi kalian bakal langsung kena likuidasi sampai ludes. Bot akan memanggil kontrak PoolLens via RPC dan menghitung risiko secara konvensional:
Begitu pasar ambles dan nilai jaminan (collateral) mulai anjlok, si agen harus berinisiatif melakukan pembayaran utang sebagian secara mandiri (Self-Deleverage). Biar gak boncos pakai modal sendiri, dia bisa memanfaatkan fitur flash loan lewat Balancer atau Uniswap V3. Langkah ini sangat krusial, karena di platform seperti Morpho denda likuidasinya luar biasa gede, kalian bisa kehilangan 10-15% dari total dana dalam sekejap mata.
Jika bot kalian hobi lompat-lompat antar-pool demi ngejar APY yang gemuk, kalkulasi biaya transaksi wajib ditanam secara kaku di dalam kode. Skrip akan nge-ping ParaSwap atau 1inch API untuk mengambil kuotasi harga, lalu memotong estimasi keuntungan dengan biaya gas dan slippage. Kalau proses transfer stablecoin, misalnya dari Arbitrum ke Base, butuh waktu lebih dari 72 jam hanya untuk balik modal akibat biaya migrasi, lupakan saja. Transaksi bakal langsung diblokir di level logika dasar skrip, bahkan jika model LLM-nya lagi kegirangan dan memprioritaskan prediksi tersebut.
Risk Matrix untuk Sistem Otonom
Menyerahkan wallet sepenuhnya ke kendali LLM itu adalah bentuk bunuh diri finansial. Neural network membawa segudang bug spesifik yang tidak pernah ada dalam sejarah dunia algorithmic trading konvensional.
- Keracunan Data Feed (Data Poisoning)
Grup penyerang mulai merekayasa transaksi palsu on-chain atau membanjiri lini masa dengan fake news. AI menangkap fenomena ini sebagai "awal dari trend bullish raksasa" dan langsung FOMO beli di pucuk.
Solusi — Polling multi-sumber (consensus). Skrip wajib mencocokkan info teks tidak terstruktur dari medsos dengan data mentah trading volume langsung dari blockchain. Kalau di pool gak ada likuiditas riil — abaikan saja. - Gagal Parsing Format (JSON Break)
Saat pasar lagi luar biasa bergejolak, model bisa panik, lupa menutup tanda kutip, menyelipkan text basa-basi di responsnya, atau merusak struktur JSON. Skrip otomatis error dan bot langsung mati.
Solusi — Pasang try/except berlapis. Setiap kegagalan sintaks saat parsing respons LLM harus langsung melempar logika bot ke mode HOLD (tahan posisi). Keamanan dana adalah prioritas utama. - Frontrunning pada Rebalancing
Bot mengirimkan transaksi pemindahan likuiditas ke public mempool, di mana bot-bot MEV sudah siap mengintai untuk melakukan sandwich attack. Hasilnya, kita terkena slippage parah dan kehilangan banyak uang.
Solusi — Gunakan private RPC. Kirim semua transaksi secara eksklusif lewat Flashbots Protect atau BuilderRPC demi mem-bypass public mempool agar pergerakan kita tidak terdeteksi. - Lag Jaringan Berantai (Cascading Latency)
Ketika terjadi market dump yang parah, harga gas di L1 bakal langsung meroket ke langit. Transaksi bot untuk menambah margin akhirnya tersangkut menjadi pending order, dan posisi pun sukses terlikuidasi.
Solusi — Sediakan sisa gas dan likuiditas cadangan. Selalu sisakan sekitar 15-20% modal dalam bentuk native token (ETH/SOL) di balance wallet, dan set parameter maxFeePerGas dengan cadangan minimal +50% di atas nilai median jaringan saat itu.
Kesimpulannya, membiarkan bagian kognitif mengelola manajemen risiko adalah kesalahan fatal. Model LLM hanya bagus berperan sebagai analis fleksibel untuk mencari korelasi tersembunyi dan pool yang profitnya maksimal. Namun, untuk urusan ukuran posisi, leverage maksimal, dan trigger darurat untuk keluar dari pasar, semuanya wajib di-hardcode mati di dalam skrip.
