Agentic AI Trading: A Complete 2026 Guide

By Kristian Fagerlie · 2026-06-01 · 7 min read

Agentic AI trading uses an LLM-driven agent loop to research, place, monitor, and adjust real trades autonomously — typically against perpetual or prediction-market platforms, with a fast sub-agent feeding live data into a stronger main agent every 30 seconds. This is the consolidated playbook from every trading experiment I have shipped on this channel — the strategies, the model comparisons, the architecture that actually holds up over hours of live execution, and the things that quietly break.

What is agentic AI trading, exactly?

Three things have to be true for a setup to count as agentic AI trading in the sense I mean here:

1. The agent makes the decisions. Not "the agent prints suggestions and I click buy". The agent calls the platform's API directly and moves real money.
2. The loop is autonomous over a meaningful horizon. Minutes minimum, ideally hours or days. Once-and-done trade ideas don't count.
3. The agent adapts on live data. Heartbeat polling, position-state evaluation, and the ability to hedge, scale, or exit without re-prompting.

That third one is what most setups get wrong. A model that opens a position and then exits hours later on a fixed timer isn't trading — it's gambling on entry. The thing that turns the loop agentic is the continuous read-evaluate-adjust cycle.

The two venues that matter right now

I trade on two platforms because they have the right shape for an LLM to add value:

Polymarket — prediction markets with on-chain settlement

The 5-minute BTC up/down market is the fastest-resolution venue Polymarket offers — 288 fresh markets a day, each resolving in 5 minutes. That cadence is what makes it interesting for a bot: you can iterate strategy ideas at a pace that produces meaningful sample sizes in hours instead of weeks. The full build is in Building a Polymarket AI Trading Bot From Scratch and the deeper strategy work is in 100x Polymarket strategies and the strategy update.

Other on-Polymarket work worth reading in this thread: Karpathy-style autoresearch on the bot and the original predictions-market run.

Hyperliquid — perp DEX with XYZ markets

Hyperliquid used to be crypto-only. The interesting shift in 2026 is the XYZ perp specification — independent perp markets on equities (NVDA, TSLA, GOOG, MRVL, HOOD), commodities (Brent, WTI, silver, gold), FX, and macro indices (S&P 500). That gives an LLM agent something it can actually research — earnings calendars, news flow, sentiment — instead of pure orderbook microstructure. Full build: Building a Hyperliquid AI Agent Trader From Scratch.

How do you architect an agentic trading loop?

Every loop I run lands on the same three layers. This is the same general shape as the 3-part AI agent system, specialized for trading.

Layer 1 — The persona / strategy CLAUDE.md

The persona is the strategy. The Hyperliquid agent I run uses an RPG-style "Wall Street Bets Moderator" sheet — risk 96, conviction 94, FOMO weakness, 999x God Gen ultimate. Sounds like a joke; it's actually the rubric the agent uses to rate trade ideas. Swap the persona for "conservative pension fund manager" with risk-aversion 95 and you get completely different trades from the identical pipeline.

Layer 2 — Skills (find + research)

Two named skills, invokable as slash commands:

• /find-trades — spawns 6 parallel sub-agents, scans the day's macro and ticker space, produces 3–5 candidate setups to a Kanban board. Grounds the time with bash date so research is fresh.
• /research-trade — takes one candidate, deep-dives via Surfagent browser sub-agents into Reddit, X, Polymarket, X.com news. Outputs a final trade brief: direction, leverage, size, hedge legs, entry conditions.

Layer 3 — The heartbeat (this is the new important one)

The heartbeat is where most setups silently waste tokens. The fix is a split-agent loop, documented in detail in Building an Agentic AI Trading Heartbeat That Works:

• Sub-agent on a fast cheap model (GPT-5.4 mini, low reasoning). Read-only. Consumes websocket frames, P&L, time-remaining. Outputs tight JSON summary of position state.
• Main agent on a strong model (Codex 5.5 high, or Opus where appropriate). Sleeps 30s, asks sub-agent for state, makes one decision (hold / hedge / scale / exit / adjust), sleeps again.

Token cost on the main agent goes way down because the data layer is now a small JSON object instead of raw market history. Decision quality stays where it matters.

Which model wins for agentic trading?

I have run actual head-to-head challenges. The summary across the data so far:

• Codex 5.5 (high reasoning) — won on both venues. Active monitor behavior is its main edge — it treats "let me re-check this" as a default rather than an event. See Polymarket head-to-head and Hyperliquid head-to-head.
• Claude Opus 4.7 — picks sound strategies but holds positions too long. Penny-grinding strategies were structurally fine; the model just doesn't iterate enough in a 1-hour window.
• Claude Opus 4.8 — improved trade decisions but with a new problem: kept self-terminating heartbeat loops mid-run, despite explicit "run for 1 hour" instructions. See the 4.8 first test.

