An AI trading agent is a software system that reads a plain-English goal, watches markets, and decides — under explicit risk rules — whether to take a position, skip it, or wait. A well-built one has three separable parts: a language model that translates intent, market connectors that read venues, and an execution layer in plain code that enforces hard limits. The interesting design questions are not about model capability; they are about where the model lives in the stack and what stops a wrong guess from costing real money.
Most well-designed AI trading agents have three layers, kept deliberately separate.
1. Intent layer. A language model reads what the user wants in plain English ("watch SPY around the open, only enter if a clean breakout above yesterday's high and volume confirms; risk no more than 1% of my paper balance per trade"). The model's job is translation — converting the English into a structured, machine-readable rule. It never touches money directly.
2. Market layer. Code (not a language model) connects to whatever venues the rule covers. For stocks this might be a broker API. For crypto it's an exchange. For futures it's a futures broker. For prediction markets it's Kalshi or Polymarket. The layer handles authentication, market discovery, order book reading, and any venue-specific quirks (lot sizes, fees, settlement timing).
3. Execution layer. Code (still not a language model) reads the structured rule, validates every potential trade against the user's risk caps, and routes the order. This layer has no LLM in it. Position size limits. Daily loss caps. Allowed venues. A paper-money mode that mirrors live behavior without real funds. Logs that capture what the agent did and why.
The architectural rule that follows: the LLM should propose, not execute. Designs that let a model call trade APIs directly have the wrong perimeter — that's where the surprise drawdowns come from.
This division of labor matches what the research and the regulators say. Lopez-Lira and Tang (University of Florida) showed that GPT-class models can read financial news well enough that their headline-sentiment scores predicted next-day stock returns within the study's sample — and that the predictability shrank as more market participants adopted the same models (arXiv:2304.07619). Models are good at reading; any edge from reading decays as everyone reads the same way. On the control side, FINRA's supervision guidance for firms running algorithmic strategies (Regulatory Notice 15-09) expects risk controls to be built into the trading systems themselves — the professional version of the same principle: limits live in code, not in judgment.
The three product categories get conflated constantly. They differ on what you give them, what they give back, and where the limits live.
| Rule-based trading bot | Robo-adviser | AI trading agent | |
|---|---|---|---|
| You provide | Exact coded logic (e.g. a moving-average crossover script) | A risk questionnaire | A plain-English goal with numeric limits |
| It produces | Orders whenever conditions match, no interpretation | A preset portfolio allocation, rebalanced on a schedule | A structured rule, then proposed trades with stated reasoning |
| Where limits live | In your script — you maintain them | In the product's allocation model | In a separate execution layer, in code |
| Scope | One strategy per script, one venue | Diversified portfolios, usually ETFs | Multi-venue: stocks, crypto, futures, prediction markets |
| Typical failure mode | A silent code bug runs unattended | Doesn't fit goals that aren't portfolio-shaped | Risk-cap drift, if limits live in the prompt |
Some agents only target one asset class. Others claim to target many. The honest test is not "does the marketing list 7 venues" but "can the same rule template work across them with the same risk discipline."
A useful full-category agent should:
A good first rule names one instrument, one trigger, and explicit numbers everywhere a judgment call could hide. Here is the sizing arithmetic for a typical first rule, on a $10,000 paper account:
On a prediction market the same budget works in contract terms: a Kalshi contract priced at $0.40 that settles at $0 or $1 puts the full $0.40 per contract at risk, so a $100 risk budget allows at most 250 contracts. Notice that in the stock example two caps interacted and the stricter one governed — that interaction is exactly what you verify on paper first. The numbers here are arithmetic for illustration, not a recommendation of any threshold.
Narrow scope, paper money, weekly audit. One market type, one rule, one venue at a time. Paper money for at least four weeks — roughly 20 trading sessions — before considering anything live, so you see the agent through varied conditions. Weekly reads of the audit log — not just the P&L, but the actual decisions.
One reason to insist on the slow start: an agent's job is not to help you trade more. In the classic study of tens of thousands of retail brokerage accounts, Barber and Odean found that the most active individual traders earned 11.4% annually over the sample period while the market returned 17.9% — a 6.5-percentage-point gap, driven largely by trading costs; the average household in the sample turned over about 75% of its portfolio each year (Journal of Finance, 2000). An agent that surfaces fewer, better-reasoned decisions is on the right side of that finding; one that nudges you toward constant activity is not.
A losing month with clean decision quality (every trade fired correctly under the rule) means the process is working as designed. A profitable month with sloppy execution is a red flag — good outcomes that arrive without discipline tell you nothing about the rule.
TraderBear is an AI trading agent built around the architectural pattern above. The intent layer is a language model that translates your plain English into structured rules. The execution layer is TypeScript running on a Cloudflare Worker, with risk caps enforced before any order leaves. Paper money is on by default; going live takes an explicit, multi-step opt-in.
The differentiation people notice first is the bear. TraderBear is a pet you adopt — it gets a name, a stage, a record of what you've trained it on. The pet frame is doing real work: people tend to stick with named, persistent tools longer than with fresh anonymous chat sessions. The bear is also what makes the safety pattern enjoyable to operate rather than tedious.
A system that reads a plain-language goal, monitors markets, and proposes or executes trades on your behalf under explicit risk rules. The agent does the watching and routing; you set the intent and review the log.
The broadest cover stocks, ETFs, crypto, futures, and prediction markets (Kalshi, Polymarket). A good agent abstracts the venue so the same rule can target whichever markets you've enabled.
Only if you (1) start on paper money, (2) the platform enforces risk caps in code at the execution layer (not in a prompt), and (3) every action is logged for audit. If any of those is missing, the safety story doesn't hold.
Not for natural-language agents. You describe what you want in English; the agent converts that into structured rules. The platform handles authentication, routing, slippage, logs.
Risk-cap drift — a tool that started with strict caps silently allowing larger trades because the LLM was "convinced". The defense is architectural: caps in code, not in prompts.
One market category, one rule with explicit numeric thresholds, paper money for several weeks. Calibration first, not profit.
TraderBear runs on plain English, defaults to paper money, and enforces risk caps in code. The bear grows with you — pick a category, write a rule, and see what an agent does when it's designed to be supervised.
Adopt a bear →