What is an AI trading agent?

An AI trading agent is an autonomous onchain agent that holds its own crypto wallet and trades on a blockchain — reading market data, deciding with a reasoning model, and signing its own swaps or orders within preset risk limits. Unlike a normal trading bot, it reasons over inputs instead of running a fixed script; unlike a centralized-exchange bot, its fills settle as public onchain transactions.

Do AI trading agents actually make money?

Some report gains, but a reported return is a claim, not proof. Markets are adversarial and no agent makes money reliably — autonomy can lose funds as fast as it earns them. Before believing any track record, ask for a wallet address and check the onchain trades against the claim. No verifiable history means the numbers are marketing.

Where do onchain trading agents trade?

Mostly on decentralized exchanges (spot swaps against liquidity pools), onchain perpetual-futures venues like Hyperliquid (margined long/short positions), and aggregators that route orders across venues for better pricing. The common factor is that every fill is a public transaction you can verify on a block explorer.

How do I know a trading agent's track record is real?

Look for a wallet address and reconstruct its trades onchain — entry and exit fills you can replay, with fees and slippage included, across the full period rather than a cherry-picked window. Standards and signals like the Sato Score grade whether a product is transparent and checkable, but verification ultimately comes from the chain itself, not a leaderboard or a screenshot.

What risk limits should an AI trading agent have?

At minimum: per-trade and position size caps, a daily loss limit that halts trading after a set drawdown, slippage bounds to resist sandwich attacks, an allow-list of vetted venues and tokens, and human approval for large irreversible actions. These should be enforced by a risk engine before the wallet signs — not stated as instructions in a prompt.

← Back to wiki

What Are AI Trading Agents?

Last updated 2026-06-24

AI trading agents are autonomous onchain agents that hold a wallet and execute trades on DEXs and perps venues within preset risk limits — reasoning over market data instead of running a fixed script.

Key takeaways

▸An AI trading agent holds its own wallet and signs trades onchain — it's an [onchain agent](/wiki/what-are-onchain-agents) pointed at markets, not a chatbot that gives tips.
▸The stack: a reasoning model + a policy-controlled wallet + venue connectors (DEX/perps) + market data + a risk engine that caps what it can do.
▸Most trade on DEXs and onchain perpetual-futures venues, where every fill is a public transaction you can check — see the [trading use case](/use-cases/trading).
▸Reported returns are a claim until the trades are reproducible onchain. A big number with no wallet address is marketing — the gap is what the [Sato Score](/sato-score) flags as self-reported.
▸Risk limits — per-trade size, daily loss caps, allow-listed venues — are the difference between an agent and an unbounded liability.

An AI trading agent is an autonomous onchain agent that controls a crypto wallet and trades on a blockchain itself — reading market data, deciding what to do, and signing its own swaps or orders inside preset risk limits. The "AI" part reasons over messy inputs; the "onchain" part means it moves value on a public venue, not on a centralized exchange's internal ledger.

"Trading agent" gets stretched to cover everything from a scripted arbitrage bot to a backtest screenshot. This page covers what one actually is, the stack underneath it, where it trades, and the thing marketing rarely shows: whether performance is verified or just claimed. For the broader category, start with what are onchain agents.

Why It Matters

Markets run continuously and move faster than a human can babysit, so trading is an obvious job to hand an autonomous agent — and a dangerous one to get wrong. The same autonomy that captures a spread can drain an account on a bad signal or a manipulated price. For a builder the question isn't "can an agent trade" (it can) but "can you prove what it did and bound what it can lose." That's why custody, risk limits, and verifiable execution — not return numbers — matter.

How It Works

▸Observe: the agent pulls price feeds, pool or orderbook state, onchain balances, and sometimes social signals into its context.
▸Reason: a model (often an LLM plus deterministic logic) decides whether and what to trade against a strategy, rather than firing a fixed if-then rule.
▸Check risk: a guardrail layer validates the trade against per-trade size, daily loss caps, slippage limits, and an allow-list of venues and tokens.
▸Execute: the agent signs a transaction from its policy-controlled wallet — a DEX swap or a perps order — via a venue connector or SDK.
▸Settle and report: the fill lands onchain as a public transaction, logged so anyone can reconcile claimed performance against real trade history.

Key Components

•Reasoning model (LLM and/or quantitative strategy logic)
•Policy-controlled wallet with spend and approval limits
•Venue connectors (DEX routers, perps APIs, aggregators)
•Market data feeds (prices, pool/orderbook state, oracles)
•Risk engine (position sizing, loss caps, slippage and allow-lists)
•Execution + transaction simulation layer
•Position and PnL state tracking
•Logging and verifiable trade history

AI trading agent vs. trading bot

A classic trading bot runs a fixed rule: if RSI crosses this line, buy; if price hits that level, sell. It doesn't reason — it executes a script a human wrote, and breaks the moment conditions fall outside it.

An AI trading agent adds a reasoning layer. It can weigh conflicting signals, interpret unstructured inputs like a governance announcement, and adapt its plan — then, like any onchain agent, sign the resulting trade from its own wallet. The line that matters isn't "AI vs. not." It's custody and settlement: an onchain trading agent holds keys and its fills are public transactions, whereas an offchain bot on a centralized exchange moves balances on that exchange's private ledger — a split covered in onchain vs. offchain agents. "AI" describes the brain, but the wallet creates the risk and the auditability; a smarter model on an unbounded key is still an unbounded liability.

The trading agent stack

Strip away the branding and every AI trading agent is the same handful of layers:

