---
title: How AI Analyzes Order Flow
slug: how-ai-analyzes-order-flow
cluster: learn
description: What it actually means for an AI system to analyze order flow — the raw feeds it ingests, the deterministic layers computed on top, how causality is enforced, and where the language model does and does not belong.
tldr: An AI order-flow system does not "look at a chart" — it ingests the raw trade tape and order-book updates, computes a stack of deterministic layers from them (delta, footprint, absorption, iceberg replenishment, liquidity clusters, auction state), and only then uses a language model to synthesise and narrate what those layers say. On The Confluence Show that stack is the Confluence Engine, more than forty analytical layers computed in-house, and NAIRO is the analyst that reads them out loud live.
published: 2026-07-31
updated: 2026-07-31
author: The Confluence Show Research
schema: Article
keywords: [AI order flow analysis, AI market analyst, how AI reads order flow, automated order flow analysis, AI trading analyst]
prompts: [How does AI analyze order flow?, Can AI read the order book?, Is an AI order flow analyst better than a chatbot?]
entities: [AI market analyst, order flow analysis, Confluence Engine, NAIRO, market structure, liquidity analysis]
related: [order-flow-trading-explained, cvd-explained, absorption-in-order-flow, ai-market-analysis-explained]
faq:
  - q: Does the AI make the measurements or does a language model?
    a: The measurements are deterministic code — the same arithmetic runs on the same inputs and produces the same numbers every time. A language model is used for synthesis and narration on top of those numbers. Asking a language model to compute delta from raw trades would be both slower and less reliable than a few lines of arithmetic.
  - q: Can an AI system read order flow in real time?
    a: Yes with a caveat about what "real time" means. Trade and depth messages arrive continuously and per-bar layers resolve at each bar close because a bar's delta does not exist before the bar ends. The engine is continuous; several of the readings it produces are inherently bar-resolution.
  - q: How is this different from a trading bot?
    a: A trading bot places orders. An AI market analyst produces analysis and says it out loud. The Confluence Show connects to no accounts holds no client funds and executes nothing — it publishes educational market analysis and issues no signals.
  - q: Why does the system refuse to show a reading sometimes?
    a: Because many layers normalise against the instrument's own trailing history and during warm-up that history does not exist yet. Drawing a bar with no distribution behind it would assert an intensity nobody measured so the reading is simply omitted until the window fills.
  - q: Can I see which layers the analysis is using?
    a: Yes. In the live room the layers are individually toggleable so you can turn on the specific one being discussed and inspect it on the same chart the analyst is drawing on.
sources:
  - label: Binance spot WebSocket market streams (trade and depth feeds)
    url: https://developers.binance.com/docs/binance-spot-api-docs/web-socket-streams
  - label: Binance USDS-M futures WebSocket market streams
    url: https://developers.binance.com/docs/derivatives/usds-margined-futures/websocket-market-streams
draft: false
---

## How does an AI analyze order flow?

By computing it, not by looking at it. An AI order-flow system consumes the same two raw feeds a human order-flow reader would — the trade tape and order-book updates — turns them into a stack of deterministic measurements, and only then applies a language model to synthesise and narrate what those measurements collectively say. The intelligence is in the layer stack and in the synthesis; it is not in a model squinting at a screenshot.

That distinction is the whole subject. Most of what people call "AI market analysis" is a language model reading a chart image or a text summary, which means it is reasoning about a compression of a compression: candles are already a lossy reduction of the tape, and an image of candles is lossier still. A system built for [order flow](/learn/order-flow-trading-explained) has to hold the raw prints, because delta, footprint and absorption cannot be reconstructed from bars at all.

So the pipeline has three distinct stages with three different technologies:

1. **Ingestion** — record every trade and every book update, not a summary of them.
2. **Layers** — deterministic arithmetic that turns those records into named, auditable measurements.
3. **Synthesis and narration** — a language model that reads the layer outputs, weighs them against each other and structure, and states a thesis with its invalidation.

Confusing the three is how you end up with a system that sounds confident and measures nothing.

## What the system actually ingests

Raw trades and raw depth, stored rather than reduced. Each trade carries price, size, timestamp and the maker flag from which the aggressor side is derived; each book update carries the resting size at each price. Positioning data — funding, open interest, basis — arrives alongside as its own stream.

The decision to store trades instead of candles is not a preference, it is a prerequisite. A candle carries open, high, low, close and total volume: five numbers with no aggressor side and no intrabar price distribution. From that you cannot build a [footprint](/learn/footprint-charts-explained), you cannot build delta, and you therefore cannot build [CVD](/learn/cvd-explained), absorption, stacked imbalances or anything that depends on them. Adding the trade feed later is not a patch; it changes what the system is.

The same argument applies to depth. Replenishment — how much size was refilled at a price while it was being executed — is the measurement that separates a real defence from size that was simply eaten once. It requires a sequence of book snapshots, not a single one, and it is the basis for inferring hidden liquidity that never displayed in full.

Both spot and perpetual tapes are recorded for the same asset, with one shared aggressor convention applied to both. Inverting the convention on one feed would produce a permanent phantom disagreement between spot and perpetual flow that looks exactly like signal.

## The layer stack: what actually gets computed

More than forty analytical layers, all computed in-house from those feeds, grouped into families that answer different questions. None of them are model outputs — they are arithmetic with documented parameters, which is what makes them auditable.

