Every engineering team that has shipped a chat model into a production workflow recognizes the pattern. You ask for JSON, you get JSON most of the time, and the remainder becomes a retry loop, a defensive parser, a fallback branch, and eventually an incident channel named after the schema drift that broke the pipeline at 3 a.m. The model was rarely the problem. The contract was. Prose is a poor interface between two systems that both need to be predictable: one that generates, and one that must act.
A decision api fixes the contract by narrowing the job to a single verb: decide. Instead of asking a model to describe a situation and hoping the description can be parsed into a decision, you declare the shape of the answer in code and receive a value that already conforms to it. That shift — from open-ended text to typed, calibrated output — is what makes a decision API safe to place directly in the hot path of an application rather than behind a human reviewer.
What a Decision API Returns: Types, Not Text
A decision API is built around a small set of answer primitives, and every request maps to one of them. The choice type returns exactly one label from a set you define — refund, replace, escalate. The score type returns a level on an ordered scale, so “how risky is this order” becomes a position rather than an adjective. The truth type returns a calibrated probability between 0.00 and 1.00, which is a very different object from a model saying “likely” or “probably.” The number type returns a value snapped to a grid you specify, which keeps outputs comparable across calls. And for visual state, point and box return coordinates and bounding regions inside an image — useful when the decision is about where something is, not just whether it exists.
Mechanically, the request is unremarkable, which is the point. On DecisionNode, developers POST to a single HTTPS endpoint, /v1/decide, with a state payload — free text, structured JSON, or up to 16 images or video frames — plus the questions defined in code. One request, one pass, one typed response object. There is no multi-turn negotiation, no tool-calling choreography, and no output tokens to bill, because the service is not generating prose that later has to be interpreted. DecisionNode offers two models: Flash at roughly 5 ms server-side and 19 ms end to end at $0.035 per 1M input tokens, and MoE at roughly 9 ms at $0.042 per 1M input tokens, with output tokens free, batch discounts, and a free daily tier for development.
The property teams underestimate most is determinism. The same request returns the same answer. That sounds like a baseline expectation until you have tried to write a regression suite against a generative endpoint whose temperature, provider version, and internal routing can all shift between runs. With typed answers and reproducible results, a decision API behaves like any other dependency in your stack: fixture in, assertion out, green build.
Calibrated Confidence Is the Part That Changes Your Architecture
Typed output removes the parsing problem. Calibration removes a much larger one: the question of what your code should do when the model is unsure. Every answer from a decision API carries a confidence, and because that confidence is calibrated, a value of 0.90 means roughly what a 0.90 should mean across the whole population of requests — not simply that the model sounded assertive on this particular input.
That single number lets you replace a binary branch with a three-way branch. Above a high threshold, act immediately and without human involvement: auto-approve the refund, auto-route the ticket, auto-pass the unit on the line. In a middle band, buffer the decision and send it for a cheap secondary check — a different question, a different model tier, or a queue for a human. Below a low threshold, take the safe path: hold the order, block the promo code, flag the frame for review. The thresholds live in your codebase, are reviewed like any other business rule, and are tuned against measured outcomes rather than guessed at.
Determinism compounds the benefit. Because identical requests produce identical responses, you can replay last quarter’s traffic through a new threshold set and see exactly how many decisions would have changed and in which direction — before you ship the change. You can cache aggressively on state hashes. You can log the typed answer and the confidence side by side and audit later why a specific decision was made, weeks after the fact, without reconstructing a prompt.
Throughput shapes the integration choice. For request/response workloads — a checkout, a triage step, a moderation gate — plain HTTPS calls are the right fit, with SDKs available for TypeScript, Python, Go, and Ruby, plus curl for anything else. For continuous loops above roughly 10 decisions per second, such as drones, robots, simulators, or machine monitoring, session-based WebSocket connections avoid per-call overhead and keep the loop tight. Both paths return the same typed answer objects, so the application logic above them does not change when a workload graduates from one mode to the other.
Where Decision APIs Replace Hand-Written Rules and Chat-in-JSON Calls
The clearest candidates for a decision API are workloads that already have a rules engine quietly failing under its own weight. Ticket routing and triage is a canonical example: a support inbox grows a tangled chain of keyword matchers and priority overrides until nobody can explain why a billing complaint lands in the wrong queue. Replacing that chain with a choice decision over your real queue labels, plus a score for urgency and a calibrated truth for “is this a duplicate,” collapses hundreds of lines of brittle conditionals into three declarations.
Fraud and promo-abuse checks follow the same shape but with different stakes. Rather than hard-blocking on a rule that generates false positives during peak season, the decision returns a probability your code can threshold and re-check — and because the answer is calibrated, the ops team can budget review capacity against a real expected volume instead of a guess. Order and shipping decisions, moderation queues, eligibility gating, and lead scoring all reduce to the same pattern of labels, scales, and probabilities that code can act on directly.
Visual workloads benefit from the image-aware types. Quality control on a production line can ask for a box around a defect and a choice among defect classes in a single call, while the OCR, depth and segmentation, human age estimation, AI-generated image detection, and face detection or recognition boosters handle the perception steps that would otherwise require a separate model pipeline. Warehouse and traffic monitoring use the same primitives at scale: count, locate, classify, and flag — each with a confidence attached.
AI agents deserve their own mention, because a decision API inverts the usual failure mode of agentic systems. Instead of an agent acting and then asking a model to judge what happened, the agent calls a decision endpoint before acting and receives a typed verdict with a confidence it can branch on. Exposed through MCP tools, webhooks, or a plain SDK call, that pattern gives an autonomous loop a guardrail that is deterministic, auditable, and fast enough to sit inside a control cycle — the difference between an agent that reasons in prose and one that decides in types.
