How paper trading works for AI agents from first principles

Paper trading for an AI agent is a simulated execution environment where the agent places orders against real market data using synthetic balances. It lets a developer observe how an agent behaves when it believes it is trading real money, without exposing actual capital to market risk. The goal is to test logic, safety controls, and integration before the agent receives authorization to spend real funds. Because the agent reasons through an LLM and acts through an API, paper trading must replicate the full round trip of data, decision, and execution.

What is paper trading for an AI agent?

Paper trading creates a mirror of live market conditions. Prices, spreads, and order book depth reflect what the agent would see in production, but settlements occur in a ledger that holds no real value. The agent receives a starting balance in plain US dollars, as it would in live mode, and submits orders through the same API. The system records fills, positions, and unrealized profit or loss as if the trades were real. This allows the agent to experience the full lifecycle of an order, from submission through settlement, without any transfer of actual assets. The exact request schema is in the docs; the shape looks like this:

curl -X POST https://api.felix.trade/v1/orders \
  -H "Authorization: Bearer YOUR_KEY" \
  -H "X-Paper-Trading: true" \
  -d '{
    "market": "perp",
    "side": "buy",
    "size_usd": "150.00"
  }'

In this mode, the API returns the same response structure it would use for a live order. The agent parses the fill price, the remaining size, and any errors exactly as it will later do when the money is real. For an AI agent, this is not a game. It is a rehearsal with realistic consequences on a fake balance. The agent does not know it is in paper mode unless the developer explicitly tells it. This opacity is important because it prevents the agent from changing its behavior based on whether the money is real or synthetic. If the agent were aware that losses do not matter, it might take risks that it would otherwise avoid, which would corrupt the test.

Why does paper trading matter before an agent touches real money?

AI agents act autonomously within their scoped permissions. They read data, form intent, and submit orders faster than a human can review each step. If the agent contains a logic error, a misunderstanding of order sizing, or a flawed interpretation of market structure, that error can repeat at machine speed. Paper trading slows the cost of discovery to zero. It gives the developer time to observe patterns of behavior, such as whether the agent respects budget caps or whether it misreads a tick size. It also reveals integration issues, like whether the agent can parse the response from a prediction market or handle partial fills on a perps venue. An agent that has never placed an order may not understand that a market order can fill across multiple price levels. It may not realize that a limit order can sit unfilled for hours. Watching the agent encounter these realities in paper mode lets you correct its prompt or its tool definitions before those mistakes cost money. Real money amplifies every mistake. Trading can lose money, including everything, and an agent that has not been tested in a realistic environment is more likely to trigger unintended losses. Paper trading is the only phase where you can let the agent fail safely.

How does paper trading differ from manual backtesting?

Human traders often associate paper trading with manual practice accounts or spreadsheet backtests. An AI agent operates differently. It does not click buttons. It consumes API responses and emits structured orders through an MCP tool or a REST endpoint. A backtest usually replays historical data and assumes fills at mid prices or average execution. Paper trading sends actual orders to a simulated matching engine. The agent experiences slippage, rejected orders, and price changes between decision and fill. This matters because an LLM agent reasons in natural language before it acts. The delay between reasoning and execution, plus the shape of the API response, can alter outcomes in ways that a static backtest cannot capture. In a backtest, the agent might appear brilliant because it bought every dip and sold every peak. In paper trading, the order might arrive late, or the book might have moved, and the fill price is worse than expected. The agent must also handle the cognitive overhead of parsing JSON, interpreting errors, and deciding whether to retry. These are not abstract concerns. They are mechanical realities that separate a working agent from a theoretical strategy. How paper trading changes when AI agents trade real money explains this distinction in more detail.

What can you actually test in paper mode?

