Every non-trivial system eventually has to make a judgment call. Should this ticket go to billing or infrastructure? Is this order worth a manual review? Does this frame show a defect, a person, or nothing at all? Teams usually answer these questions twice: once as a pile of hand-written rules that nobody wants to touch, and once as a chat model asked to “reply in JSON” — which then needs a parser, a validator, a retry loop, and a small amount of hope.
A decision API collapses that pattern into a single contract. Instead of generating text and hoping it validates, you send state and a set of questions defined in code, and you get back typed answers with calibrated confidence in one pass. This article looks at what that contract actually looks like, how the request and response shapes work, and where the pattern earns its keep in production systems.
What a Decision API Actually Returns
The fastest way to understand the category is to contrast it with the thing it usually replaces. When developers wire a general-purpose language model into a business rule, they are really building a text-generation pipeline with a parsing stage bolted on the end. The model emits prose that happens to resemble JSON, and your code then has to validate it, coerce types, handle refusals, retry on malformed output, and somehow decide how much to trust the result. Every one of those stages is a failure mode, and none of them produces a number you can threshold on.
A decision API inverts that. The output is not a document — it is a value drawn from a vocabulary you declared in advance. DecisionNode’s model returns five answer types, each of which maps directly onto a data structure your code already understands:
Choice returns exactly one label from a set you defined, so routing, triage, and classification become an enum lookup rather than a string match. Score returns a level on an ordered scale — useful for severity, priority, or risk bands where “medium-high” needs to be a number, not a phrase. Truth returns a calibrated probability between 0.00 and 1.00, which is the type that lets you write if confidence > 0.92 then act and mean it. Number returns a value on a grid, for quantities and estimates. Point and box return locations inside an image, for anything spatial.
Two properties make this different from a well-prompted completion. First, every answer carries a calibrated confidence, so the response is self-describing about how much weight it deserves — a 0.61 truth answer and a 0.98 truth answer are not the same object, even when they round the same way. Second, the system is deterministic: the same request produces the same answer. That sounds mundane until you try to write a regression test against a generative endpoint. Determinism is what makes a decision reproducible in staging, replayable in an incident review, and comparable across model versions — and it is the property that turns an AI component from a liability into something your on-call rotation can reason about.
The Contract: State In, Typed Decisions Out
The mechanics are deliberately boring, which is the point. You POST state to a single HTTPS endpoint, /v1/decide, and the state can be text, structured JSON, or up to 16 images and video frames in a single request. The questions travel with the request, but they are defined in code — versioned, reviewed, and diffable — rather than improvised in a prompt template. The response comes back schema-valid and typed in one pass, with no separate parsing stage between the model and your business logic.
That shape unlocks a pattern that is awkward to implement on top of a generative endpoint: threshold-gated execution. Because each answer arrives with a calibrated confidence, code can branch on it immediately. Above your threshold, act — route the ticket, approve the refund, release the gate. Below it, take the safe path: re-check with more context, escalate to a human, or fall back to the conservative default. The threshold lives in your codebase, is tunable per question, and is measurable in production. This is how you get automation rates up without quietly raising your error rate, because the confidence value tells you where the boundary actually sits.
Latency and cost matter here too, and they are unusually concrete for this class of tooling. DecisionNode ships two models: Flash at roughly 5 ms server-side and 19 ms end to end, priced at $0.035 per 1M input tokens, and MoE at roughly 9 ms and $0.042 per 1M input tokens. Output tokens are always free, batch discounts are available, and there is a free daily tier for development. SDKs cover TypeScript, Python, Go, Ruby, and curl, with MCP tools and webhooks for teams wiring decisions into agents and automation platforms. You can read the full contract and request shapes at decisionnode.com. For synchronous request/response work, an end-to-end budget in the tens of milliseconds means a decision fits inside a web request without a queue, a spinner, or an apology.
Where Decision APIs Earn Their Latency Budget
The pattern shows up wherever a system already has rules but the rules have stopped scaling. Support triage is the classic entry point: a choice answer routes the ticket to the right queue, a score sets priority, and a truth answer flags whether the message looks like a duplicate or an abuse attempt — all from the same state payload, all returned together. Fraud and promo-abuse checks follow the same shape, except the truth answer gates whether the order proceeds automatically, gets held, or gets kicked to review.
Visual decisions are where the typed outputs do the most work that JSON-in-a-prompt cannot. Quality control on a production line needs a box around the defect plus a truth score for whether it crosses the rejection threshold. Warehouse and traffic monitoring need counts, labels, and locations in the same response. Moderation needs a choice from a policy taxonomy, not a paragraph explaining the policy. In each case the value is that the answer is already the data structure the downstream system consumes.
Two integrations deserve specific mention because they change what is buildable. Sessions over WebSocket support decision loops above roughly 10 decisions per second, which is the regime drones, robots, simulators, and continuous machine monitoring operate in — a per-request HTTP round trip stops being the right primitive once you are deciding on every frame. And the boosters — human age estimation, AI-generated image detection, face detection and recognition, OCR, depth, and segmentation — let a single decision call answer compound questions that would otherwise require stacking three or four specialized models behind a routing layer.
AI agents are the newest consumer of this interface, and arguably the most natural. An agent that calls a decision endpoint before acting gets a typed verdict and a confidence value, which is a far better substrate for tool selection than free-text reasoning about whether the next step is safe. The agent decides before it acts; the decision API tells it how sure to be. Teams running these workloads in production tend to instrument calibration first — bucketing historical answers by confidence band and measuring observed accuracy within each band — because that measurement, more than raw accuracy, is what tells you which thresholds are safe to lower and which decisions still need a human in the loop.
