How to size positions for an AI trading agent using MCP

Position sizing determines how much capital an AI agent commits to each trade, and it matters more than the signal that triggers the trade. For agents using MCP to connect to trading infrastructure, sizing is not just a strategy parameter; it is a safety boundary. A poorly sized position can erase a budget faster than a wrong direction. Getting this right first is the difference between an agent that survives its learning phase and one that does not.

Why does position sizing matter more than entry timing?

Most beginners spend the majority of their effort refining entry logic, but the size of the trade is what determines whether a small error becomes a catastrophic loss. An agent can be directionally correct on a market move and still lose its entire budget if it commits too much capital to a single position. Volatility can turn a minor pullback into a margin call or liquidation when the position is oversized. The entry signal tells the agent when to act; the sizing rule tells it how much of its operating budget to risk. In agentic trading, the sizing rule functions as the primary guardrail because the agent acts autonomously once it is running. If the sizing logic is loose, the human operator cannot intervene fast enough on every single order, especially when the agent is connected through an MCP tool loop that can execute multiple steps per minute. There is also a subtle risk specific to autonomous systems. An agent can get stuck in a feedback loop where it believes it has an edge and should increase exposure. Without a hard sizing rule, this loop can escalate quickly. Trading can lose money, including everything, so the first goal of any beginner should be to preserve capital long enough to learn. A tight sizing rule keeps individual losses small and predictable, which is more valuable than a perfect entry algorithm.

How do dollar-based orders simplify sizing for agents?

When an agent reasons in shares, contracts, or lots, it must understand venue-specific math that humans and language models often get wrong. Felix normalizes this by accepting orders in plain US dollars, so the agent thinks in terms of exposure rather than contract counts. If the agent decides it wants $300 of risk, it sends a size of 300. The infrastructure translates that into the correct number of contracts, shares, or units for the specific venue. This removes an entire class of errors where an agent miscalculates tick sizes, multipliers, or decimal places. The agent does not need to know whether a perps contract is worth one dollar or twenty dollars per point; it only needs to know how many dollars it is willing to put at risk. Dollar sizing also makes risk management uniform across the five market types. A $100 position in a stock and a $100 position in a crypto perpetual carry the same notional exposure, even though the underlying mechanics differ. The exact request schema is in the docs; the shape looks like this:

{
  "market": "perps",
  "symbol": "EXAMPLE-PERP",
  "side": "buy",
  "size_usd": 150,
  "time_in_force": "gtc"
}

In this illustrative shape, the agent sets size_usd to 150 and the system handles the contract translation. The operator does not need to prompt the agent with venue-specific contract specifications. This simplicity is important because MCP tools are often invoked by LLMs that can hallucinate numbers or misread decimal points. By constraining the conversation to whole dollar amounts, the operator reduces the chance that a parsing error leads to an order of magnitude mistake. The agent still needs a sizing rule, but the rule lives in a space the operator intuitively understands. There is no need to explain lot sizes, minimum increments, or notional calculations in the system prompt. The operator can say, risk fifty dollars per trade, and the API enforces that intent across stocks, crypto, perps, options, and prediction markets.

What safety controls should you set before the agent trades?

Sizing logic inside the agent prompt is not enough. The infrastructure must enforce hard limits that the agent cannot override through reasoning or misinterpretation. Felix provides scoped keys, budget caps, position limits, and a panic switch that flattens positions and revokes access. These controls act as a floor underneath the agent's reasoning. Before you connect an MCP client, you should configure a scoped API key that carries a maximum single-order size. If the agent tries to request $5,000 but the key is capped at $500, the order is rejected before it reaches a venue. Budget caps add a second layer by limiting total exposure across a time window, such as a day or a week. Position limits prevent the agent from building an oversized concentration in one market, even if each individual order is small. A kill switch gives the owner a manual override that cancels everything and disables the key. You can learn more about setting these up in our guide on building scoped API keys for a trading agent. These controls are non-custodial by construction; the agent can spend within limits but can never withdraw funds to itself. Withdrawal addresses are owner-approved only. The combination of prompt-level sizing and infrastructure-level enforcement creates defense in depth. Even if the agent misinterprets its instructions or the LLM produces an unexpected tool call, the hard limits keep the damage bounded. This is especially important when running an agent through an MCP client that may execute tool calls automatically.

How should a beginner think about risk per trade?

Beginners should start with a fixed dollar amount per trade rather than a percentage of the total budget. Percentage sizing sounds sophisticated, but it requires the agent to recalculate on every trade and can lead to larger absolute sizes as the account grows. A fixed dollar rule is easier to audit, easier to enforce in a scoped key, and easier to reason about when debugging. Suppose your agent starts with a $2,000 budget and you set a fixed $100 per trade. That gives you twenty discrete attempts before the budget is exhausted. This framing makes the risk concrete. You can look at the budget and know exactly how many mistakes you can afford. If you are starting with limited capital, see our guide on how to start an AI agent with a small budget. As the agent proves itself in paper trading, you can gradually increase the fixed amount or introduce a percentage rule. A common beginner mistake is to let the agent scale up after a win streak without resetting the cap. The sizing rule should be boring and consistent. Consistency protects you from emotional overrides or agentic overconfidence. Trading can lose money, including everything, so the sizing rule should assume the next trade will be a total loss. If you would not be comfortable lighting that amount on fire, the position is too large. Another useful heuristic is to size so that a gap or wick against your position does not trigger a liquidation or force a margin call. In leveraged markets, this means keeping the notional exposure small relative to the account equity.

How does paper trading help validate sizing logic?

Paper trading lets you test sizing rules without committing real capital. You should run the agent for enough simulated trades to see whether it respects the dollar limits you set. Watch for edge cases where the agent rounds up, splits orders, or interprets a $100 limit as $100 per leg of a multi-step strategy. Paper trading also reveals whether the agent handles different market types correctly. A $100 stock order and a $100 perps order may behave differently in terms of margin and liquidation risk, even though the notional size is identical. Use the paper phase to confirm that the scoped key limits and budget caps are actually enforced. Before you authorize live keys, run the agent through paper trading evaluation. If the agent violates sizing rules in simulation, fix the logic before it touches real money. Paper trading is only useful if you treat the simulated budget as real. Size the paper account to match the live budget you intend to use. If you plan to trade with $1,000 live, give the paper agent $1,000 and watch how it survives. This alignment prevents the psychological trap of being reckless in simulation and cautious in live markets. It also lets you measure the impact of fees on small sizes, which can be significant in prediction markets and options venues.

What should you check before taking sizing rules live?

Moving from paper to live requires more than flipping a switch. Review the following before you authorize a live key. Many of these checks are covered in what beginners get wrong when taking an AI trading agent live.

• ·Verify that the scoped key used for live trading has the same or stricter limits as the paper key. It is easy to accidentally create a live key with a higher cap during setup.
• ·Confirm that the budget cap is active and that the agent cannot bypass it by splitting orders across multiple calls within the same window.
• ·Check that the kill switch is reachable without opening a code editor. You should be able to flatten and revoke from a dashboard or a single command.
• ·Review the agent's prompt template to ensure the sizing rule is explicit and not buried in examples or implied from context.
• ·Set an exit plan. Decide in advance what happens if the agent hits a drawdown threshold, such as halting for twenty-four hours or requiring manual reauthorization.

Live authorization should be a deliberate ceremony, not a default next step. Once live, monitor the first few orders closely to confirm the sizing matches your intent. If the first live order is even slightly off, stop and debug. Early errors in live trading compound faster than in paper trading because slippage and fees are real. Preserve the habit of checking size before every session until the agent has proven consistency over a meaningful period.