Paper trading is not just about strategy performance. It is a systems integration test. You can verify that the agent understands the dollar-based order sizing abstraction. You can confirm that it handles the five market types, stocks, crypto, perps, options, and prediction markets, without mixing up contract specifications. You can observe whether the agent respects the scoped key it has been given. A scoped key might allow the agent to trade on a specific venue but not to withdraw funds. In paper mode, you can test that the agent never attempts an unauthorized withdrawal, even if its prompt contains a request to do so. You can also test the panic switch. If you trigger the kill switch during paper trading, the agent should flatten positions and revoke access immediately. This is the right time to discover whether your exit plan actually works. You can test how the agent responds to a denied order. Suppose the API rejects a trade because the position limit has been reached. Does the agent log the error and wait, or does it try to circumvent the constraint by splitting the order into smaller pieces? Paper mode reveals the agent’s true compliance posture. You can also test the handoff between reasoning and action. An agent that generates a brilliant trade idea but then constructs a malformed API request is not ready for live markets.

What safety controls should you verify in paper mode?

Before an agent trades live capital, every hard limit should be exercised in paper. This includes budget caps, position limits, and allowed instruments. How to give an AI agent a small trading budget it cannot overspend describes how these limits are enforced at the API level rather than in the agent's prompt. In paper mode, you should attempt to breach the cap intentionally to see if the API rejects the order. You should test whether the agent can open a position larger than the limit you configured, or whether it can trade an asset class you did not authorize. You should also test the exit plan. Suppose you set a rule that the agent must close all positions if the portfolio drops by a specific amount. In paper mode, you can simulate that drawdown and watch whether the agent complies or continues trading. If the agent ignores the limit because the prompt is ambiguous, you want to learn that now. You should verify that the kill switch works as intended. The owner should be able to flatten positions and revoke the key instantly. If there is any delay in paper mode, there will be a delay in live mode. You should also confirm that the agent cannot change the withdrawal address. In a non-custodial system, the owner pre-approves where funds can go. The agent should never be able to redirect money to a new address, even if the prompt asks it to update the destination. Testing this in paper mode costs nothing. Testing it in live mode could cost everything.

When is an agent ready to leave paper trading?

An agent is ready for live authorization when it has operated through multiple market conditions without violating constraints. This includes high volatility, low liquidity, and normal ranges. The agent should have demonstrated that it can handle errors, such as rejected orders or empty responses, without entering a loop of repeated submissions. It should have shown that it respects the owner-approved withdrawal addresses and never attempts to move funds outside its scope. The developer should also review the audit logs. Every action the agent took in paper mode should be explainable. If the agent made a losing trade, the developer should understand why. The agent should not have secrets. Its reasoning should be visible in the logs, and its orders should map cleanly to its stated intent. A practical checklist for running autonomous trading systems with real money offers a structured set of criteria for this transition. Moving to live trading is not a reward for good paper results. It is a decision to accept real risk after the mechanics have been proven. Even then, the first live trades should use the smallest budget the API allows. Paper trading removes financial risk, but it does not remove the risk of a poorly built agent.

Why do paper results often mislead beginners?

Beginners sometimes treat paper profitability as evidence that the agent will succeed with real money. This is a mistake. Paper trading does not account for the psychological and market impact of real execution. In live markets, your order can move the price, especially on smaller venues or less liquid options. Paper fills assume the book absorbed the trade without disruption. An agent that appears profitable in paper mode may be relying on unrealistic fill assumptions. Why paper trading misleads beginners who build AI agents discusses these gaps in depth. Another issue is that paper trading does not simulate counterparty risk or venue downtime. The API is always available in test mode, but live venues experience maintenance, rate limits, and outages. An agent that has never faced a timeout may behave unpredictably when one occurs. Paper trading also hides the stress of real losses. A developer might leave the agent running for days in paper mode and celebrate a positive return. In live trading, the same sequence of trades might cause anxiety that leads the developer to shut the agent down prematurely, or worse, to override it with emotional decisions. Paper trading proves that the agent can connect and trade. It does not prove that the strategy is profitable or that the agent is robust. The only way to test true robustness is with real money at a scale you can afford to lose.