Most teams that try to put AI into production hit the same wall. They wrap a chat model in a prompt, ask it to “respond only in JSON,” and then spend the next six weeks writing parsers, validation layers, retry logic, and fallback handling for the inevitable moment the model decides to say “Sure! Here’s the JSON you asked for.” The model was never the problem. The problem is that a text-generation API is being used to answer questions that code needs to consume. A decision API is the correction to that pattern: instead of generating prose you parse, it returns typed, calibrated answers you branch on.
The distinction matters more than it sounds. With a generative endpoint, the output is a string whose shape you hope holds. With a decision endpoint, the output is a value whose type is part of the contract. You define the questions in code, send the state, and get back an answer that is already the right shape for an if statement, a threshold check, or a database column.
What a Decision API Actually Is — and Why It Is Not a Chat Model in a Trench Coat
A decision API is an inference service built around a narrow, disciplined contract: you send state plus a set of questions defined in your code, and you receive structured answers in a single pass. On DecisionNode, that contract is deliberately small — one HTTPS endpoint, POST /v1/decide. The state you send can be text, JSON, or up to 16 images or video frames. The questions are declared programmatically, which means your application owns the schema rather than hoping the model respects a prompt.
The answers come back as one of a fixed set of types. A choice is exactly one of the labels you supplied — you own the taxonomy, so there is no free-text label to normalize. A score is a level on an ordered scale, which is what you want for severity, risk tiers, or priority bands where the ordinal relationship carries meaning. A truth is a calibrated probability between 0.00 and 1.00 — a real number you can multiply, threshold, or feed into expected-value math. A number is a value on a grid, useful for quantities the model should estimate rather than classify. And point and box return locations in an image, which is how spatial questions become typed answers instead of prose descriptions of where something probably is.
The piece that separates this from a well-prompted classifier is calibration. Every answer carries a confidence score, and that confidence is not decorative metadata — it is an input to your control flow. Code can act instantly above a threshold and take a re-check path, queue for human review, or route to a safe default below it. That single design decision eliminates an entire category of production incidents: the ones where your system was confidently wrong and nothing in the response told you so.
There is also a determinism guarantee that changes how you test and audit. Same request, same answer. That means decisions are replayable, unit-testable, and defensible in an audit trail — properties that are effectively impossible to guarantee when you are sampling from a generative model with a temperature setting.
The Five Answer Types and How They Reshape Your Code
The practical value of a decision api shows up in the shape of the calling code. Consider a support triage pipeline. With a generative model, your code looks like this: build a prompt, call the endpoint, parse the response, handle malformed JSON, coerce the label to match your enum, and hope the model did not invent a sixth category. With typed decisions, you declare the labels once and branch directly. The choice type makes the enum the contract, so a new category the model invents is structurally impossible.
Scoring follows the same logic. If you are ranking accounts by churn risk or orders by fraud likelihood, a score on an ordered scale maps cleanly to a queue position, and because the scale is ordered, adjacent levels are comparable in a way that free-text severity descriptions never are. When you need arithmetic rather than ranking, the truth type gives you a probability you can combine with business numbers — expected loss, expected margin, expected delay cost — which is where calibrated confidence starts paying for itself in real money.
The number type handles the estimation questions that get awkward in text form: how many units are on a pallet, what is the estimated wait time bucket, how many items are in a frame. Because the answer snaps to a grid, downstream aggregation does not need to parse “approximately seven to nine” into a usable integer.
Point and box answers unlock the vision cases that usually force teams into a separate, heavier stack. Quality control on a production line, warehouse slot verification, or traffic monitoring all depend on where something is, not just whether it is present. Returning a location as a typed value means your existing geometry and overlay code consumes it directly.
None of this requires you to abandon the questions you already have. It requires you to express them as declarations rather than prompts — which is, notably, also how you make them versionable, reviewable, and diffable in a pull request.
Latency, Cost, and Determinism as Architectural Constraints
For a technical audience, the numbers matter more than the narrative. DecisionNode ships two models. DecisionNode Flash runs at roughly 5 ms server-side and 19 ms end to end, priced at $0.035 per 1M input tokens. DecisionNode MoE runs at roughly 9 ms, priced at $0.042 per 1M input tokens. Output tokens are always free — a pricing model that only makes sense when the output is a typed decision rather than generated text, and which removes the usual anxiety about verbose responses inflating your bill. Batch discounts are available, and there is a free daily tier for development and low-volume production checks.
Nineteen milliseconds end to end is the number that changes architecture. At that latency, decisions can sit inside request paths that were previously off-limits to AI: inline checkout fraud checks, synchronous ticket routing, per-request content moderation, order and shipping decisions evaluated before the API responds. When a call takes two seconds and returns a variable-length string, it has to be a background job with a queue and a reconciliation process. When it takes tens of milliseconds, it can be a function call.
For tight loops, throughput becomes the constraint rather than latency. Sessions over WebSocket are available for loops above 10 decisions per second — the regime that matters for drones, robots, simulators, and continuous machine monitoring, where the cost of establishing a connection per decision would dwarf the inference itself.
Determinism deserves its own line because it is an architectural property, not a feature. Same request, same answer means you can snapshot decisions in tests, replay a production request to reproduce a bug, and explain to an auditor why a specific order was flagged. Teams migrating off brittle hand-written rule engines often find this the hardest property to give up — and the one they most need to keep.
Where Decisions Land in Real Systems: Routing, Risk, Vision, and Agents
The use cases cluster around a few patterns. Routing and triage is the most common entry point: classifying inbound tickets, assigning queues, escalating by severity. Fraud and promo-abuse checks lean on the probability type, because a calibrated 0.83 combines with order value and account age in ways a boolean never could. Order and shipping decisions — hold, split, expedite, reroute — are naturally choice and score problems. Moderation, scoring, and gating all reduce to the same question: does this clear the bar, and how sure are we?
Vision-heavy operations get the most out of typed spatial answers. Quality control on production lines, warehouse slot and inventory verification, and traffic monitoring all benefit from point and box responses, and the optional boosters extend the base model for specific perceptual tasks: human age estimation, AI-generated image detection, face detection and recognition, OCR, depth, and segmentation. These are not separate products to integrate — they are capabilities you enable on the same decision surface.
For AI agent builders, the pattern is slightly different and arguably more important. An agent that calls a decision endpoint before acting gets a typed verdict plus a confidence it can gate on, which is far more controllable than letting the agent narrate its own reasoning and hoping the conclusion was sound. DecisionNode exposes SDKs for TypeScript, Python, Go, Ruby, and curl, along with MCP tools, webhooks, and agent integrations, so the decision layer sits naturally between an agent’s intent and its action.
Platform and ops teams tend to arrive at the same place from a different direction. They have accumulated years of hand-written rules — nested conditionals, magic thresholds, comments explaining why the threshold is 0.72 and not 0.75 — and they need to replace them without losing determinism or observability. A decision API gives them a typed, calibrated, replayable replacement they can wrap in the same monitoring they already trust, with confidence thresholds that make the safe path explicit instead of implicit in an undocumented rule.
Reykjavík marine-meteorologist currently stationed in Samoa. Freya covers cyclonic weather patterns, Polynesian tattoo culture, and low-code app tutorials. She plays ukulele under banyan trees and documents coral fluorescence with a waterproof drone.