▸Reasoning model — an LLM, a quantitative strategy, or both, deciding whether and what to trade.
▸Policy-controlled wallet — the part that can sign. Production agents rarely hold a raw private key; they use embedded wallets or scoped signers with spend caps. See how agents interact with smart contracts for the signing mechanics.
▸Venue connectors — tools that turn a decision into an onchain order. Toolkits like the GOAT SDK and Coinbase AgentKit expose swap and DeFi actions an agent can call.
▸Market data — price feeds, pool or orderbook state, and oracles the agent reads before acting.
▸Risk engine — the layer that says no: position sizing, daily loss caps, slippage bounds, and allow-listed tokens and venues.

The loop is the same as any agent — observe, reason, act, report — but here every "act" spends real money, so simulating the transaction before signing is not optional.

Where they trade: DEXs, perps, and aggregators

Onchain trading agents trade where settlement is public:

▸Spot DEXs. Agents swap tokens against liquidity pools or through aggregators that route for best price. Every fill has a transaction hash, so the spot history is fully reconstructable.
▸Perpetual-futures venues. Onchain perps platforms like Hyperliquid let agents open long or short positions with margin, raising both the potential gains and the liquidation risk. Its order and position model is documented in the official docs.
▸Aggregators and routers. Rather than picking one pool, many agents call a routing API that splits an order across venues to reduce slippage.

The common thread is verifiability: unlike a centralized-exchange trade, an onchain fill leaves a public record — exactly what lets you check a claimed track record against reality. Map the tooling per venue on the trading use case page.

Claimed vs. verified performance

Here's where most trading-agent content quietly falls apart. A return number — "up big this month," a green equity curve, a leaderboard rank — is a claim. It becomes shown only when you can tie it to onchain trades you can replay on a block explorer. Three questions before you believe any track record:

Is there a wallet address? No address means no way to verify. A screenshot is not evidence.
Does the onchain history match the claim? Reconstruct the fills — cherry-picked windows hide losing periods.
Are fees, slippage, and failed transactions included? Gross numbers that ignore costs flatter every strategy.

The Sato Score grades exactly this transparency and liveness — whether a product is open, active, and checkable. It is explicitly not a safety grade or a returns rating, and never tells you an agent will make money. The rule holds hardest here: trust the receipts, not the equity curve.

Risk limits and guardrails

An autonomous trader is only as safe as the limits around it. The non-negotiable controls:

▸Per-trade and position caps — a hard ceiling on any single trade or open position.
▸Daily loss limits — an automatic stop after a defined drawdown, so one bad session can't compound.
▸Slippage bounds — reject fills worse than a set tolerance to blunt sandwich attacks and thin-liquidity traps.
▸Venue and token allow-lists — restrict the agent to vetted markets so a hallucination can't route funds into a scam token.
▸Human-approval steps — a sign-off for withdrawals or anything irreversible above a threshold.

These live in the risk engine, enforced before the wallet signs — not as suggestions in a prompt. Treat the guardrails as the product. Browse frameworks that bundle wallet, execution, and limits in the directory.

Examples

▸A spot DEX agent that rebalances a token basket on a schedule, swapping through an aggregator within a slippage tolerance.
▸A perps agent on an onchain futures venue that opens hedged positions inside a fixed margin and daily-loss cap.
▸An arbitrage agent that watches price gaps across pools and executes only when the spread clears gas and fees.
▸A signal-driven agent that reads governance or listing announcements and trades a pre-approved token list with human sign-off on large orders.
▸A treasury agent that trims volatile holdings into stablecoins when a drawdown threshold is hit.

Risks & Limitations

⚠Financial loss from bad reasoning, bugs, or market moves — autonomous execution amplifies every mistake, and perps add liquidation risk.
⚠Manipulated inputs: oracle attacks, spoofed liquidity, and prompt injection can steer an agent into harmful trades.
⚠Key compromise — a trading agent's wallet is only as safe as its key management and permission scoping.
⚠Self-reported performance is not verified performance; reported returns mean nothing without onchain trades to back them.

Frequently Asked Questions

What is an AI trading agent?: An AI trading agent is an autonomous onchain agent that holds its own crypto wallet and trades on a blockchain — reading market data, deciding with a reasoning model, and signing its own swaps or orders within preset risk limits. Unlike a normal trading bot, it reasons over inputs instead of running a fixed script; unlike a centralized-exchange bot, its fills settle as public onchain transactions.
Do AI trading agents actually make money?: Some report gains, but a reported return is a claim, not proof. Markets are adversarial and no agent makes money reliably — autonomy can lose funds as fast as it earns them. Before believing any track record, ask for a wallet address and check the onchain trades against the claim. No verifiable history means the numbers are marketing.
Where do onchain trading agents trade?: Mostly on decentralized exchanges (spot swaps against liquidity pools), onchain perpetual-futures venues like Hyperliquid (margined long/short positions), and aggregators that route orders across venues for better pricing. The common factor is that every fill is a public transaction you can verify on a block explorer.
How do I know a trading agent's track record is real?: Look for a wallet address and reconstruct its trades onchain — entry and exit fills you can replay, with fees and slippage included, across the full period rather than a cherry-picked window. Standards and signals like the Sato Score grade whether a product is transparent and checkable, but verification ultimately comes from the chain itself, not a leaderboard or a screenshot.
What risk limits should an AI trading agent have?: At minimum: per-trade and position size caps, a daily loss limit that halts trading after a set drawdown, slippage bounds to resist sandwich attacks, an allow-list of vetted venues and tokens, and human approval for large irreversible actions. These should be enforced by a risk engine before the wallet signs — not stated as instructions in a prompt.