How AI Trading Signals Work: From Raw Market Data to Executable Trade

When someone says "AI trading signal," most people picture a stock tip with a confidence score. The reality is more interesting — and more useful to understand. A real signal is the output of a multi-stage pipeline that turns raw market data into a structured, risk-bounded recommendation. This article walks through every stage of that pipeline, using SuperKamouBot's architecture as the concrete example.

Stage 1: Raw Market Data (OHLCV)

Every signal starts with data. For crypto futures, the core data is OHLCV — Open, High, Low, Close, Volume — for each candle on each tradable pair. SuperKamouBot pulls 1-hour candles for 30+ perpetual futures pairs on KuCoin: BTC, ETH, SOL, XRP, and 26 others.

Why 1-hour? It's a balance. Shorter timeframes (1m, 5m) are noisier and more expensive to trade relative to edge. Longer timeframes (4h, 1d) produce fewer signals and slower feedback. 1H is the sweet spot for a system that wants multiple signals per day without high-frequency infrastructure.

Data Quality Matters

Garbage in, garbage out. Before any analysis, the data must be checked for:

• Gaps — missing candles (exchange downtime, API issues)
• Stale data — candles that haven't updated (WebSocket degradation)
• Outliers — impossible prices from API glitches

SuperKamouBot runs a data-quality gate that rejects stale or gapped data before it enters the pipeline. A signal built on bad data is worse than no signal — it's a confident wrong answer.

Stage 2: Technical Indicators

From clean OHLCV data, the system computes a battery of indicators. These are the raw materials for the ranking layer.

Common indicators include:

• Momentum — RSI, MACD, rate of change. Measures whether price is accelerating or decelerating.
• Trend — moving averages (SMA, EMA), ADX. Measures whether price is trending and how strong the trend is.
• Volatility — ATR, Bollinger Bands. Measures how much price is moving, which affects position sizing and stop placement.
• Structure — support/resistance levels, higher highs/lower lows. Measures the market's current shape.

No single indicator generates a signal. They're inputs to the next stage — the ranking.

Stage 3: Mathematical Ranking (T1)

This is where the system scores every pair. For each of the 30+ pairs, the T1 layer combines the indicators into a single score: "how good does this pair look right now?"

The scoring is not a fixed formula. It weighs indicators differently depending on the detected regime:

• Trending regime — momentum and trend indicators weighted higher
• Ranging regime — mean-reversion indicators (RSI extremes, Bollinger band touches) weighted higher
• Volatile regime — volatility and structure weighted higher; momentum de-weighted because it whipsaws

The output is a ranked list: pair A scores 0.82, pair B scores 0.71, pair C scores 0.65, and so on. The top candidates move to the next stage. The bottom ones are discarded.

Why Ranking, Not Binary Signals

A binary "buy BTC" signal throws away information. A ranking tells you not just "BTC looks good" but "BTC looks better than ETH right now, and both look better than SOL." This matters when you can only take a few positions at once — you want the best ones, not just any that pass a threshold.

Stage 4: Rules-Based Veto (T2)

The veto layer is the safety net. It takes the top-ranked candidates and applies hard filters that cannot be overridden:

• Risk per trade — would this position risk more than 1% of balance? Reject.
• Max exposure — would opening this position push total exposure above 15%? Reject.
• Correlation limit — are you already long a highly-correlated pair? Reject.
• Regime match — does the strategy match the current regime? If not, reject.
• Daily loss limit — has the bot hit its daily loss cap? Reject everything.

The veto layer is non-negotiable by design. The AI refiner in the next stage can downgrade a trade, but it cannot override a veto. This is what keeps the system safe when the math layer is wrong.

The Veto Is Not Optional

Many bot projects skip this layer or make it advisory. That's how accounts get blown up. The veto layer is the difference between a system that has a bad day and a system that has a catastrophic day. SuperKamouBot's veto is enforced in code, on every candidate, every cycle.

Stage 5: AI Refinement (T3)

The candidates that survive the veto go to the AI refiner — a language model that applies judgment the math layer can't.

The refiner receives:

• The candidate trade (pair, side, entry, SL, TP)
• The current regime and market context
• Recent trade history for this pair
• Relevant indicators and their recent behavior

It then asks: does this trade make sense given everything I can see?

The refiner can:

• Approve — the trade proceeds to execution
• Downgrade — reduce confidence, which may reduce position size
• Reject — the trade is discarded

What the Refiner Is NOT

The refiner is not a price predictor. It does not say "BTC will go to $70,000." It says "given that BTC is trending up, momentum is aligned, and the regime supports trend-following, this long candidate is reasonable" — or "momentum is aligned but we just had a volatility spike that often precedes reversals, so I'm downgrading."

It's a quality gate, not an oracle. The edge still comes from the math layer; the refiner just filters out the candidates where context suggests the math is about to be wrong.

Stage 6: Execution

Approved trades go to the execution layer. This is where the signal becomes an order.

• Position sizing — based on risk per trade, stop-loss distance, and current balance
• Order placement — via the exchange API (KuCoin Futures for SuperKamouBot)
• Stop-loss and take-profit — placed at the exchange level, not just tracked internally. If the bot crashes, the SL/TP still execute.
• Confirmation — the bot waits for fill confirmation and reconciles

Why Exchange-Side SL/TP Matters

If your stop-loss only exists in your bot's memory, a bot crash means no stop-loss. Exchange-side SL/TP means the exchange enforces the exit regardless of what your bot does. This is a non-negotiable safety feature for any live system.

Stage 7: Monitoring and Reconciliation

After execution, the system monitors open positions and reconciles its state against the exchange every cycle:

• Did the order fill? At what price?
• Did the SL or TP trigger?
• Is the exchange's view of the position the same as the bot's?
• Has the regime shifted such that the trade should be closed early?

Drift between internal state and exchange state is the silent killer of trading bots. Reconciliation catches it before it causes bad decisions.

The Full Pipeline in One Sentence

Raw OHLCV → indicators → mathematical ranking → risk veto → AI refinement → execution with exchange-side SL/TP → continuous reconciliation.

Every stage exists for a reason. Remove the ranking, and you trade random pairs. Remove the veto, and you blow up on risk. Remove the refiner, and you take trades the math can't see are wrong. Remove reconciliation, and you trade on stale state.

See the Live Output

You can see the trades this pipeline produces on the results page — every trade, win and loss, with entry, exit, and PnL. The how it works page has the full architecture. If you want the signals in your own dashboard or via API, see pricing.

---

Disclaimer: Trading cryptocurrency futures involves substantial risk of loss. Past performance does not guarantee future results. This is not financial advice.