Autonomiczny agent AI składa się z trzech odizolowanych modułów: agregatora danych on-chain (węzły RPC i API indeksatorów), rdzenia kognitywnego (LLM o niskim opóźnieniu odpowiedzi) oraz bramki wykonawczej dla transakcji (Action Layer). Próba oparcia logiki handlowej na komercyjnych modelach z ciężką cenzurą, takich jak GPT-4o, skończy się zablokowaniem kluczy API podczas wysokiej zmienności na rynku – ich wewnętrzne filtry bezpieczeństwa (guardrails) często flagują przesyłanie sygnałów tradingowych jako generowanie ryzyka finansowego. Do stabilnej automatyzacji używa się nieocenzurowanych modeli open-weights (Llama 3.3 70B, DeepSeek V3), postawionych na zdecentralizowanym hostingu lub dostępnych przez dedykowane bramki typu Venice AI.
Warstwa wykonawcza musi być wpięta w infrastrukturę z minimalnym pingiem. W sektorze kontraktów wieczystych (perps) standardem stało się Hyperliquid API, a to dzięki działaniu na dedykowanym appchainie L1, co pozwala na realizację zleceń w czasie poniżej 0.1 sekundy. Rdzeń kognitywny nie ma bezpośredniego dostępu do portfela: model zgarnia zestaw metryk rynkowych i wypluwa rekomendację w formacie JSON, którą lokalny skrypt w Pythonie sprawdza pod kątem sztywnych limitów ryzyka przed puszczeniem jej w sieć.
Łapcie kod, a dokumentację do Hyperliquid API możecie przejrzeć tutaj: https://hyperliquid.gitbook.io/hyperliquid-docs/for-developers/api/info-endpoint/perpetuals
import osimport jsonimport requestsfrom eth_account import Account# wyciągamy klucze ze środowiska, hardkodowanie prywatnych kluczy w tekście to czysta abstrakcja
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"):
# parsujemy orderbook i aktualny funding bezpośrednio z appchainu 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 # jeśli HL laguje, nie ruszamy zleceń, bezpieczeństwo przede wszystkimdef ask_brain(context):
if not VENICE_KEY:
return {"action": "HOLD", "pct": 0, "leverage": 1}
headers = {"Authorization": f"Bearer {VENICE_KEY}", "Content-Type": "application/json"}
# zamykamy model w sztywnych ramach, żeby nie lał wody. potrzebny czysty 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 # ucinamy halucynacje i kreatywność
}
try:
r = requests.post(VENICE_URL, json=payload, headers=headers, timeout=12)
out = r.json()["choices"][0]["message"]["content"].strip()
# wywalamy backticki, jeśli model zamulił i dorzucił formatowanie kodu
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):
# sztywny bezpiecznik. jeśli model odepnie wrotki — kod go przytnie
if decision["action"] not in ["BUY", "SELL"]:
return None
# ograniczamy dźwignię do 3x i wolumen do 5% depozytu
leverage = min(int(decision.get("leverage", 1)), 3)
pct = min(int(decision.get("pct", 0)), 5)
if pct <= 0:
return None
# zakładamy poślizg cenowy (slippage) 0.3%, żeby zlecenia wchodziły z miejsca
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 odpalony dla adresu: {acc.address}")
ctx = get_market_data("ETH")
if not ctx:
print("[-] Brak łączności z HL.")
return
raw_decision = ask_brain(ctx)
final_order = filter_limits(raw_decision, ctx["price"])
if final_order:
print(f"[+] Zlecenie sformatowane: {json.dumps(final_order)}")
else:
print("[*] Czekamy na warunki, pozycja bez zmian.")if __name__ == "__main__":
run_pipeline()Automatyzacja Yield Farmingu na rynkach kredytowych
W sektorze spot DeFi agenci są zazwyczaj szkoleni do zarządzania pozycjami dłużnymi w odizolowanych pulach (typu Morpho Blue czy Fluid) albo w starym, dobrym Aave V3. Największym wyzwaniem jest tutaj ciągłe przeliczanie wskaźnika kondycji (Health Factor, czyli HF) – inaczej pozycję zmiecie z planszy. Bot odpytuje kontrakt PoolLens przez RPC i liczy ryzyko po klasycznemu:
Jeśli rynek leci na łeb, a zabezpieczenie traci na wartości, agent musi sam zainicjować częściową spłatę długu (Self-Deleverage). Żeby nie mrozić własnego kapitału, kręci flash loany przez Balancera lub Uniswap V3. To kwestia krytyczna, bo w takim Morpho kara za likwidację jest ogromna – w ułamku sekundy można wtopić 10-15% całego depozytu.
Kiedy bot skacze między pulami w pogoni za grubym APY, w kodzie musi na sztywno siedzieć dokładna kalkulacja kosztów transakcji. Skrypt puka do ParaSwap lub API 1inch, zgarnia wyceny i odejmuje od zysku straty na gas i poślizg cenowy (slippage). Jeśli transfer stablecoinów, na przykład z Arbitrum do Base, miałby się zwracać dłużej niż 72 godziny, wysyłamy model na drzewo. Transakcja zostaje zablokowana na poziomie bazowej logiki skryptu, nawet jeśli LLM ma w swoich prognozach maksymalny priorytet i totalną euforię.
Matryca ryzyka dla systemów autonomicznych
Oddanie portfela pod kontrolę LLM to zawsze potężne ryzyko. Sieci neuronowe mają całą masę własnych, specyficznych bugów, z którymi tradycyjny trading algorytmiczny nigdy nie miał do czynienia.
- Zatrucie feedu danych (Data Poisoning)
Atakujący zaczynają kręcić sztuczny wolumen on-chain albo spamować fake newsami. AI widzi w tym „początek potężnego trendu” i ładuje się w pozycję na samej górce.
Rozwiązanie – dywersyfikacja źródeł (multi-oracle). Skrypt musi weryfikować tekstowy bełkot z socjali z surowym wolumenem handlu branym prosto z blockchaina. Jeśli w puli brakuje realnej płynności – ignorujemy temat. - Błędy formatowania (JSON Break)
Na rynku zaczyna się dzika zmienność, model panikuje, zapomina zamknąć cudzysłów, dorzuca do odpowiedzi zbędny tekst albo po prostu rozwala strukturę JSON-a. Skrypt wywala błąd, bot leży.
Rozwiązanie – pancerne try/except. Każdy błąd składniowy przy parsowaniu odpowiedzi z LLM musi momentalnie zrzucać logikę w tryb HOLD (przetrzymanie). Bezpieczeństwo kapitału to priorytet. - Frontrunning rebalansowania
Bot wysyła transakcję przeniesienia płynności do publicznego mempoola, gdzie od razu polują na niego MEV boty. W efekcie łapiemy potężny slippage i tracimy kasę.
Rozwiązanie – prywatne RPC. Wszystkie transakcje wypychamy rygorystycznie przez Flashbots Protect lub BuilderRPC z pominięciem publicznego mempoola, żeby nikt nas nie widział. - Kaskadowy lag sieci
Przy silnym zrzucie ceny, gas na L1 wystrzela w kosmos. Transakcje bota mające dorzucić depozyt zabezpieczający (margin) wiszą w próżni, a pozycja zostaje bezlitośnie zlikwidowana.
Rozwiązanie – bufor na gas i płynność. Zawsze trzymamy 15-20% depozytu nietknięte w natywnych tokenach (ETH/SOL) na balancie portfela i ustawiamy w maxFeePerGas zapas na poziomie minimum +50% względem aktualnej mediany sieci.
Z tego wszystkiego płynie prosty wniosek: pozwalanie części kognitywnej na zarządzanie ryzykiem to czyste samobójstwo. Model sprawdza się świetnie wyłącznie jako elastyczny analityk do wyszukiwania ukrytych zależności i zyskownych pul. Jednak wielkości pozycji, maksymalna dźwignia i triggery awaryjnego wyjścia z rynku muszą być na sztywno zahardkodowane w kodzie źródłowym.
