Agentic AI Trading: The Complete 2026 Guide

By Kristian Fagerlie · 2026-06-05 · 15 min read

Agentic AI trading is a hands-off trading loop where an LLM agent reads live market data, makes its own decisions every 30–120 seconds, and adjusts strategy on the fly without human intervention. It's the practical merger of agentic AI and quantitative trading that finally became viable in mid-2026, after Codex 5.5, Claude Opus 4.8, and the /goal long-running task primitive landed in production tooling. This guide is the consolidated playbook from every trading experiment I've shipped on this channel — the architecture, the strategies, the model comparisons, the platforms, the realistic costs, and the gotchas that quietly break setups.

I am Kristian Fagerlie, creator of the All About AI YouTube channel. The trading material here comes from live builds with real wallets, real APIs, and public experiment logs across Polymarket, Hyperliquid, Robinhood, Codex, and Claude Code. The goal is to document working agent architecture, not to sell a signal service.

What is Agentic AI Trading?

The phrase gets used loosely. The strict definition I work from has three components, and a setup that's missing any of them isn't really agentic AI trading — it's something else dressed up.

1. The agent makes the decisions. Not "the AI suggests, I click". The agent calls the platform's API directly and moves real money — opening, sizing, hedging, closing positions.
2. The loop is autonomous over a meaningful horizon. Minutes minimum, ideally hours or days. A one-shot trade idea isn't agentic; it's a chatbot recommendation. The whole point is sustained operation.
3. The agent adapts on live data. Heartbeat polling, position-state evaluation, and the ability to switch strategy when the market regime changes — without re-prompting. This is the part that separates an agentic loop from a Python script with a sleep timer.

If you can leave the room for an hour and come back to find the agent has noticed conditions changed, abandoned its first plan, and pivoted into a new strategy — that's agentic AI trading. If it just executed what you told it, that's automation.

Why now — what changed in 2026

People have built algorithmic trading bots for decades. The reason "agentic AI trading" is suddenly its own thing in 2026 comes down to four shifts that all landed in the same six months:

• Reasoning-class models held a 1-hour task. Pre-2026, models would drift mid-run. Codex 5.5 high reasoning, in particular, treats "re-check the position" as a default behavior rather than an event. That's the property a live trading loop depends on. See the Codex vs Claude Hyperliquid head-to-head for what that looks like on real money.
• Long-running task primitives shipped. Codex's /goal slash command formalizes "keep working toward this verifiable condition across turns". Before /goal, you had to roll your own loop and pray the model didn't self-terminate. See the Opus 4.8 test for what happens when a model self-terminates a heartbeat mid-trade.
• Sub-agents got cheap. Models like GPT-5.4 mini can summarize websocket frames into clean JSON for $0.something per thousand tokens. That means the heartbeat loop is no longer dominated by token cost — full architecture in the heartbeat post.
• The platforms opened up. Hyperliquid exposes programmatic perp trading through its API docs, Polymarket's 5-minute BTC market gives bots a high-cadence venue, and Robinhood launched Agentic Trading through an MCP flow in 2026. The API surface a beginner can hit is now huge.

Together: models that hold a loop, primitives that schedule the loop, sub-agents that make the loop cheap, and a wide surface of platforms to point it at. That's the stack. Each piece existed before; they only just composed.

Live experiment evidence

These are the core agentic trading builds this guide consolidates. Each one has a dedicated write-up and video so you can inspect the setup, prompt shape, platform gotchas, and failure modes instead of trusting a summary claim.

How is this different from algorithmic trading?

Important question because the line is blurry. Quick comparison:

• Algorithmic trading: a fixed strategy expressed in code. Entry/exit rules are deterministic. If the market regime changes, the strategy keeps doing the same thing until you update the code. Edge comes from speed (HFT) or rare statistical signals (long-tail strategies).
• Agentic AI trading: a fixed goal expressed in natural language. The strategy is generated dynamically by an LLM, evaluated against live data, and revised on the fly. If the market changes, the agent can switch strategy without code changes. Edge comes from adaptability and the ability to compose new strategies as conditions shift.

