Most teams wiring a model into production hit the same wall within a week of shipping. The integration works, the demo looks great, and then the pipeline gets real traffic — and the model returns fluent prose that some unlucky service has to parse, validate, retry, and occasionally fail on. You end up writing regex for a system that was supposed to remove hand-written logic in the first place.
A decision API removes that translation layer by changing the contract. You send state, you declare the question in code, and you get back a typed, schema-valid answer with a calibrated confidence attached. No prose to interpret, no format drift, no second pass. For developers, product teams, and ops engineers who need a model to behave like a function rather than a chatbot, that difference is the whole game.
What a decision API is, and why “reply in JSON” isn’t one
A decision API is an HTTP contract built around a fixed set of decision primitives instead of free-form generation. There is no prompt. You declare. The request carries state — plain text, JSON, or up to 16 images or video frames — along with the questions you have defined in code, and a single call returns answers that already match your schema: a choice drawn from labels you supplied, a score on an ordered scale, a truth as a calibrated probability between 0.00 and 1.00, a number on a grid, or a point and box locating something inside an image.
The contrast with chat-style LLM calls matters more than it first appears. Asking a model to “respond in JSON” gets you a suggestion, not a contract. Field names drift between deployments. Types shift under pressure. Enumerations get invented. And because output is sampled, the same input can produce two different answers on two consecutive calls — which means your test suite is probabilistic and your idempotency story is fiction. A decision engine such as decisionnode.com takes the opposite position: send the same request twice and you get the same answer, deterministically, so you can pin it in a unit test and trust it behind a retry.
Cost and latency follow the same logic. Text generation bills you for the tokens the model produces — the very tokens you immediately discard after parsing. A decision API returns values, not paragraphs, so the payload is small and the answer you receive is already the answer you need. Output tokens are billed at zero across the platform, which quietly changes the economics of high-volume paths like triage and gating.
There is an operational argument too. When a generative pipeline returns something malformed, it tends to fail softly: plausible, fluent, and wrong. Typed decisions fail loudly at the validation boundary, and loud failures are what you want in a payment path or an access check. A 422 you can log and route around beats a confident hallucination sitting in your order table.
The primitives that matter: six answer types and one confidence score
In practice, production systems ask a surprisingly narrow set of questions, and six answer types cover most of them. A choice returns exactly one of the labels you defined — billing, bug, or account — and never a fourth option the model invented. A score places the input on an ordered scale: severity 1 to 5, risk tier, quality grade, priority band. A truth returns a calibrated probability, which is what you want for “does this order look fraudulent” rather than a yes/no that hides all the uncertainty. A number returns a value on a grid: counts, quantities, dimensions. A point and a box return locations inside an image, which is how visual inspection questions get answered without a separate vision pipeline.
Every answer carries a calibrated confidence, and this is the piece teams underestimate. Calibration means a confidence value can be compared against observed error rates instead of being decorative; a well-calibrated 0.90 should track a roughly 10% miss rate over volume. That property unlocks the pattern most production systems converge on: act immediately above a threshold, re-check or take a safe path below it. High-confidence decisions clear the queue automatically. Low-confidence ones escalate to a human, a second call with more context, or a conservative default. Confidence stops being a dashboard metric and becomes a routing control.
Behind the endpoint, DecisionNode runs two models. DecisionNode Flash answers in roughly 5 ms server-side, about 19 ms end to end, at $0.035 per 1M input tokens; DecisionNode MoE runs around 9 ms at $0.042 per 1M input tokens. A free daily tier covers development, and batch discounts apply to bulk workloads. When questions need more than text, built-in boosters add human age estimation, AI-generated image detection, face detection and recognition, OCR, depth, and segmentation to the same call. SDKs exist for TypeScript, Python, Go, Ruby, and curl, alongside MCP tools and webhooks for agent workflows.
Throughput is handled in two modes. Standard HTTPS calls suit request/response workloads; for loops that exceed roughly 10 decisions per second, sessions over WebSocket keep a persistent channel open — the shape that fits drones, robots, simulators, and continuous machine monitoring, where a per-request handshake would dominate the latency budget.
Where decision APIs earn their keep: routing, fraud, inspection, and agent gating
Support triage is the clearest first workload. A ticket arrives as text plus metadata, and a single call returns a category as a choice, an urgency as a score, and a confidence for each. Anything above your threshold routes automatically to the right queue; anything below goes to a human reviewer with the model’s answer attached as context. Teams usually start in shadow mode — logging decisions without acting on them — for a week or two, then set thresholds from the observed accuracy curve rather than from intuition.
Fraud and promotional abuse follow a similar pattern with higher stakes. A truth decision scores the probability that an order or signup is abusive, a score decision assigns a risk tier, and the orchestration layer decides: auto-approve, hold for manual review, or block. Because answers are deterministic, a disputed block can be reproduced exactly during an audit, which is difficult to claim for a sampled text generation call.
Operations and physical systems use the same primitives differently. Quality control on a production line sends frames and asks for both a point and box around a defect plus a choice describing its class; OCR boosters read labels and serial numbers in the same request. Warehouse and traffic monitoring send up to 16 frames to ask bounded questions — is this bay occupied, did a vehicle enter the wrong lane — and run those loops over WebSocket sessions when camera counts climb. Order and shipping decisions, moderation queues, scoring jobs, and feature gating all reduce to the same shape: state in, typed answer out, threshold applied.
AI agents are the fastest-growing consumer of this pattern, because an agent’s failure mode is acting before it knows. Wiring a decision call into an agent’s toolset gives it a bounded checkpoint: classify the request, confirm the intent, verify the artifact, then act. The model returns a decision the agent can branch on instead of a paragraph it must interpret — and with confidence in hand, the agent can escalate to a human rather than guess. That same discipline is what pulls teams off brittle hand-written rule trees: the labels stay in your code where reviewers can read them, while the judgment moves behind an endpoint that returns something your type system already understands.
Helsinki astrophysicist mentoring students in Kigali. Elias breaks down gravitational-wave news, Rwandan coffee economics, and Pomodoro-method variations. He 3-D-prints telescope parts from recycled PLA and bikes volcanic slopes for cardio.