Same labels, different failure modes once leverage is on

A grid bot and a language-model agent can both be sold as an "AI trading bot." On spot those differences already matter; leverage amplifies them. Turn on leverage and the gap changes shape: a small error in a decision is scaled by position size, costs keep accruing while the position is open, and the venue, not the bot or the agent, decides when a position is closed by force.

Agent products and models such as Grok Bot and Meta's Muse Wonder model series show how common agents have become for general tasks. Neither announcement page mentions trading, crypto or leverage. Nothing below claims either one connects to LeverUp. This post is the second in the Agentic Trading on Perps series and covers only what leverage adds.

A one-paragraph reminder: bot versus agent

A bot runs rules someone wrote in advance. An agent puts a language model in the loop to decide what to do next, often across several tools. The full comparison, including inputs, auditability and cost, lives in AI trading agent vs trading bot, and the question of whether bots make money is in Do AI trading bots work?. The rest of this post assumes you have that split in mind and asks one question: what changes when the account is leveraged?

What leverage changes for both

Leverage separates margin from exposure. LeverUp's opening-a-position docs describe traders choosing collateral, exposure size and leverage, with optional stop-loss and take-profit orders. Exposure is a multiple of the margin put up, so the same wrong call costs a larger share of the account.

Three things follow, and they apply to a bot and an agent alike:

  • Errors scale. A bad entry, a misread price or a wrong size does proportionally more damage.
  • Time costs money. A position that sits open pays fees for as long as it sits.
  • Someone else holds the exit. Past a threshold, the venue closes the position whether or not the operator agrees.

What differs is how each kind of system produces the error in the first place.

How a rule-based bot fails under leverage

A rule-based bot does what its rules say, including when the rules no longer fit the market. These examples are hypotheticals, not observations of any real bot.

Range logic meets a breakout. Imagine a grid bot built for a range. Price leaves the range and keeps going. Without a stop condition, the bot keeps adding to the losing side. On spot, that is a large unrealized loss. With leverage, increasing exposure without proportionately increasing margin can reduce the position's buffer against further losses. On LeverUp, adding in the same direction on the same pair with the same margin token merges quantity and margin and updates the weighted entry, so the liquidation effect depends on those changes (opening-a-position docs).

No awareness of carrying costs. Many simple rule sets are written around price and nothing else. A bot with an entry rule, an exit rule and no clock can hold a position far longer than its designer pictured, and the cost of holding grows with that time.

Stale or wrong parameters. A leverage setting or position size that made sense in testing can be wrong on a different market, and a fixed rule repeats the same mistake consistently.

The common thread is that the bot is consistent. Its logic can be easier to debug, but it may keep an unsuitable strategy unless its rules detect the change.

How an LLM agent fails under leverage

An agent adds flexibility, and with it some failure modes a rule set does not have. Again, these are labelled hypotheticals.

A confident wrong number. A model asked for the current funding rate or price may answer from memory instead of fetching it. If that figure feeds a sizing decision, the leveraged position is sized on a guess. This is one reason the decision step should read live data from the source, a point made in AI trading agent vs trading bot.

Tool-call ordering mistakes. An agent that places an order, then adjusts margin, then sets a stop, can get the sequence wrong or stop partway through. A position that exists without its intended stop is a different risk from one that never opened.

Context drift overnight. An agent running for hours accumulates context. Earlier instructions can be diluted, summarized away or contradicted by later text. A limit that was clear at the start of a session may carry less weight many steps later.

Different answers to the same question. Outputs can vary between runs. Under leverage, a small variation in how the agent reads "reduce risk" can be the difference between trimming a position and closing it.

The pattern: a bot fails by being rigid, an agent fails by being inconsistent. Leverage makes both costly, in different ways.

Holding and funding: costs that accrue while a position is open

On LeverUp, two fees accrue while a position is open. Per the holding and funding docs, the holding fee accrues per second based on position notional and holding duration, with the rate locked at opening and the fee deducted when the position closes. The funding fee exists to keep long and short open interest balanced: when one side is crowded, that side pays the other, and the rate is 0 when the two are equal.

