Every automated workflow eventually hits a branch point. A support ticket needs a queue. An order needs a fraud verdict before it ships. A camera on a production line needs to know whether the component in frame is seated correctly. Each of those is a decision, and each one has traditionally been handled either by a pile of hand-written conditionals or by a chat model asked, politely, to respond in JSON. A decision API replaces both patterns with something narrower and considerably more useful: a single endpoint that accepts state, evaluates questions your code has already defined, and returns a schema-valid, typed answer with a calibrated confidence attached.
What a Decision API Returns: Typed Primitives, Not Prose
A decision API is not a general-purpose text generator wearing an API key. It is a service built around a fixed output contract. The caller supplies two things: the state under consideration and the questions, both expressed in code. State can be plain text, structured JSON, or up to sixteen images and video frames. The questions declare in advance what is being asked and which answers are permitted, so nothing depends on a prompt remembering to mention the allowed values. The response arrives in a single pass, already valid against the schema the caller defined.
The vocabulary of answers is deliberately small, and that is the point. A decision API returns choice, one label drawn from your own set; score, a level on an ordered scale; truth, a calibrated probability between 0.00 and 1.00; number, a value snapped to a grid; and point or box, a location inside an image. Those six primitives cover most of what operational software actually needs to know about the world, and crucially, every one of them is machine-checkable.
Compare that with the common alternative: a generative call wrapped in an instruction to reply in JSON. It works in demos and fails in production, always for the same boring reasons. The model wraps the object in a markdown code fence. It appends a friendly sentence after the closing brace. It renames a key, invents an enum value that was never in the list, or returns a number as a quoted string. Each of those becomes a parser, a retry, a fallback branch, and eventually a ticket. With typed decisions the contract is fixed at build time, enum values cannot drift because the labels came from your code, and the answer is either valid against the schema or it isn’t.
Implementations differ mainly in how cleanly they hold that contract. decisionnode.com, for example, exposes the whole thing as one HTTPS endpoint, POST /v1/decide, where state and code-defined questions go in and typed answers come back with no multi-step prompting chain and no post-processing layer stitched on top. That architectural simplicity matters more than it first appears: fewer moving parts between the caller and the answer means fewer places for latency, cost, and failure modes to hide.
Calibration and Determinism: The Two Properties That Make a Decision Safe to Act On
An answer without a confidence value is a guess wearing a suit. The more useful property of a modern decision API is that every response carries a calibrated confidence, a probability that the answer is correct given similar inputs. Calibration is the difference between a model that sounds sure and one that is measurably right roughly nine times out of ten when it says 0.90. For a developer, that turns a binary into a dial: code can act instantly above a threshold, and take a different path below it.
In practice this produces explicit risk budgets instead of implicit ones. A chargeback check might auto-approve above 0.95, hold between 0.60 and 0.95 for an extra signal or a human look, and route everything below 0.60 to a safe default. A warehouse label inspection might trust the model above 0.90 and clip the frame for review below it, while the conveyor keeps moving. The threshold is a business decision written in a config file, not a vibe buried in a prompt, and it can be tuned against real traffic without redeploying the model.
Determinism is the second property, and it is what makes the whole thing testable. Same request, same answer means fixture-based unit tests actually assert something stable, production requests can be replayed during an incident, and a change to a question definition shows up as a clean before-and-after diff rather than noise. Sampling-based generation gives you a slightly different response every call, which is fine for prose and corrosive for anything sitting inside an automated pipeline.
Latency and cost decide whether a decision can live inline. DecisionNode Flash runs at roughly 5 ms server-side and 19 ms end to end, and the MoE model at about 9 ms — fast enough to sit inside a request handler rather than in a queue. Pricing is $0.035 per 1M input tokens for Flash and $0.042 for MoE, with output tokens always free, a free daily tier for development, and batch discounts for offline scoring. At that scale, a decision stops being a scarce resource you guard and becomes a cheap step you can afford to repeat whenever confidence is thin.
Decision APIs in Production: Triage, Fraud, Quality Control, and Agent Gating
The use cases cluster around work that is repetitive, high-volume, and currently handled by either brittle rules or a queue of humans. Ticket routing and triage is the classic entry point: a subject line and body become a choice across team labels, plus a truth probability for “needs escalation,” so the easy majority flows through untouched. Fraud and promo-abuse checks work the same way, returning a probability that a downstream policy converts into allow, challenge, or block. Order and shipping decisions, moderation, scoring, and feature gating all follow the pattern of state in, typed answer out, threshold applied by the caller.
Visual primitives open up physical operations. Quality control on a production line becomes a camera frame plus a question — “is the seal intact?” — answered with a choice and a box that localizes where the model looked. Warehouse and traffic monitoring use the same primitives across frames. Boosters extend the base models for specific signals: human age estimation, AI-generated image detection, face detection and recognition, OCR, depth, and segmentation, each stacking onto the decision primitives rather than demanding a separate inference pipeline and a separate set of credentials.
Throughput shapes the transport. For loops above roughly ten decisions per second, sessions over WebSocket keep a persistent connection open, which is what makes drones, robots, simulators, and continuous machine monitoring feasible. For everything else, standard HTTPS plus the available SDKs — TypeScript, Python, Go, Ruby, curl, MCP tools, and webhooks — is enough to wire a decision into an existing service in an afternoon. AI agents get a particularly natural fit: rather than generating an action and hoping, an agent calls the decision API to choose the next step from a fixed set of tool labels, or to confirm that a proposed action is appropriate before executing it.
There is a quieter operational benefit too. When every branch in a system is expressed as a typed decision, each response can be logged with its confidence and later analyzed as a distribution. A slow drift in the share of low-confidence answers on one queue, one SKU, or one camera is an early warning that the underlying conditions have changed — visible in a dashboard before it becomes a backlog, a mis-shipment, or a line stoppage.
