Deterministic vs AI Signals: Why Robots Can't Read Charts

The Seductive Idea

The pitch sounds compelling: feed a chart to an AI model, ask it "should I buy or sell," and get a probability-weighted answer backed by pattern recognition across thousands of training examples.

This is appealing because the task is hard — reading a chart, identifying regime, assessing pattern quality, gauging volume conviction — and AI seems like it should handle complexity better than humans.

Here's the problem: AI language models are not deterministic. They're probabilistic. That means the same input can produce different outputs across repeated calls. And in trading, where "above the neckline" and "below the neckline" are separated by a fraction of a percent, non-determinism isn't a quirk — it's a fatal flaw.

What Non-Determinism Actually Means

A deterministic system is one where the same input always produces the same output. Your Python script that calculates price > EMA_20 is deterministic. Run it 1,000 times with the same data: 1,000 identical results.

A probabilistic system produces outputs sampled from a probability distribution. The same input, across repeated calls, can produce meaningfully different outputs depending on sampling temperature, model version, context window state, and other variables.

LLMs are probabilistic systems. This is not a bug — it's an architectural choice that makes them creative, flexible, and capable of producing diverse text. It also makes them unreliable for tasks that require consistent, reproducible outputs.

The A/B Test That Ended the Debate

The question of whether AI could reliably generate trading signals was tested directly with three Gemini model variants on the same chart.

The setup: a BTC 4-hour chart from a real trading session. Same chart image. Same prompt. Three models: Gemini 1.5 Flash, Gemini 1.5 Pro, and Gemini 2.0 Flash.

Results:

• Model A: "Bearish. The recent candle structure shows lower highs and the neckline is breaking down. Estimated price at resistance: $43,250."
• Model B: "Neutral to bullish. The pullback is finding support at the key level. Recent consolidation suggests buyers are accumulating. Estimated resistance: $44,100."
• Model C: "Bullish with caution. The pattern resembles an inverse head and shoulders neckline test. Price is at $43,750 and holding above the critical level."

Three models. Same chart. Three different directional calls. Price readings differing by up to 850 points — 0.5-1.5% variance at the time. For a spot trade, that's noise. For an options trade where the strike price precision matters, that's the difference between profitable and worthless.

What AI Is Actually Good At (And Where It Belongs)

The conclusion isn't "never use AI." The conclusion is "use it for the right tasks."

AI excels at:

• Research synthesis: Summarizing the characteristics of a pattern across hundreds of sources, including exceptions and failure conditions
• Rule extraction assistance: Processing large volumes of text or transcripts to identify recurring concepts (with fabrication audit afterward)
• Scenario analysis: "Given these market conditions, what are the historical failure modes of this setup?" — asking for patterns in knowledge, not real-time decisions
• Educational content: Explaining concepts, building mental models, teaching framework
• Post-trade analysis: "Here's what happened on this trade. What might I have missed?" — retrospective pattern identification

AI fails at:

• Real-time execution decisions that require consistent output
• Precise price level identification from image inputs
• Regime classification when directional bias matters for P&L
• Any task where the same input must produce the same output every time
• Tasks where 0.5% variance is the difference between a winner and a loser

The line is this: use AI where creative synthesis, knowledge distillation, and flexible reasoning add value. Use code where consistency, precision, and repeatability are required.

The Deterministic Alternative

Everything you want AI to do in real-time execution, you can do deterministically with code:

Regime detection: if price > ema_20 and ema_20 > ema_50: regime = "bullish"

This runs identically every time. No variance. No creative interpretation. The result is always the same for the same input data.

Pattern qualification:

neckline_break = candle_close > neckline_level
volume_confirm = current_volume > avg_volume * 1.3
regime_clear = regime in ["bullish", "neutral"]
entry_signal = neckline_break and volume_confirm and regime_clear

Every condition is binary. The system fires or it doesn't. When it fires, you know exactly why. When it doesn't, you know exactly why not.

This is the architecture behind the Foresight signal engine that powers jeremyknox.ai's live trading. The 11-factor conviction scoring model is fully deterministic Python — every factor is a calculation, not a judgment. Same market conditions produce the same signal score, every time.

The Practical Framework: When to Use Which

Use AI for:

• Session start research ("summarize recent market conditions for BTC")
• Post-session review ("analyze this trade log for patterns")
• Learning and concept building
• Generating the first draft of your rule document (followed by fabrication audit)
• Any task where synthesis and creativity add value over precision

Use deterministic code for:

• Real-time signal generation
• Entry/exit rule evaluation
• Position sizing calculation
• Regime classification
• Any task where you need the same answer every time with the same inputs

The transition point: Once you understand a concept well enough to write code that implements it, that concept moves from the AI column to the code column. The AI was useful to help you build understanding. The code is what actually trades.

Building the Right Mental Model

AI is a research team. Code is the execution desk. Research teams generate insight, analyze scenarios, and build understanding. Execution desks make consistent, repeatable decisions under pressure. You need both. They do different things. Confusing the roles is how you end up with a system that's intelligent in discussion but unreliable in practice.

This distinction matters most as AI tools become more sophisticated and more accessible. The temptation to hand execution decisions to increasingly capable models will grow. The math of non-determinism doesn't improve with capability — a more creative model is still a probabilistic model. The variance in its outputs is still incompatible with requiring consistent results.

Build AI into your research process. Build code into your execution process. The line between them is the line between insight and edge.