How to automate exit plans and take-profit rules for an AI trading agent

An AI trading agent will hold losing positions indefinitely unless it is given explicit instructions to exit. Exit plans and take-profit rules are not suggestions. They are pre-commitments encoded in logic that runs before emotion or drift can interfere. This article presents a practical checklist for building those rules from first principles, using the safety tools available in agentic trading infrastructure.

Why do exit plans fail without explicit automation?

Most discretionary traders exit too late because they change their plan in real time. An agent does exactly what it is told, which is a strength only if the instructions are complete. When exit logic is vague, the agent defaults to inaction. A position that loses half its value while the agent waits for a good time to sell is not a bug. It is a missing rule. The first principle is that every entry must carry a corresponding exit instruction that is defined in dollars, percentages, or time, and that instruction must be submitted as an order or a monitored condition before the trade is live.

The failure modes are predictable. A trader tells the agent to manage risk but does not specify the maximum loss in dollars. The agent interprets this as a suggestion, not a constraint. Another trader sets a mental stop but never encodes it in the API, so a brief outage or logic gap turns a small loss into a large one. Real money can be lost, including the entire budget allocated to the agent. Gaps in connectivity should not become gaps in risk control.

What should an exit plan define before the first trade?

Before the agent opens any position, the owner should answer five questions in writing. The answers become the exit plan. Writing them down removes ambiguity and prevents the owner from rewriting the rules when the position moves against them. The agent will enforce what is written, not what is hoped.

• ·What is the maximum loss in dollars? This is the hard stop. It is not a trailing idea or a technical level. It is the amount of capital the owner is willing to lose on this single position. The agent should receive this as a budget sub-cap.
• ·What is the minimum profit target in dollars? This is the take-profit level. It should be realistic relative to the position size and the volatility of the market. The agent needs a number, not a wish.
• ·What is the time horizon? If the position does not hit the profit target or the stop within a set number of hours or days, the agent should flatten. Time is a risk factor that many plans ignore.
• ·What is the slippage tolerance? In fast markets, the exit price may differ from the stop price. The owner should tell the agent how many dollars of slippage are acceptable before it should use a market order instead of a limit.
• ·What is the correlation rule? If the agent holds multiple positions, it should know whether one position hitting its stop triggers a review of the others. Correlated drawdowns can breach the overall budget even if each individual stop is intact.

This checklist mirrors the approach in a practical checklist for non-custodial AI trading, but narrows the focus to exits. The answers should be stored in the agent's prompt or its configuration, not in the trader's memory. If the plan lives only in the owner's head, it is not part of the automation.

How do you size and place take-profit levels from first principles?

Take-profit rules are not about predicting the top. They are about converting unrealized gains into realized gains before the market reverses. The first principle is asymmetry: the agent should know that a realized gain is more valuable than an unrealized gain of the same size, because the latter can disappear.

One approach is to set take-profit levels as a fixed percentage of the position's entry value. For example, if the agent enters a stock position at one hundred dollars and the plan specifies a five percent take-profit, the agent should submit a limit order to sell at one hundred five dollars at the same time it submits the entry order. This is called bracketing. The advantage is that the exit order lives on the venue's books, not just in the agent's memory. If the agent loses power, the exit order remains active.

Another approach is tiered exits. Suppose the agent holds a position and the plan says to sell one third at a three percent gain, one third at a five percent gain, and let the final third run with a trailing stop. This requires the agent to monitor partial fills and adjust the remaining quantity. The logic is more complex, but it reduces the all-or-nothing risk of a single target. If the first tier fills and the market reverses, the agent has already locked in some profit.

A third approach is time-based profit taking. If the position is up by any amount after twenty-four hours, the agent takes the profit and resets. This sounds mechanical, and it is. The purpose is not to capture the maximum possible move. It is to prevent the agent from giving back gains while it waits for a larger move that may never arrive. Time-based rules are especially useful in prediction markets and event-driven setups where the edge decays quickly.

In all cases, the agent should calculate the dollar value of the take-profit and compare it to the stop-loss dollar value. If the plan risks five hundred dollars to make two hundred dollars, the expected value is negative unless the win rate is extremely high. The agent should not take the trade unless the owner explicitly accepts that ratio. Trading can lose money, including the entire position, and skewed risk-reward plans accelerate that outcome.