Caveat: this is a small sample size and a specific task. Opus 4.7+ is still better than Codex for frontend work, agent design, and any task that values prose quality. The conclusion is narrow: for the specific shape of "run a heartbeat loop and make rapid math-y decisions on live positions", Codex is currently in front.

What strategies actually work?

The strategies that have produced real fills on real money so far:

Late-window scalp (Polymarket)

In the last ~20 seconds of a 5-minute BTC window, the outcome is essentially decided (BTC has done what it's going to do) but the winning side often still trades at $0.95 instead of $0.99. Enter late on the side already winning, hold to resolution. Bone Reaper, a public Polymarket leaderboard trader, runs this at scale (~180K trades/week, ~$30K/month). Detail: the original bot post.

Window-switch snipe (Polymarket)

At the exact moment a 5-minute window closes and the next opens, fire $0.01 bids on both up and down across BTC, ETH, SOL, XRP (eight bids). Cancel after 120 seconds. If both legs fill at $0.01 during the chaotic close-settlement delay, the position is guaranteed positive — one side has to redeem. Hit rate is low (~6%), payout is ~100x. See the 100x strategies post and the first paid fill.

Probability arb against the book (Polymarket)

Compute fair probability of "up wins" given current price, time remaining, BTC volatility. Compare to Polymarket-implied probability from the orderbook. Bet the underpriced side. Codex 5.5 picked this strategy unprompted and won its hour with it.

Active rotation on XYZ perps (Hyperliquid)

Open positions across multiple correlated XYZ perps with a heartbeat monitor that rotates in and out — small profit-taking on winners, fast cuts on losers. Codex's active-monitor instinct fits this perfectly. The agentic hedge composition (e.g., short SP500 paired with long NVDA at 25% hedge ratio) emerged naturally from the heartbeat loop, not from pre-coded rules.

What does this cost to run?

Real numbers from my own setup:

• Capital at risk per agent: $30-$200 to start. Each platform takes a different floor; Polymarket works with ~$30, Hyperliquid wants ~$100+ for any meaningful position sizing under leverage.
• Subscription cost: Codex Max + Claude Code $20 plan = ~$220/month for both. The Codex side carries the trading work; Claude Code stays for frontend and general dev.
• Hardware: Mac mini idling 24/7, maybe $20/month of electricity. Same machine handles the broader passive-income loops.
• Gas + funding fees: a few dollars per platform setup, basically rounding error.

The economics work because cost per trade decision is near zero on a flat subscription, and the heartbeat split-agent further compresses token usage on long runs.

What are the realistic risks?

This isn't a get-rich path. Honest framing:

• Variance dominates short horizons. A 1-hour win/loss is noise. The strategies above only show up as positive EV across hundreds or thousands of trades.
• Latency matters more on some setups than others. Late-window scalping is sub-second-decision but not millisecond-race. Cross-venue arbitrage is millisecond-race and will lose to colocated bots — don't try.
• The agent can panic. Telling a model mid-run that it's "losing" can flip a sound penny-grinding strategy into a high-variance gamble. Documented this the hard way in the first Polymarket head-to-head. Don't intervene mid-loop.
• Platform-side gotchas. Hyperliquid's HIP-3 DEX abstraction silently routes deposits to spot instead of perps if you don't disable it. Polymarket needs CTF exchange allowance approval before any order goes through.
• Models can self-terminate heartbeat loops. Opus 4.8 does this; needs prompt fortification. Codex doesn't, in my testing.

How do I start building one?

Realistic 4-step path if you're starting from zero:

1. Get the platform mechanics right first. Fund a wallet, place one manual trade, exit it, fully understand the spot/perp split and the API authentication flow. This is the boring step that breaks 80% of agentic setups when skipped.
2. Build the harness with one agent. Skip the sub-agent split for V1. Get Codex or Claude Code reading docs, calling the API, opening + closing a single position. Polymarket build walkthrough or Hyperliquid build walkthrough as references.
3. Add the heartbeat split. Once V1 works, introduce the sub-agent on a cheap model for state polling. Heartbeat build is the template.
4. Run it small, log everything, leave it alone. Resist the urge to intervene mid-run. Read the log after, not during. Most decisions about whether a strategy works can only be made on >24h data.

Where to go from here

The active deep-dive posts are linked throughout above — start with the platform-specific build for whichever venue interests you, then read the heartbeat post for the loop architecture, then the head-to-head comparisons for model choice. Live updates and longer-run results land first in the AI_automata Discord — that's also where the strategy discussions happen between videos.