The API Call That Isn't Doing What You Think

Pull up the GitHub repo for ten "AI" crypto trading bots. Look at the file that actually fires orders. Nine times out of ten you'll find a function called something like evaluate_signal() or should_trade() that takes a price feed, runs it through an RSI, a MACD, maybe a Bollinger band, and returns True or False. Somewhere else in the repo there's a separate function — let's call it explain_decision() — that takes the boolean result, stuffs it into a prompt along with the indicator values, and asks an LLM to write a paragraph explaining why the bot just bought.

That's the wrapper. The decision happened before the model saw anything. The language model is a narrator, not a trader. It is generating prose around a verdict that was already sealed by code.

This is the single most common architecture in "AI" crypto products right now, and it's structurally identical to what people were shipping in 2019 before anyone had a reason to call it AI. The rebrand is the product. The thinking is the marketing.

What a Wrapper Actually Computes

To be precise about this, a wrapper is a piece of code where the trading logic is deterministic — if X then Y — and the LLM is bolted on for one of three jobs: explaining trades after the fact, parsing news headlines into a sentiment score that feeds back into the same if-then tree, or generating a strategy description that a human reads once and walks away from.

None of those require reasoning. They require pattern matching and text generation, both of which a model does well and neither of which a model needs to do before a trade. The trade still fires when RSI crosses 30. The model just gets to write the post-mortem.

The reason this architecture is so common is that it ships fast. You don't need to engineer a real decision loop. You need a rules engine you've already debugged, a wrapper around the OpenAI client, and a frontend that surfaces the model's output as "AI reasoning." The user sees paragraphs. The code does what it always did.

What Real Reasoning Looks Like on the Tape

Here's a contrast using the current market. Bitcoin rejected $87K resistance on heavy profit-taking, with $1.05B in unrealized gains stacked at that wall. Funding sits neutral at 0.0032%, long/short balanced at 57/43. The daily candle printed bearish, pulled back 3% into weekend low-volume, but held above $83K order block support — higher-low structure intact. Futures CVD turned positive on the dip.

A rule engine reads that. Most will fire a short because the candle is red and price is below recent high. Some will fire a long because the higher-low held. The signal is whichever one the developer coded first.

A genuinely reasoning agent reads it differently. It weights the signals against each other. The bearish daily is real, but it printed into a known support zone with thin weekend liquidity and an aggressive derivatives bid showing in CVD. The $87K rejection is real, but the unrealized gains sitting there are a known resistance pocket, not a regime change. Funding being neutral rules out a crowded long about to squeeze. The higher-low structure being intact is the highest-conviction fact in the tape — it overrides the candle color.

That's not a rule. It's a hierarchy of evidence being applied to conflicting inputs in real time, with the conclusion depending on which inputs the model trusts more in this specific context. A wrapper can't do that. A wrapper can only narrate the conclusion the rules already reached.

The Reasoning Test

Here's the practical question: when the agent takes a position, can you see why before the trade fires, and does the reasoning look specific to this moment in the market?

If the explanation is generic — "RSI is oversold, MACD crossed up, bullish divergence on the 4H" — that's a wrapper. Those are the indicator values the rule used. The model transcribed them.

If the explanation names the conflict — "the daily is bearish but the higher-low at $83K held with aggressive CVD bid, and funding is neutral so this isn't a crowded long" — and explains why one side of the conflict won, that's reasoning. The model had to weigh evidence against itself.

The distinguishing feature is not the length of the explanation. It's whether the reasoning could apply to a different trade in a different week. Wrapper outputs do. Real reasoning outputs don't, because the conclusion depends on the specific configuration of inputs the agent is staring at right now.

Show Me the Reasoning, Mid-Decision

There's a second tell that's harder to fake: does the agent surface its reasoning before the trade, or only after?

After-the-fact explanations are free. The decision is already made, the trade is already on, and the model can manufacture any justification that fits. This is how most wrapper products work. You get a beautiful paragraph on the dashboard explaining why the bot bought SOL at 3pm. You have no way to know whether the model approved that trade or whether the rule did and the model wrote the eulogy.

BullSpot's market report is built around a different idea: the agent posts reasoning while the decision is still live, including the cases where it vetoes itself. When the agent says no, you see the veto. That's the only way to know whether the model is actually in the loop. If you can't see the rejected trades, you can't know whether the system is reasoning or just narrating.

