Block-level speed. One token out. Zero benchmarks. OpenAI shipped a "Decisions API" this week — an endpoint that locks a language model into picking one answer from a fixed menu instead of generating free text. The announcement carried four data points and no product documentation. No latency figure. No pricing page. No accuracy table. Just the phrase "fast, constrained AI choices" and a link.
That's the entire release. And the crypto-agent economy — the routing layers, the intent solvers, the autonomous vaults, the DAO executors — is already salivating over it. Builders want a cheap, fast, reliable "decide" primitive. They're about to get one. They're also about to inherit whatever biases and failure modes are baked into a schema they can't see.
I've spent twenty-nine years watching this pattern repeat. In 2017 I scraped token-sale contracts and found a front-running flaw in a DEX's order-matching logic before any outlet had a headline. In 2020 I decoded Aave's emergency upgrade parameters hours before the official announcement. Speed-first, primary-source, no narrative. This is the same game with a new primitive. Let me decode it.
Context
Here's what "constrained" actually means, stripped of marketing.
Constrained decoding is old. Very old by AI standards. You take a language model and, at each token step, you mask the logits — the raw probability scores — so the model can only emit tokens that keep the output inside a legal grammar. JSON. A regex. An enum. A finite state machine. The academic foundations go back years, and the open-source tooling is mature and free: Outlines, Guidance, LMQL, Instructor, BAML, XGrammar, llguidance. All of them do grammar-constrained, schema-constrained, FSM-constrained generation today, and you can self-host every one.
OpenAI already shipped structured outputs and JSON mode. Anthropic has tool use. Google has controlled generation. Meta ships open weights the community constrains for free. So a "Decisions API" is not a new capability. It's a repackaging of an existing one — wrapped for a specific job: pick one option from N.
That reframing matters more than the launch. The unit of value shifts from the token to the decision. A call that returns one class label out of five doesn't cost what a paragraph of prose costs. Its value isn't measured in tokens; it's measured in whether the pick was correct. That is a different economic animal, and it's the whole point.
Why now? Because the agent boom needs it. Every autonomous system — on-chain or off — spends most of its compute on routing, classification, and gating. Which tool do I call? Which pool do I route to? Is this transaction safe? Is this address sanctioned? Is this proposal malicious? Those are discrete choices, not essays. They're high-frequency, low-value-density, and latency-critical. Free-form generation is the wrong tool. A constrained picker is the right one.
The timing is defensive as much as offensive. When Outlines and Instructor give you the same capability for free and self-hosted, a closed vendor has to productize and simplify or lose the API revenue to builders who just wire it up themselves. The Decisions API is a moat-repair job disguised as a feature launch.
Core
Let me get technical, because the marketing won't.
"Fast" is not magic. It's a stack of known engineering tricks. Small parameter models. Speculative sampling — draft with a tiny model, verify with a big one. Prefix caching, so repeated system prompts skip recomputation. KV-cache optimization. Continuous batching, so requests pipeline instead of queueing. And the biggest lever of all: output only a handful of tokens. A decision that emits one token is orders of magnitude cheaper than a generation that emits five hundred. None of this is a new model. It's a latency-and-cost packaging problem. On the innovation ladder, this sits at "engineering" and "combination" — not "architecture."
That distinction isn't academic. It tells you where the differentiation can and cannot live. It cannot live in model capability — everyone has the same base models. It can only live in latency, cost, and reliability. Those are engineering metrics. Engineering metrics are catchable. That's the first crack in the story.
Here's the mechanical picture. A constrained decoder walks the grammar token by token. At each step it computes the full logit vector, then zeroes out every token that would break the current legal state. Only the surviving tokens get sampled. For a decision task, the grammar is tiny — often a single enum — so the valid token set collapses fast and the model emits one or two tokens and stops. That's why the compute profile looks nothing like a chat completion. There's no long decode loop. There's a mask, a pick, and a return.
Which is exactly why the economics are interesting. Decision tasks are compute-light and latency-sensitive, the inverse of training workloads. They barely move GPU demand. They do move routing architecture. And they're cacheable — the same input should yield the same decision, so you can memoize aggressively and drive marginal cost toward zero. Any vendor that doesn't exploit that caching is leaving money on the table, and any vendor that does exploit it has a cost structure that looks like a CDN, not a data center.
Now bridge it to chain.
The on-chain equivalent of "constrained decoding" has existed since the first oracle. A smart contract can't emit free text either — it executes a fixed opcode set against fixed state. Everything on-chain is already a constrained decision. The chain is the ultimate FSM: deterministic, bounded, no hallucination possible because there's no room for one. What's new is putting a language model in the loop before the chain — letting an AI make the discrete call that determines which contract path executes.
That's the actual product-market fit nobody is naming. Intent-based DeFi. Solvers that decide which of forty routes fills a swap. Vaults that decide when to rebalance. Governance executors that decide whether a proposal is safe to queue. Liquidators that decide which position to hit first. Restaking operators that decide which AVS to serve. Bridges that decide which message to relay. Each of those is a "pick from a menu" problem. Each is exactly what a Decisions API claims to solve, fast and cheap.
And here's where my blood runs cold, and where the bull-market euphoria is masking a structural flaw.
In a bull market, nobody audits the router. They audit the yield. When APYs are 400% and green candles stack, the routing decision is invisible — it just works, or it doesn't, and if it doesn't you blame the market. This is the same blindness I watched in April 2021, when I ignored the Bored Ape "green flame" and stress-tested Yuga's marketplace liquidity instead. I ran high-frequency trades to map the slippage mechanics, found an oracle-pricing arbitrage the market hadn't priced, and published the mechanical flaw with gas-cost math while everyone else was posting JPEGs. The lesson held: the hype is always in the asset; the risk is always in the machinery. A Decisions API is machinery. It will be trusted precisely because it's boring, and it will be exploited precisely because it's trusted.
Let me make the economics concrete, because this is the part the announcement buried.
If OpenAI prices per decision rather than per token, it opens a new billing paradigm — and a new subsidy game. Here's the analogy that should make every DeFi native wince. Liquidity mining APY is not yield; it's the protocol paying for TVL numbers. Stop the incentives and the "users" evaporate. A per-decision price does the same thing at the infrastructure layer. If decisions are priced cheap enough — or free up to a tier — builders will flood in, wire their agents to the endpoint, and inflate "adoption" metrics. The moment the price normalizes, the marginal agents that only existed because the decision was subsidized will vanish. You can manufacture adoption with a price floor just as easily as you can manufacture TVL with a token emission. Watch for a free tier. Watch for the day it disappears.
The pricing ambiguity is itself the signal. The announcement says impact "depends on cost and accuracy." Read that twice. A vendor that had the numbers would print them. Saying the value depends on two metrics you didn't publish is a hedge, not a claim. It's the same tell as a project that announces a partnership without naming the partner. No latency percentiles. No throughput. No comparison to the standard chat endpoint. When a launch is four sentences long, the missing sentences are the story.
Now the failure modes, because constrained output is sold as a safety feature and it isn't purely one.
Constraining output does kill hallucination — mechanically. If the model can only emit one of five labels, it cannot invent a sixth. That's real. Hallucination risk drops from high to low. Good.
But the risk doesn't disappear. It migrates. When you lock a decision into a finite option set, you convert a diffuse hallucination risk into a concentrated, high-frequency bias risk. A classifier that systematically mislabels a dialect, a demographic, a region — or on-chain, a wallet cluster, a jurisdiction, a protocol pattern — will repeat that error at machine speed, across every call, forever. One biased schema, replicated across ten thousand agents, is a systematic error with systemic blast radius. Free-form text fails loudly and locally. Constrained decisions fail quietly and globally.
And on-chain, "quietly and globally" has a name: it's an exploit waiting for a trigger. If a routing agent has a blind spot in its decision schema, an adversary doesn't need to hack it. They just need to present the input that lands in the blind spot, repeatedly, until the aggregate misrouting becomes extractable MEV. You don't break the decoder. You feed it the one input it always mishandles. That's a prompt-injection attack that never touches a prompt — it's an injection into the decision boundary itself.
Which brings me to the real power question — and the one angle the announcement, and every breathless thread about it, completely missed.
The model isn't the moat. The constraint set is. Whoever defines the schema — the legal options, the grammar, the enum — owns the decision space. The model is a commodity. The menu is the asset. And a menu is a governance artifact: it's written by someone, versioned by someone, and changed by someone, usually through a process no user can see.
If that sounds familiar, it should.
Governance isn't a vote. It's whoever holds the constraint set.
Governance isn't consensus. It's a merge window nobody watched.
Governance isn't a meeting; it's a race condition, and the fast side wins.
This is the exact structure of DAO governance I've been screaming about since DeFi Summer. "Code is law" is a slogan, not a mechanism, because the upgrade key always sits with a handful of multi-sig admins. The same is true of a Decisions API. The "law" — the set of legal outputs — is enforced by code. But the code is edited by an admin. The constrained decoder is just a multi-sig with better marketing. You don't get determinism from constraint. You get determinism from whoever controls the constraint. Change the schema, and every downstream agent silently changes its behavior on the next call. No fork. No vote. No announcement.
That's the blind spot. The entire agent narrative is built on the fantasy of autonomous, trustless decision-making. A Decisions API doesn't deliver that. It delivers fast, cheap, delegated decision-making — delegated to whoever wrote the enum. And in crypto, where the whole point was supposed to be removing the trusted third party, we're about to insert one at the routing layer and call it infrastructure.
Now the compute and infrastructure reality, because it matters for who profits. This workload is the opposite of training. Training is a capital-intensive, GPU-maxing, months-long grind. Decision inference is a low-density, latency-sensitive, cacheable workload that runs on modest silicon and scales with request volume, not model size. If the "fast" claim comes from a distilled small model — and it almost certainly does — then OpenAI is deploying dedicated inference clusters, not frontier training runs. The carbon footprint per decision is trivial. The GPU demand pull is marginal. The whole economic engine is batch efficiency: can you pipeline ten thousand tiny decisions cheaply enough that the per-decision price clears the per-decision cost? That's the only number that matters, and it's the one number nobody published.
There's a payments angle here too, and it's the one most analysts will miss. Agents that make decisions need to settle them, and settlement increasingly happens in stablecoins. In inflationary economies, the driver was never blockchain ideology — it was local currency collapse forcing people to find survival rails. Now add machine agents making per-decision micropayments on those same rails. A cheap decision primitive plus cheap stablecoin settlement equals an autonomous economic loop that runs at machine speed. That's the real long-term market. It's also the real long-term attack surface, because an agent that both decides and pays can be drained by a decision-boundary exploit and settle the loss in the same block.
Contrarian
Here's the unreported angle, and it cuts against the prevailing hype in both AI and crypto circles.
Everyone is framing the Decisions API as a step toward capable agents. I think it's a step toward auditable agents — and that's a much smaller, much less sexy thing. The value isn't that the model got smarter. It's that the model got narrower, and narrower is auditable in a way free generation never is. You can fuzz a finite option set. You can enumerate the failure surface. You can, in principle, prove properties about a decision space in a way you can never prove about open-ended text. The real product is not intelligence. It's a testable boundary. That's a compliance story wearing an AI costume.
Which is why the regulatory angle matters more than the technical one, and why I've spent 2025 building exactly that lens. I lean on a network of former SEC staffers and bank regulators here in DC, and the pattern I keep seeing is this: as soon as a tool starts making decisions — who gets the loan, who gets flagged, which trade routes — it stops being "limited risk" software and starts climbing the EU AI Act's high-risk ladder. A constrained decision API used for KYC gating or credit scoring or sanctions screening is a regulated decision engine, full stop. The "it's just an API" defense won't survive contact with an auditor.
The other contrarian read: this is a commodity trap, and OpenAI may be walking into it voluntarily to defend a different position. Structured output is becoming table stakes. Once every vendor has it — and the open-source world already does, for free — it can't be priced as a standalone feature. So why ship it as a named product? Two reasons, both defensive. One, to own the routing entry point in the agent stack, so builders standardize on the endpoint before the capability commoditizes. Two, to test a new billing unit — per decision — before competitors do. It's less a product than a beachhead.
And the open-source anchor caps the whole thing. Outlines, Instructor, BAML, XGrammar — free, self-hostable, no vendor lock. Against that price floor, a paid API can only charge for three things: no-ops maintenance, lower latency, and reliability guarantees. Two of those are engineering, and one of them is an SLA. None of them is a moat. Speed eats strategy for breakfast — but only if the speed is real, and nobody has published a latency number.
Which brings me back to the bull-market lens I opened with. Right now, in this market, capital is chasing narratives. Agent infrastructure is a narrative. "Fast decisions for agents" is a narrative. The technical reality — constrained decoding is old, the capability is commoditizing, the moat is the schema, the risk is concentrated bias — will not show up in a price chart until something breaks. And something will break, because that's what unaudited routing layers do. In May 2022 I didn't write a Terra eulogy. I pulled Lido's stETH exposure and found three hedge funds over-leveraged on LSTs as collateral, and I published wallet addresses and liquidation thresholds while everyone else was writing obituaries. The crash wasn't the story. The leverage map was. Same here. The launch isn't the story. The constraint set is.
Takeaway
So here's what to watch, and it's not the model.
The first real signal is the schema. The moment a Decisions API publishes its option sets, that's the governance document — read it like a multi-sig config, because that's what it is. The second signal is the price page: per-token or per-decision, free tier or not, because that tells you whether adoption is being bought. The third is the first third-party benchmark on latency and accuracy, because until that exists, "fast" and "reliable" are adjectives, not facts.
The bigger question, and the one I'll be tracking into 2026: when an autonomous on-chain agent makes a decision that drains a pool, who is liable — the model, the schema author, or the multi-sig that shipped the constraint? Right now, the answer is nobody, and that's the whole problem. The agents are coming regardless. The only open question is whether we audit the menu before we eat from it.