The owner should also consider how take-profit rules interact with portfolio-level budget caps. A single position might hit its profit target, but if the agent immediately reinvests that capital into a new position with the same risk profile, the portfolio is not actually de-risking. The exit plan should state whether realized profits reduce the daily or weekly budget, or whether they are recycled. This distinction changes the compound risk profile significantly.

How does the agent enforce exits without human intervention?

The agent must not rely on the owner to be online when the stop is hit. Enforcement happens in two layers: the venue layer and the agent layer. Separating these layers means that a failure in one does not automatically become a failure in the other. The venue layer handles static stops, while the agent layer handles logic that changes with market structure. Both layers should be configured before trading begins.

At the venue layer, the owner should use bracket orders or stop-limit orders where the venue supports them. This means the exit order is resting on the venue's order book before the price moves. If the agent loses connectivity, the venue still holds the instruction. This is the safest form of automation because it removes the agent as a single point of failure. For markets that do not support native bracket orders, the agent must submit the exit order immediately after the fill is confirmed.

At the agent layer, the agent monitors open positions and submits exit orders if the venue-level stops are missing or if the plan requires dynamic logic, such as a trailing stop or a correlation-based flatten. The exact request schema is in the docs; the shape looks like this:

{
  "api_key": "YOUR_KEY",
  "action": "exit_plan",
  "position_id": "abc123",
  "stop_dollars": 500,
  "profit_dollars": 750,
  "time_limit_hours": 48,
  "slippage_tolerance_dollars": 50,
  "order_type": "market_if_touched"
}

The agent should log every exit attempt and every deviation. If the venue rejects an exit order because of volatility or liquidity, the agent should escalate to a wider slippage tolerance or a market order, depending on the pre-written rules. The owner should never need to wake up and decide. The decisions were made when the plan was written.

This enforcement model is part of why running an AI trading agent with real money safely depends on infrastructure that separates the owner's capital from the agent's instructions. The agent can spend within limits but cannot redirect funds. The owner approves withdrawal addresses, and the panic switch can flatten and revoke access if the agent behaves unexpectedly.

How do you test an exit plan without risking capital?

Every exit plan should be tested in paper trading before it controls live capital. Paper trading exists for testing, and live trading requires explicit owner authorization of a key. The owner should force the agent into losing scenarios to see if it exits on time. This means deliberately allocating a small paper budget to a strategy that is expected to lose, or using historical replay if available, without inventing specific performance numbers. Testing only winning scenarios proves nothing. The goal is to verify that the agent loses gracefully and within the planned boundary.

The test should verify three things. First, does the agent submit the exit order at the correct dollar threshold? Second, does it handle partial fills correctly? Third, does it respect the time limit even when the position is profitable but has not hit the take-profit target?

1. 01The agent submits the exit order at the exact dollar threshold written in the plan, not a rounded or delayed version.
2. 02The agent adjusts remaining position size after a partial take-profit fill, and it does not double-exit or leave orphaned shares.
3. 03The agent closes the position when the clock expires, regardless of whether the owner would have preferred to wait.

If the agent hesitates, overrides its own rule, or waits for a better price, the prompt or the configuration is flawed. This is the moment to fix it, not after the first live loss. The kill switch your trading agent cannot override should also be tested during this phase. If the owner triggers the panic switch, the agent should flatten every position and revoke its own access within seconds.

What happens when the market gaps through your stop?

A stop order is not a guarantee. In stocks, crypto, perps, options, and prediction markets, prices can gap past the stop level due to volatility, low liquidity, or session opens. The agent should know this and the owner should accept it. A stop is a request to exit at a certain price or worse, not a magical barrier. Even with the API normalizing venue-specific contract math, the agent cannot normalize market volatility. The owner must internalize that the stop level and the actual fill price are two different numbers.

The plan should include a gap protocol. If the price gaps through the stop, the agent should submit a market order immediately rather than waiting for a fill at the original stop price. The loss may exceed the planned stop by a multiple. This is not a failure of the agent. It is a known property of public markets. The owner should size positions so that a gap-driven loss does not breach the overall budget cap.

For leveraged products, such as perpetual futures or options, a gap can liquidate the position before the agent's stop order is processed. The owner should account for this by setting the stop further away from the liquidation price than the plan's maximum loss would suggest, or by reducing leverage. Trading can lose money, including everything, and gaps are one of the fastest ways.