Answer card
The two failures of LLM trading are interface (perception and latency), not intelligence. A frontier model reasons about markets fine; it drowns when you feed it raw JSON or a chart screenshot, and it loses when you put it in the millisecond hot path. Fix the interface: render the market as compact text a context window can hold, and let a bounded, contingent program fire in milliseconds while the agent decides in parallel. That is the Interface Thesis.
The claim everyone must say first
Before you argue about whether an LLM can trade, say the sentence: the two failures of LLM trading are interface (perception and latency), not intelligence. Almost every public "LLM trades badly" demo conflates all three. It hands a model a screenshot or a wall of order-book JSON, asks it to act inside a loop that ticks faster than the model can emit a token, and then concludes the model is not smart enough. The intelligence was never the bottleneck. The interface was.
This matters because the two real failures have engineering fixes, and "not smart enough" does not. If perception and latency are the problem, you build a perception layer and a latency layer. That is what Kestrel, the open-source language and runtime for agentic trading, is: not a smarter model, a better interface to the market for the model you already have.
Failure one: perception. The chart is in text.
A price chart is a picture optimized for a human retina. A screenshot of one is a catastrophe for a language model: thousands of tokens of pixels, no numbers it can compute on, re-encoded in full every time one candle prints. Raw market JSON is the opposite failure: technically complete, perceptually unusable, a swamp of absolute prices and nested fields where the model spends its budget reconstructing "is this up or down" instead of reasoning about it. A quote is not a value, and a screenshot is not a chart.
Kestrel's answer is the VIEW statement, and the principle is blunt: the chart is in text. A VIEW renders the market as a compact text Frame: a chart-in-text sized for a context window. It is a vertical, append-only tape: one row per candle, newest last. Candles are relative, expressed in basis points versus the prior close, so the model reads momentum directly instead of subtracting six-figure prices in its head. Periodic keyframes anchor absolute level so nothing drifts.
The property that makes this work at machine speed is cost. Perception is O(new bars), not O(screen): when a new candle prints, you append one row, and the whole prior Frame stays byte-identical and KV-cache-friendly, so the model re-reads almost nothing. A screenshot is O(screen) every tick. A tape is O(new bars). That difference is the whole ballgame for a model paying by the token and thinking on a clock.
VIEW tape budget 1200
price SPY 1m relative keyframe 30m
vwap SPY 1m
velocity SPY 5mYou spend a token budget, you get back a Frame a model can actually read. That is perception treated as an interface problem, which is what it is.
Failure two: latency. The agent is never in the hot path.
Even with perfect perception, an LLM cannot sit in the hot path. Round-trip inference is hundreds of milliseconds to seconds; a market move that matters is over in tens of milliseconds. Ask the model to be the trigger and you have already lost: not because it chose wrong, but because it answered late. This is the failure people most often misread as stupidity. It is arithmetic.
Kestrel splits the decision from the reaction. The agent's judgment is compiled ahead of time into a PLAN: a standing, bounded-risk contingent program (trigger, then actions, bracket, invalidation, and a TTL). The runtime holds the armed Plan next to the market and fires it in milliseconds when the trigger hits. Then, in parallel, it wakes the agent to inform it of what just happened. This is fire-then-inform, and its invariant is absolute: the agent is never in the hot path. The model pre-decides; the runtime reacts; the model reviews. Nobody waits on an LLM to execute.
PLAN headline-chase budget 0.25R ttl 15:55 regime {intraday: trend}
USING signal SPX exec SPY 0dte
WHEN spot > HOD AND velocity(5m) >= p95
DO buy 2 +1 C @ min(fair, mid) peg cap fair
TP 2.5x frac 0.5 @ fair
EXIT spot < VWAP held 120s @ fair
INVALIDATE spot < VWAPThis is illustrative: a generic 0dte template on SPX/SPY, not a strategy recommendation. The point is structural: every branch the market can take is already written down and bounded before the fast moment arrives. The agent authored the judgment; the runtime owns the reflex.
Attention gets the same treatment. A WAKE is a standing subscription over a trigger algebra (event-driven, not polling) that spends attention (tokens, wakes), never risk. The agent sleeps until something it cares about happens, then reads a Frame. It does not sit and stare at a screen it re-encodes every tick.
WAKE breakout
WHEN spot > HOD AND velocity(5m) >= p95
DELIVER tape
BUDGET 40 wakes/dayThe fourth piece: grade, so the honesty is verifiable
Perception and latency get the agent into the market safely. The last statement kind keeps it honest. A GRADE is the counterfactual result of a run, and because a Grade is never flattering when it is done right, grading is contamination-fenced. LLM authors are graded only on post-training-cutoff, date-blinded days, because weights leak what code fences can't stop: a model that saw a date in training can "predict" it. Grade judges judgment, not parameters, with explicit counterfactuals in the syntax.
GRADE plan headline-chase OVER 2026-04..2026-06 FILL conservative
VS null
BY regimeVS null and VS ungated are the honest questions: did the judgment beat doing nothing, and did the regime gate beat running the same plan with the gate removed? Names are data; dates are data; a Grade that ignores that is a flattering fiction.
So: is this the right frame for everyone? No.
Honesty is part of the thesis, so here is where it does not apply. If your strategy lives entirely below the millisecond floor (pure latency-arbitrage, market-making at the top of the book), you do not have an interface problem, you have a colocation problem, and no language model belongs anywhere near it. If your edge is a numerical model that never needs to read a market picture or explain itself, the perception layer is overhead you do not need. The Interface Thesis is a claim about agentic trading, where a general reasoner's judgment is the asset and the only things standing between it and the market are perception and latency. That is a large and growing space. It is not all of trading.
Where this is today
Kestrel the language and runtime is the open substrate for View/Wake/Plan/Grade. The commercial platform, kestrel.markets, hosts what stays scarce when intelligence is abundant (capital and trading authority, licensed data, latency and broker access, deterministic execution, provenance) while brains stay outside. As of mid-2026: anonymous trial sims, certified Grades, shareable proof URLs, and 402 Offers with Stripe settlement are live; always-on paper presence and the human-signed live path are in build. The free tier needs no signup. The four-statement model and the perception and latency arguments are the stable core, and they are what you can reason about now. We would rather tell you that than imply a finished product.
The category conversation keeps stalling on the wrong noun. It is not about a smarter trader. It is about a usable interface to the market for the reasoners we already have.
Fix the interface and the intelligence was there all along.
The two failures of LLM trading are interface (perception and latency), not intelligence.