How Trading IA works: from the market to the panel

Every five minutes, a piece of data that just happened in the market travels the same road: it comes in, gets ranked, becomes a decision, leaves as a limit order to your exchange and returns to the panel as something you can verify. This article follows that road from end to end.

1. The market comes in

The system doesn't watch a chart: it watches 291 signals at once. They come from five different places and refresh every cycle.

• Price and microstructure: candles, RSI across timeframes, volatility, and the live order book over WebSocket (buy and sell pressure, flow toxicity).
• Derivatives: aggregated funding from dozens of exchanges, open interest, liquidations and where they cluster.
• On-chain: coins moving into and out of exchanges, realized profit of holders, whale movements.
• Macro and institutional flow: VIX, the dollar, rates, Bitcoin ETF flows, stablecoin issuance.
• Sentiment and news: fear and greed, and a news reader that classifies each headline by direction and impact.

Every signal carries its timestamp. A stale reading isn't worth the same as a fresh one, and the system knows it: if a source stops updating, it stops voting.

2. Each signal is measured

This is the part almost nobody does. Every signal is scored against what price did afterwards, at five minutes, fifteen, one hour and four hours. Three groups come out of that measurement:

• The ones that get it right: they vote in the reading.
• The ones that are consistently wrong: useful too, inverted. A signal that is wrong 70 % of the time is a 70 % signal, read backwards.
• Noise: most of them. They don't vote. Being a famous indicator earns no voice.

The scoring recalculates itself. A signal that was good and stops being good loses its vote without anyone touching anything.

3. The reading is ranked

Voting signals don't weigh the same. The hierarchy is fixed and runs from what moves money to what merely describes price: institutional flows and stablecoins first, then macro, then the chain, and technical indicators last. The practical consequence: money leaving outweighs an oversold oscillator, always.

Out of this comes a composite reading with three parts: a 0 to 100 score (from capitulation to crash risk), a brain mode from aggressive to defensive that scales the size of everything, and a verdict per asset. The bear-market detector adds one more layer: when it reads distribution at a top, buying slows down and profit-taking gets stricter.

4. The decision becomes orders

The brain doesn't execute. It hands off to the engines, and the engines don't think: each does one thing.

• Grid: a ladder of limit orders around price, buying below, selling above, re-centering the range when the market moves.
• DCA: a base entry plus staggered safety orders when the reading says buy the pullback.
• Harvest: sells what is in the green when the signal says momentum is fading. It never sells in the red.
• Futures hedge: shorts that protect the spot when the reading says risk, always with stop-loss and take-profit registered on the exchange before opening.

Above all of them, an exposure controller allocates capital and caps every engine and every asset: no engine can take the whole account even if its signal is screaming. And each engine keeps its own inventory: it cannot sell what another one bought.

5. The order reaches your exchange

Every entry is a limit order. If price doesn't get there, it doesn't fill, and that's acceptable: missing an entry beats paying the spread on all of them. Nothing closes at market; an exit is done by adjusting the price so it fills.

The order is sent with your API keys to your own Kraken, Binance or OKX account. Trading permission, no withdrawal permission. Before it goes out, it passes a checklist (minimum size, pair precision, real balance, exchange limits) and a circuit breaker that halts sending if the exchange starts answering badly.

6. It comes back and gets reconciled

What actually happened is what the exchange says, not us. Every fill, fee and funding payment is pulled from the exchange's own record and crossed against what the system thought it did. If it doesn't match, the error is ours, and watchdogs raise it: inventory that doesn't match the real balance, orphan orders, a stalled grid, an account buying a lot and selling nothing.

The average cost you see is the one your exchange computes. The result of every sale is measured against that average, fees already deducted.

7. It reaches the panel

The panel doesn't explain the system: it shows it. What you see there comes from the same base we just walked through.

• Activity: every buy and sell, with the engine that made it, price, quantity, fee and result against the exchange average.
• Exposure: how much you hold per coin, what share of capital it is, and whether the inventory is green or red against its average.
• Brain reading: score, mode, fear and greed, real-time signals. The same one served by the public API.
• Futures: the exchange's own book, not a calculation of ours.

What you can verify yourself

Everything on the panel can be checked on your exchange, because it is your account. Open orders, fills, fees, balance. If one day a panel figure doesn't match the exchange, the exchange wins, and that is exactly what we want you to do: look.

What is not published

The exact weight of each signal, engine thresholds, execution routes and any client data. We explain the behavior you can observe; we don't hand out a manual to replicate or attack the system. We don't publish expected returns either: the system is measured by how it works, and that is what the panel shows.

How to follow it

The public real-time reading lives on the signals page, with the API and its plans. To connect an account, start by requesting access. And if you want the doctrine behind every decision, it's in How we operate: signals decide.