This isn't a value judgment in either direction. HFT firms running 100µs colocated bots will keep winning the microstructure game. But for retail-scale capital and longer time horizons, the agentic version is dramatically easier to ship, easier to maintain, and more resilient to regime change. The bar to entry collapsed from "team of quants + colo" to "$30 in a wallet and a Codex subscription".

The platforms that matter in 2026

Three venues account for almost all the practical work right now. Each has a different shape that suits different kinds of agents.

Hyperliquid — perp DEX, equity + commodity + FX markets

Hyperliquid is where I do most of my work. The official Hyperliquid docs expose the API surface an agent needs for programmatic trading, and the long-tail market set gives an LLM something to actually research per ticker (earnings, news, sentiment) instead of pure orderbook microstructure.

Full build walkthrough: Building a Hyperliquid AI Agent Trader From Scratch. Beginner walkthrough: Agentic AI Trading For Beginners.

Funding flow: USDC on Arbitrum + a few dollars of ETH for gas. About $200 is a reasonable starting balance. There's a quiet gotcha to know up front: by default, deposits route to the spot account, not perps. The fix is to disable "HIP 3 DEX abstraction" in settings — without that, every API order to the perp engine silently fails. Detailed in the build post.

Polymarket — prediction markets, 5-minute BTC up/down

Polymarket's 5-minute BTC up/down market is the highest-frequency thing available. 288 fresh markets a day, each resolving in 5 minutes against a Chainlink BTC oracle. That cadence is exactly what an iterating agent wants — strategy ideas get hundreds of samples in a single day. The relevant developer surface is the Polymarket docs plus the CTF exchange approval flow in the web app.

Full build: Building a Polymarket AI Trading Bot From Scratch. Strategy library: 100x Polymarket strategies. Live results: the first paid fill update. Earlier research-shape work: Karpathy-style autoresearch and the original predictions-market run.

Funding flow: USDC.e on Polygon + a tiny amount of MATIC for gas. ~$30 starting balance works. Approve the CTF exchange allowance on Polymarket's site before any order will go through.

Robinhood — newly launched agentic stocks

Robinhood's Agentic Trading product went live in 2026 with a dedicated agentic account and MCP-based setup. Higher friction to start (real KYC, real fiat onboarding) but if you already have a Robinhood account it is the cleanest regulated path for a US-based user to test stock-trading agents. Read Robinhood's own risk disclosures carefully: the agent can place trades without direct per-trade input, and you remain responsible for monitoring it.

How do you architect an agentic trading loop?

Every loop I run lands on the same four layers. This is the same general shape as the 3-part AI agent system, specialized for trading and extended with a heartbeat.

