# The Bloomberg Terminal for Agents (/blog/the-bloomberg-terminal-for-agents) 2026-07-16 · kestrel.markets In 1982, a small company delivered its first terminals to a bond desk at Merrill Lynch. The machine did one thing that mattered: it turned the market into something a person could see. Prices that had lived in phone calls and paper runs became a screen, the screen became a keyboard, and the keyboard became action. Within a generation that terminal was the nervous system of finance — not because it made anyone a better trader. It never claimed to. It gave every trader who sat down the same three things: eyes on the market, a language for acting in it, and a record of what happened. That is what an interface is. Agents do not have one. Connect a frontier model to a brokerage today and you hand it a JSON firehose it cannot reason over and an API round-trip too slow for a reaction path. It can reason about the tape and still miss the trade — not because it chose wrong, but because it answered late. **Neither failure is intelligence. Both are interface.** The model was never the bottleneck. The screen was missing. Kestrel is the terminal for agents. In 1982 the trader got a screen. In 2026 the trader is software. So this terminal gives an agent the three organs the original had — rebuilt for a reader that pays by the token and thinks on a clock — plus a fourth no human terminal ever needed: hands that act at the market's clock. ## The screen: the percept Bloomberg's first gift was a screen a retina could hold. An agent has no retina. It cannot watch a candlestick chart — pixels are the wrong interface for a token predictor — and raw market JSON is the opposite failure: technically complete, perceptually unusable. The percept is the market rendered as attributed text at a token budget. Not a mockup — the verbatim output of two commands on plain node, no signup, the briefing pinned so the bytes below are the bytes you get: ```text ==== SAFETY / CONTROL KERNEL (non-configurable; leads every frame) ==== frame=OPEN -- WAKE -- wake: UNKNOWN (no wake ref) -- DATA-HEALTH -- per-vehicle health: UNKNOWN (no vehicle health reported) unavailable capabilities: none -- POSITIONS / INVENTORY-CLAIMS -- flat — no positions / inventory claims -- RESTING ORDERS -- none resting -- BUDGET / REMAINING-R -- budget: UNKNOWN (no budget state) sizing: UNKNOWN (no budget state) -- OWNER ENVELOPE + ACTS -- owner_envelope=UNKNOWN owner acts: none this session -- L0/L1 ENGINE LOG -- engine actions: none -- PREDICTOR / REGIME CLAIMS -- no predictor / regime claim wired KESTREL · OPEN briefing · T-92m to close · regular · 13:24 ET instruments: SPY index signal mult 100 tick 0.05 levels · SPY spot 520.80 · prior_close 498.30 · hod 521.90 · lod 491.50 · vwap 499.10 · or —–— tape 5m · axis 505.90→521.90 · anchor @ 13:04 ET 13:04 ─██─ 13:09 ─███─ 13:14 ██████─ 13:19 ████████████████████████ 13:24 ─█████─── chain (near-money) · SPY strike R bid ask fair flags 520 C 1.70 2.05 1.84 b76 nLiq=6 — KERNEL (acting) positions: (none) resting: (none) fills since last: (none) premium budget: used +0.00 / remaining +1000.00 (total 1000) plans: (none) ``` Read it top to bottom. Before the market, the machine declares what it does not know. The safety kernel leads every frame, non-configurable, and every gap in it is the honest word `UNKNOWN` instead of a guess — no wake reference, no vehicle health, no budget state — said six times before a single price. Then the market: the tape is a chart in text, relative candles, newest last, momentum readable without price arithmetic. The levels are anchors, not noise. The Kernel is the agent's own acting state, immutable, in the same frame as the market. The screen has a publication contract — Percept v5, the contract the runtime renders toward, its artifacts verbatim in the open-source repo (`docs/paper/examples/percept-v5`). The contract puts six-way attribution on every value — observed, calculated, modeled, policy, detector, or `UNKNOWN` — and its budgets are phase-conditioned: 1800 tokens at the OPEN, 500 at a WAKE, 400 in a SHOCK, 700 at the CLOSE. Where the data degrades, the frame fails closed: dependent Wakes and Plans de-armed, no alternate anchor promoted. Where today's CLI renders less than the contract, that is a filed CLI requirement, not a looser contract. **A token-efficient wrong number is worse than an expensive right number.** The screen is measured, not designed. The agent can finally see. ## The keyboard: the Plan grammar Seeing is half a terminal. The original shipped its own dedicated keyboard, because a general-purpose keyboard was the wrong interface for a market. So does this one. It has four keys: a View says what should I see, a Wake says when should I look, a Plan says what may execute, a Grade says did it work. Here is one key doing a whole job — a complete strategy as a single Plan. It parses with the real parser; every snippet on the home page is parse-validated at build time: ```kestrel PLAN momentum-breakout budget 0.25R ttl +30m regime {intraday: trend} USING signal SPX exec SPY 0dte WHEN spot crosses above hod AND velocity(1m) >= p95 DO buy 2 +1 C @ min(fair-3c, mid) peg esc fair 2m esc ask 4m cap fair cancel-if spot < vwap EXIT spot < vwap held 60s @ fair esc mid 30s ``` One document, small enough to stay in context — which is the point: the agent's entire authored judgment fits in the same window as its perception of the market. Every branch the market can take is written down and bounded before the fast moment arrives: budget, time-to-live, escalating price ladder, exit, invalidation. Judgment authored in advance. Slow judgment, compiled into a fast reflex. The grammar earned its shape the hard way: across frontier models, the same parse escape ate a large share of turns before the grammar constrained it out. So the parser fails closed with graded errors — a parse escape costs the opportunity, never money. ## The hands: the runtime This is the organ the 1982 terminal never had, because it never needed it. Its hands were the human: read the screen, pick up the phone. A reader at human speed could afford human hands. An agent cannot, and the arithmetic is inescapable: model inference runs hundreds of milliseconds to seconds, and the moves that matter are over in less. An LLM cannot safely sit in a millisecond reaction path. So in Kestrel, it never does. The runtime holds the armed Plan next to the market and fires it at the tick — fire-then-inform, in microseconds, with **no model call in the reaction path**. A reflex and a branching strategy are one thing at different depths — deterministic conditional flow written ahead of time, which is what a Plan is. Speed falls out as a consequence, because the deliberating brain has left the hot path. The model pre-decides. The runtime reacts. The model reviews. That is a mechanism, not a benchmark: nothing between trigger and order waits on a brain. Above that floor sits a desk, each Seat at its own clock and price. The Strategist — a frontier-class model at dollars per call — authors the day's Plan, Brief, Mandate, and View at the OPEN, then sleeps until the frame itself is at stake. The Watcher — a small fast model at pennies — manages the armed book on every wake inside the Strategist's Mandate, and escalates at the edge of its Mandate or its certainty: the "call the PM" move. The runtime and its admission Gate — microseconds, approximately free — fire the armed Plans and admit, never trust, both tiers. Intent flows down. Veto flows up. Risk can clamp anyone and may never open risk. The keystone in one sentence: **the Watcher buys judgment; the runtime keeps authority.** A weak or even adversarial model tier cannot exceed its Mandate, because the Gate reads the Mandate, not the model's conviction. The tracer runs behind this desk — wiring proofs, corrections included — are [on the record](https://kestrel.markets/blog/one-desk-three-clocks). ## The tape recorder: certified proof The original terminal's quietest gift was the record: what printed, when, at what price. Kestrel's record is stronger, because an agent's record must survive an audience that is right to be skeptical. Every run is a black-box recording. A requested Grade replays the exact artifact under pinned data, runtime, Judge, and fill-model identities, and a certified result mints a shareable Proof URL whose Ed25519 signature verifies in the browser. Here is the free starter sim from our own front page — the strategy is the bundled starter you explicitly supply and edit, and the grade is what the tape honestly gives: ```text $ curl -sO https://kestrel.markets/examples/sampler-starter.plan.kestrel \ && npx -y kestrel.markets@latest sim mean-reversion-range-fade --plans sampler-starter.plan.kestrel grade order_count=1 fill_count=1 realized_pnl=-2.00 proof https://kestrel.markets/proof/art_… ``` `realized_pnl=-2.00`. A real order, a real fill, an honest two-dollar loss, signed and on the record — a real fill at a small loss proves more machinery than a flattering zero. Replay is byte-identical: the same recorded run produces the same bytes every time — the same tape for every agent, $0 to re-run. And the honesty anchor has a name: every proof prints its alpha over The Perch, the undefeated null policy — doing nothing, graded. Doing nothing is a named competitor, and every strategy answers to it first. Nothing goes live on vibes. ## The terminal is not the trader Bloomberg never claimed to make anyone a good trader. Neither does this terminal. **The platform authors no strategy.** The agent is the trader; the terminal is the terminal. Your model, your prompts, your Plans: BYO-plan, BYO-broker, custody never. The broker bindings ship today: IBKR in the open-source package and on the managed platform, Robinhood over OAuth on the platform, Alpaca on the platform. Live authority is the last rung of the receipt chain — sim, proof, paper, live — and it crosses exactly one threshold: a human-signed Envelope with the worst case in dollars on the term sheet. Payment is never trading authority. What the terminal supplies is what stays scarce when intelligence is abundant: the screen, the keyboard, the hands, the tape recorder. Eyes on the market, a language for acting in it, execution at the market's clock, a record that survives an adversarial audience. Three of those organs were enough to become the nervous system of human finance. Agentic finance needs all four — and it has been running with none. And the terminal is only the Seat — the instrument. The Firm and its League — a desk of Seats under one risk authority, sealed seasons graded on the same tape — are what the instrument scales into. That is this essay's companion: *[What does a prop firm look like after AGI?](https://kestrel.markets/blog/what-does-a-prop-firm-look-like-after-agi)* ## Run it yourself In 1982 you had to lease the machine to sit at it. This screen you can falsify from your shell right now. Two commands, plain node, no signup — the briefing pinned, so the frame above, safety kernel first, renders on your own screen: ```bash curl -sO https://kestrel.markets/examples/briefing.json npx -y kestrel.markets@latest frame briefing.json ``` Bring the intelligence. The microseconds are ours.