The Regime Problem Wrappers Can't Solve

Wrappers break at regime changes. This isn't a hypothetical — it's structural. A rule engine encodes the market the developer was looking at when they wrote it. If they wrote a long-only trend bot during a bull market, it dies in a range. If they wrote a mean-reversion bot in 2022, it gets run over by a trending Q4.

A reasoning agent is supposed to notice the regime shift and adjust. The current tape is a useful example: BTC/XAU ratio closed Q3 +37%, its strongest quarterly print since Q4 2024. That's a relative-strength breakout that quietly reframes the entire macro context — Bitcoin is winning capital away from gold, not just rallying against the dollar. A rule engine with a "Bitcoin vs. SPY" signal in it doesn't know that. A reasoning agent can take a position that's bullish BTC because the BTC/XAU ratio is breaking out, not in spite of it.

This is the gap the wrapper was supposed to close and didn't. Adding an LLM to a rule engine doesn't make it adaptive. It makes it a rule engine with a translator. When the regime changes, the rule engine still does what it was coded to do, and the model still writes a confident paragraph about why.

How to Audit a Bot Before You Hand It a Wallet

Five concrete checks, in order of how much they tell you:

1. Find the file that fires orders. If it's a rules-based function that returns a boolean from indicator values, you're looking at a wrapper. No amount of LLM-generated prose in the surrounding files changes that.

2. Look for the veto path. A system that's actually reasoning will have a record of trades it considered and rejected. If every published trade is a winner, the system is curating, not trading. If you see vetoes with reasoning, the agent is genuinely evaluating setups and sometimes saying no.

3. Read three explanations and time-shift them. Take an explanation from last week and apply it to this week's tape. If the wording still sounds appropriate, the reasoning is generic and you're looking at a wrapper. If the conclusion only makes sense for the specific inputs the agent had, it's reasoning.

4. Look for regime awareness. Does the system ever change its behavior in response to a structural shift — funding flipping, BTC/XAU ratio breaking out, ETF flows reversing? If it always does the same thing regardless of the broader context, the rules are static and the LLM is decoration.

5. Check whether reasoning is shown pre-trade. After-the-fact explanations prove nothing. Pre-trade reasoning, including vetoes, proves the model is in the loop.

What This Means If You're Choosing a Bot

If you're sizing real capital against one of these systems, the question isn't "does it use AI." Of course it does. Every wrapper uses AI. The question is: does the AI participate in the decision, or does it describe the decision the rules already made?

The only way to know is to look at the receipts. Wrapper decisions are explainable in public but not verifiable — the model can write a beautiful justification for any trade the rules took. Real decisions are verifiable because you can see the reasoning before the order, the cases where the agent vetoed itself, and the moments where the system changed its mind because the tape changed.

The current tape makes the test easy to run. Anyone selling an "AI" bot right now should be able to point to a recent trade and explain why the system went long into a bearish daily candle at the bottom of a $3K pullback while funding was neutral and CVD was bid. If the explanation is a list of indicators that all pointed up, you're looking at a wrapper that happened to get lucky. If the explanation weighs the conflicting inputs and explains why the higher-low structure and the neutral funding outweighed the candle color, you're looking at something that might actually be reasoning.

The Takeaway

  • The wrapper architecture is the default. Most "AI" bots are rules engines with an LLM bolted on to generate explanations. Find the order-firing function and you'll see it.
  • Real reasoning shows the conflict. A wrapper explains a trade by listing indicator values. A reasoning agent explains a trade by explaining which inputs it trusted more when they disagreed.
  • Pre-trade transparency is the tell. If you can see the reasoning before the order, and you can see the vetoes, the model is in the loop. If you only see explanations after the fact, the rules are in the loop and the model is the narrator.
  • Regime changes expose wrappers. Static rules break when the market structure shifts. Reasoning adapts. Check whether the system has ever changed its behavior in response to a structural shift — funding flipping, BTC/XAU ratio rotating, ETF flows reversing.
  • Audit before you allocate. Five checks, in order: find the order-firing file, look for vetoes, time-shift the explanations, check for regime awareness, verify pre-trade transparency. If any of those fails, you're funding a narrator.

The market doesn't care whether your bot calls itself AI. It only cares whether the decision the bot made was the right one. Find out which kind of system you're looking at before you find out the hard way.

Source context: BullSpot report from 2026-10-04T04:42:01.723Z (Fresh report: generated this cycle).