Layer 1 — Persona / strategy doc (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 the rubric the agent uses to rate trade ideas. Swap the persona for "conservative pension fund manager" with risk-aversion 95 and the identical pipeline produces a different book of trades.

This is where you encode your risk tolerance, capital constraints, time horizon, and any hard rules ("never use more than 50% of margin", "always pair leveraged positions with at least a 25% hedge").

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 — critical because models cache stale market state otherwise.
• /research-trade — takes one candidate, deep-dives via Surfagent browser sub-agents into Reddit, X, Polymarket, news. Outputs a final trade brief: direction, leverage, size, hedge legs, entry conditions.

Layer 3 — The execution model

The actual strategy as a Python (or TypeScript) script. The agent writes this — that's its job — but the script is what touches the exchange. Entry triggers, position sizing, hard stops, order rotation logic all live here. The agent reads/writes status.md and structured state files; the script reads/writes positions.

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

The heartbeat is what makes the system agentic. Most setups silently waste tokens here. The fix is a split-agent loop, detailed 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, recent fills. Outputs tight JSON summary of position state. Every 30 seconds.
• Main agent on a strong model (Codex 5.5 high, or Claude Code where appropriate). Sleeps. Asks sub-agent for state. Makes one decision (hold / hedge / scale / exit / adjust / switch strategy). Sleeps again.

Or, simpler for a single-platform agent: use Codex's /goal slash command. It sets a verifiable stopping condition and Codex keeps cycling toward it. Same effect, single binary.

Which AI model wins for agentic trading?

I have run actual head-to-head bake-offs. Three runs so far, identical prompts, identical capital, different models. Summary:

• Codex 5.5 (high reasoning) — won both venues. Active monitor behavior is its main edge — it treats "let me re-check this" as a default rather than an event. Polymarket head-to-head, Hyperliquid head-to-head.
• Claude Opus 4.7 — picks structurally sound strategies (the late-window scalp is genuinely +EV) but holds positions too long. Penny-grinding is fine over weeks; it loses badly to active rotation over 1 hour.
• Claude Opus 4.8 — improved trade decisions but a new problem: kept self-terminating heartbeat loops mid-run, despite explicit "run for 1 hour" instructions. Documented in the 4.8 first test. Probably fixable with prompt fortification; haven't found the right phrasing yet.
• Open Code (open-source models) — usable for the sub-agent role on fast cheap inference. Haven't benchmarked them as main agents yet; it's on the queue.

Caveats: small sample size, specific task. Opus 4.7+ is still better than Codex for frontend, agent design, and prose-heavy work. The conclusion is narrow: for the specific shape of "run a heartbeat loop and make rapid math-y decisions on live positions", Codex 5.5 high is currently the best choice in mid-2026.

What strategies actually work?

Strategies that have produced real fills on real money so far. None of these are magic; all of them have a clear edge mechanism that the agent can articulate and the LLM can defend.

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 profit). 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 total. Cancel after 120 seconds so we don't get filled in the late-window stale-bid zone. If both legs ever get filled during the close-settlement delay, the position is mathematically guaranteed positive — one side has to redeem. Hit rate is low (~6%), payout is ~100x. Documented in the 100x strategies post and first paid fill update.

Probability arb against the book (Polymarket)

Compute fair probability of "up wins" given current price, time remaining, BTC volatility (Bayesian update from a few minutes of recent data). Compare to Polymarket-implied probability from the orderbook. Bet the underpriced side when the gap exceeds a threshold. 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, never holds a single position to ruin. Codex's active-monitor instinct fits this perfectly. Agentic hedge composition (e.g., short SP500 paired with long NVDA at 25% hedge ratio) emerges naturally from the heartbeat loop, not from pre-coded rules.

Pullback mean-reversion long (Hyperliquid)

When the market is structurally bullish (rising EMAs, positive momentum) but pulls back to a support level, enter a long with 3x leverage on the most-correlated basket of crypto perps. Tight stops, exit at +$10 P&L on the basket. This is the strategy the beginner-walkthrough agent switched into autonomously when its original short-trend strategy was repeatedly blocked by bullish EMA structure. The fact that the agent generated and pivoted to this in real time is the whole point of the beginner walkthrough.

What does this cost to run?

Real numbers from my own setup, mid-2026:

• Capital at risk per agent: $30–$200 to start. Polymarket works with ~$30, Hyperliquid wants ~$100+ for meaningful position sizing under leverage. Don't risk more than you can comfortably lose to a single bad hour.
• Subscription cost: Codex Max (~$200/month) + Claude Code $20 plan = ~$220/month. The Codex side carries the trading work; Claude stays around for frontend and general dev. Cheaper paths exist if you only run one platform.
• Hardware: a Mac mini idling 24/7. Maybe $20/month of electricity. Same machine handles the broader passive-income loops — the marginal cost of adding a trading agent on top is essentially zero.
• Gas + funding fees: a few dollars per platform setup, basically rounding error.

The economics work because cost-per-decision is near zero on a flat subscription, and the heartbeat split-agent further compresses token usage on long runs. The breakeven on the subscription is roughly $10 of trading profit per day — very achievable on multiple parallel small loops.

Realistic expectations: what should I aim for?