| Family | Representative layers | Question answered |
| --- | --- | --- |
| Aggression and delta | CVD and delta panel, delta divergences, delta exhaustion, delta rotation, aggression effect | Who is crossing the spread and what are they getting for it |
| Per-bar flow | Footprint, detailed footprint, stacked imbalances, failed imbalances, conflict zones | Where inside the bar volume traded and on which side |
| Passive side | Absorption, absorption exhaustion, iceberg and replenishment, trapped passive, defensive adds, queue depletion | Who is defending a price and whether the defence is funded |
| Resting liquidity | Liquidity heatmap, heatmap clusters, book walls, DOM ladder, liquidity pools, book reliability | Where size is resting and how reliable that display is |
| Structure and value | Dealing range, auction state, volume profile nodes, developing POC and value area, POC migration | What kind of auction this is and where value sits |
| Positioning | Funding and open interest, open-interest profile, basis, spot-versus-perpetual divergence, liquidation cascades | How the derivative crowd is positioned relative to spot |

The families are deliberately overlapping. Absorption is gated on delta; delta comes from the footprint; the footprint comes from the tape. That chain means a single upstream mistake propagates visibly rather than silently, which is a property you want.

## Why every reading carries the moment it became knowable

Because a layer that is drawn on the bar that created it, using information that only existed later, is a chart lying about its own history. Every reading the engine emits carries two timestamps: the bar it is *anchored* to for drawing, and the moment it became *knowable* from data that had actually arrived.

The distinction is not cosmetic. A bar's delta does not exist until the bar closes, so a CVD point is anchored at the bar's open time but knowable only at its close. A swing pivot is not a pivot until enough later bars have closed to confirm it, so a [CVD](/learn/cvd-explained) divergence built from two pivots is knowable at the confirming bar, never at the pivot. An absorption level's strength is only knowable test by test, as each test seals.

Systems that skip this produce backtests and highlight reels that cannot be reproduced live, because the marks were placed with information the market had not published yet. Enforcing the second timestamp everywhere is unglamorous and it is the difference between analysis you can audit and analysis that flatters itself. It is also what makes "state the invalidation in advance" a mechanical property of the system rather than a stylistic promise.

## Normalisation: why thresholds are per-instrument percentiles

Because "large" has no absolute meaning across instruments, and a fixed threshold is a hidden assumption about which asset you are on. Nearly every intensity reading in the stack is normalised as a percentile against the *same instrument's own trailing window*, excluding the observation being judged.

Two consequences follow, both of which show up in the interface. First, thresholds move with the market: what counted as an extreme delta in a quiet session does not count as one during expansion, without anyone retuning a setting. Second, during warm-up — before the trailing window has enough history — there is no distribution to rank against, so the reading is **not drawn at all**. An omitted bar is honest; a bar drawn from an empty sample asserts an intensity nobody measured.

The same discipline applies to how confidence is expressed. The engine's trend gauge, for example, is built from Bayesian arithmetic over several moving-average families, and it is documented internally as a *gauge*, not a calibrated probability — the number orders states, it does not promise frequencies. Treating a smoothed score as a probability is one of the easiest and most damaging things to get wrong in a quantitative stack, and the fix is to label it accurately rather than to dress it up.

## From layers to a thesis: what confluence means here

Confluence means independent layers pointing at the same price for different reasons. One layer flagging a level is an observation; several unrelated families agreeing at that level — resting liquidity, a value-area edge, a defended absorption level, a positioning extreme — is a thesis worth stating. The synthesis stage is where that weighing happens.

This is the stage where a language model genuinely earns its place, and only this stage. The model does not compute delta or detect icebergs; it receives named, timestamped layer outputs and does what models are actually good at — reconciling many partial descriptions into one account, in language, in real time, and updating it as new bars close. It also does the part no dashboard does: saying what it currently believes, why, and what would prove it wrong.

The output is a spoken analysis with a stated invalidation, not an instruction. When the invalidation trips, it is said out loud on air. That posture — [we do not predict, we keep score](/nairo) — is what the layer stack is built to support: you cannot honestly keep score unless every reading was timestamped as knowable when it was made.

## Is this different from asking a general chatbot?

Yes, categorically, and the difference is data access rather than model quality. A general-purpose chatbot has no trade tape and no order book. Given a chart image or a text summary it is reasoning about a lossy reduction of a lossy reduction, and it cannot compute delta, footprint or replenishment from what it was handed — no matter how capable the underlying model is.

There is also a live-versus-static distinction. Order flow is a description of the auction *now*; a conversation about a screenshot describes the auction at the moment the screenshot was taken. A system that ingests continuously and re-resolves its layers at every bar close is doing something structurally different from a question-and-answer session.

None of that makes the general model bad at what it is for. It makes it the wrong tool for this specific job, in the same way a spreadsheet is the wrong tool for streaming depth updates. The comparison is examined in more detail in [ChatGPT versus a dedicated AI market analyst](/compare/chatgpt-vs-a-dedicated-ai-market-analyst) and across the category in [best AI tools for order-flow analysis](/compare/best-ai-tools-for-order-flow-analysis).

## What an AI order-flow analyst cannot do

It cannot see hidden liquidity directly, cannot know why anyone traded, cannot make a single venue into the whole market, and cannot turn a description of the present into a forecast. Those limits belong to the data, not to the model, and no amount of compute removes them.

Nor should it try to do the things it is not for. The Confluence Show is not a broker, exchange, fund or adviser: it connects to no accounts, holds no client funds and executes nothing. It publishes educational market analysis and issues no signals of any kind. What it does is read raw trades, order books and positioning 24 hours a day through the Confluence Engine, draw its thesis directly on a live chart, speak it, state the invalidation in advance, and stay on the record when it is wrong.

If you want to judge that on the output rather than the description, the same show streams free on a twenty-minute delay on YouTube, Twitch and Kick — [watch it](/watch) — and the live room runs on a per-asset subscription starting at $149/month with a seven-day free trial. [How it works](/how-it-works) documents the engine, and [markets](/markets) lists what is currently covered.