The relevant variable is duration, not how often anyone checks the position. A bot that polls once a second and an agent that wakes once an hour accrue the same fees on the same open position, because fee accrual depends on elapsed holding time. Checking more often does not cut them; closing does.

An assumed illustration, extending the docs' own worked example. The docs show a 10,000 USDC long paying about 3.51 USDC over 24 hours at an assumed 12.8% annualized funding rate. If the rate were held constant (assumed; the docs describe a rate that moves with open-interest skew), seven days would cost roughly 10,000 × 12.8% ÷ 365 × 7 ≈ 24.5 USDC, before the holding fee. Against margin of 1,000 USDC at an assumed 10x, that is about 2.5% of margin for a position that did nothing but stay open.

A rule-based bot with no funding input will not see that cost. An agent might see it, if it is given the data and asked, but that is only as reliable as the data it reads. Neither is protected by default.

Liquidation and fee drift

Liquidation is decided by the venue. The liquidation docs say a position is liquidated when the market price reaches the liquidation price or when collateral becomes insufficient to cover outstanding fees. For a long, the docs give the liquidation price as the entry price minus (collateral × liquidation loss rate − fees) ÷ position size, where fees include the close fee, holding fee and funding fee, and the loss rate is set per pair, 85% on most and 80% on some.

Fees sit inside that formula, so the liquidation price is not a fixed number. An assumed example using the docs' formula for a long: entry price 100, collateral 100 USDC at 10x, so position size is 10 units, and an 85% loss rate. With zero fees, the liquidation price is 100 − (85 ÷ 10) = 91.5. If 5 USDC of fees have accrued, it becomes 100 − (80 ÷ 10) = 92.0. The line has moved closer to the entry price although nobody changed the position. (The docs' simplified condition also nets funding received against costs, so the direction of drift depends on which side of funding the position is on.)

This is where a prompt-based agent can go wrong in a quiet way. If an agent calculated its liquidation price at entry and stored it, that number can be stale hours later. A stop placed "safely" above the entry-time figure may sit closer to the real threshold than the agent believes. The fix is to read the venue's current position data instead of trusting a stored calculation, and to leave room for fees. For the full mechanics, see how liquidations work on LeverUp.

A prompt is not a risk rule

One idea runs through the failure modes above. A line in a prompt such as "keep leverage low" is an instruction the model weighs. A code check that rejects any order above a set leverage holds regardless of what the model concludes. Under leverage, the gap between the two is the gap between a suggestion and a limit. The prompt can shape behavior, but it should not be the only thing standing between a model's output and a leveraged order. How to build those checks is the subject of upcoming posts in this series, and key permissions are covered in AI trading agents need scoped permissions.

A practical split: when a bot is enough, when an agent needs code-level limits

Neither is better by default. Some rough guidance, for education only:

  • A bot can be enough when the job is narrow and the rules are tested: fixed size, fixed market, an explicit exit, and a hard stop on duration or loss. Its rigidity is an asset when the rules are right.
  • An agent earns its place when the job needs interpretation, such as summarizing conditions or preparing a trade for a person to approve. The more authority it has over leveraged orders, the more its limits should live in code outside the model.
  • Combined setups let an agent propose and deterministic code check, a pattern explored in the proposed decision-layer design, which is a proposed architecture and not a live LeverUp feature.

If an agent is connected to a venue at all, LeverUp's documented route is the One-Click Trading hosted-agent mode, walked through in the Grok Bot trading guide. That guide covers setup; this series covers what to put around it. Post #3 looks at scoped keys and post #4 at pre-trade checks in code. A spending budget is not a leverage limit either, as this Manus Cue explainer argues. For the underlying mechanics, the perpetual futures learning path is a good start.

Closing

Leverage does not make bots or agents good or bad. It makes their characteristic mistakes more expensive: a bot's rigidity, an agent's inconsistency, and for both, the cost of time and the venue's control over the exit.

LeverUp uses a protocol-managed virtual liquidity system powered by the VMMV, where trades reference oracle pricing while execution, settlement, and risk management are handled at the protocol layer. See the documentation on pricing and order execution, VMMV settlement, protocol risk controls, and liquidation.

This article is educational and is not financial advice. Perpetual futures use leverage and can result in the loss of your margin.