I get asked this a lot. Honest framing:

• $100/week (~$5000/year) is a realistic side-hustle target. Achievable on $500–$2000 starting capital with two or three small agents running in parallel. This is the sweet spot for "learn and earn a bit" without quitting your day job.
• $1000/month (~$12K/year) requires more dedication. More capital, more parallel strategies, more hours of monitoring and iteration. Doable but it's a project, not a side hustle.
• Beyond $30K/month is full-time quant territory. Bone Reaper does it. So can you, eventually. But that's a multi-year arc with serious capital and infrastructure, not "I ran an agent for a weekend".

The bigger value at the small-capital end is the learning. You learn more about how markets actually work in a month of running $30 agents than a year of paper trading. Latency, slippage, settlement delays, regime change — they're all real and observable on small money.

Risks and gotchas (read this part carefully)

This is not a get-rich path. Honest framing of what will actually trip you up:

• 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. Don't draw conclusions from a single day.
• 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 — it 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. Read the status logs after, not during.
• Platform-side gotchas. Hyperliquid's HIP-3 DEX abstraction routes deposits to spot instead of perps if not disabled. Polymarket needs CTF exchange allowance approval before any order. These are the kind of thing that silently breaks a setup for hours.
• Models can self-terminate heartbeat loops. Opus 4.8 does this; Codex 5.5 doesn't. If your model exits the loop early, the position keeps moving without an active manager. Either pin to Codex 5.5 or set up a watchdog that restarts the agent.
• Close-execution lag. An agent that decides to exit at +$10 might settle at +$6 by the time the orders clear. Tighter exit logic, smaller orders, or limit orders fix this; market orders at small size on a thin book do not.
• Regulatory uncertainty. Perp DEXes and prediction markets sit in gray legal territory in some jurisdictions. Robinhood's agentic launch is helping standardize the fiat-side stack, but you should check what's legal where you live before depositing real money.
• Broker disclosures matter. Robinhood's Agentic Trading disclosure says AI agents can make errors, misinterpret instructions, and place trades without direct input on each transaction. That same risk class applies to every DIY setup here, even when the venue is not a broker.

How do I actually start building one?

Realistic step-by-step path if you're starting from zero. Detailed beginner walkthrough: Agentic AI Trading For Beginners.

1. Pick one platform. Hyperliquid for crypto + equity perps. Polymarket for prediction markets. Don't try both at once.
2. Get the wallet + API working. Fund a wallet, place one manual trade, exit it, fully understand the spot/perp split and the API authentication flow. Skipping this step is what breaks 80% of agentic setups.
3. Run a $10 test trade through Codex/Claude Code. Confirms the API actually works end-to-end via the agent before you build anything fancy.
4. Collect real data into data/raw/. Whatever the platform's API gives you — candles, funding, recent fills, order book snapshots — dump it. Don't skip this; models build worse strategies in a data vacuum.
5. Ask the model for 3 strategy hypotheses, pick one. Force the model to defend its choice. Same pattern as the WSB persona — rate the candidates, articulate the edge.
6. Wrap it in an agentic monitor. Use /goal on Codex for V1, or the split-agent heartbeat pattern when you're ready for the next level.
7. Start small. Lose small. Learn. Run it. Read the status logs. Iterate. Don't intervene mid-run. Run for at least a week before deciding if a strategy works.

Where to go from here

If you're starting fresh, read the beginner walkthrough, then pick one platform and follow either the Hyperliquid build or the Polymarket build. After that, the heartbeat post for the loop architecture, then the model bake-offs (Polymarket, Hyperliquid, Opus 4.8) for model choice.

Live updates and longer-run results land first in the AI_automata Discord — that's also where strategy discussions happen between videos. Drop in.

Official platform references

• Hyperliquid API docs — exchange documentation for programmatic trading.
• Polymarket docs — market data, CTF exchange, and developer reference.
• Robinhood Agentic Trading — dedicated agentic account and MCP setup.
• Robinhood Agentic Trading overview — user-facing setup and risk context.