Most engineering teams that try to extract decisions from a language model end up rebuilding the same brittle scaffolding: a prompt that begs for “JSON only”, a tolerant parser, a retry loop, a validator, and a growing pile of special cases for the day the model renamed a key or wrapped its answer in prose. It demos beautifully and breaks in production. A decision API takes a different approach. Rather than generating text and hoping it parses, it accepts application state and a question defined in code, and returns an answer that satisfies your schema by construction — a label, a level on a scale, a calibrated probability, a number on a grid, or a location inside an image. The output is a value your code can branch on immediately, not a paragraph your code has to interpret.
What a Decision API Is — and Why JSON Mode Is Not One
A decision API is a narrow, typed interface for classification, scoring, gating, and localization. You do not ask it to “think”; you ask it a bounded question and constrain the answer space in advance. A decision engine such as DecisionNode exposes a small set of answer types that cover most operational logic: choice returns exactly one label from a set you supply; score returns a level on an ordered scale; truth returns a calibrated probability between 0.00 and 1.00; number returns a value snapped to a grid; and point and box return coordinates inside an image. Because the answer space is closed, the response is schema-valid by definition — there is no “the model hallucinated a field” failure mode, and no repair pass to write.
This is the structural difference from a chat model in JSON mode. JSON mode constrains syntax, not semantics: the response is valid JSON, but the value inside can still be an off-schema label, a confidence-free guess, or a nested object you did not ask for. A decision API constrains the decision space. You declare the labels, the scale bounds, or the grid resolution, and the endpoint can only answer within those bounds. Downstream code stops defensive-parsing and starts branching.
The second contrast is with hand-written rules. If/else trees encoding routing policy, fraud heuristics, or quality thresholds are easy to write and miserable to maintain — nobody wants to touch the file that decides whether an order ships, and every edge case adds a branch that another branch must not contradict. Decision logic expressed as a typed question, with a calibrated confidence attached, is a versionable contract. You can test it, replay it, and change one label without untangling a conditional ladder. Teams evaluating the move from rules to model-driven decisions can see the request and response shapes documented at decisionnode.com.
The practical consequence is that the decision API fits where a chat model is a poor shape: high-volume, low-latency, machine-consumed calls where the answer feeds a branch, a queue assignment, a moderation gate, or an actuator — not a human reading a chat window.
Inside POST /v1/decide: State In, Typed Answers Out in a Single Pass
The request model is deliberately flat. You send state — text, JSON, or up to sixteen images or video frames — together with the questions defined in code, to one HTTPS endpoint: POST /v1/decide. There is no multi-turn negotiation, no tool-calling loop, and no chain-of-thought transcript you pay for by the token. Everything resolves in one pass, which is what makes the latency numbers achievable and the behavior testable.
Multiple questions can be asked against the same state in a single request, which matters for cost and consistency: a support ticket can be classified by queue, tagged by urgency, and checked for abuse signals in one call instead of three. The model families behind the endpoint are DecisionNode Flash (roughly 5 ms server-side, about 19 ms end to end) and DecisionNode MoE (roughly 9 ms), with output tokens always free — relevant because typed answers are short by design.
Integration surface is broad on purpose, since decision points live in many runtimes: SDKs for TypeScript, Python, Go, and Ruby, plus curl for anything else, MCP tools for agents, and webhooks for event-driven pipelines. For control loops that exceed roughly ten decisions per second — drones, robots, simulators, machine monitoring — sessions over WebSocket avoid per-call overhead and keep the loop tight.
Vision-heavy decisions do not require a separate model pipeline. Boosters layer specific capabilities onto the same endpoint: human age estimation, AI-generated image detection, face detection and recognition, OCR, depth, and segmentation. A production-line quality check can therefore return a pass/fail truth value and a bounding box around the defect in one response, and a warehouse monitoring job can fuse frame analysis with a routing label without stitching three vendors together.
Two engineering habits make this pleasant to operate. First, treat question definitions as source-of-truth artifacts under version control — they are part of your application contract, not prompt text buried in a config string. Second, log the raw typed response alongside the decision your code took, so later analysis can separate “the model was wrong” from “the threshold was wrong”. Those are different bugs with different fixes, and a typed response keeps them distinguishable.
Calibrated Confidence, Determinism, and Millisecond Latency in Production
The property that changes system design more than any other is calibration. Every answer from a decision API carries a calibrated confidence, and the truth type is a calibrated probability on a 0.00–1.00 scale. Calibrated means a confidence of 0.80 should be right about eighty percent of the time across the population of requests where it reports 0.80 — which is what allows a threshold to be a real engineering control rather than a vibe. Code can act instantly above the threshold and, below it, route to a re-check, a second model, a human queue, or a documented safe default. The uncertainty is explicit in the response instead of hidden inside fluent prose.
Determinism is the second load-bearing property: the same request returns the same answer. That makes decisions replayable for incident review, cacheable at the application layer, stable under regression tests, and auditable when a regulator, a customer, or an on-call engineer asks why a specific order was held or a specific ticket was escalated. Chat models offer none of these guarantees, which is why so many “reply in JSON” integrations end up wrapped in retries that silently change the answer.
Latency and cost follow from the single-pass design. Flash runs around 5 ms server-side and 19 ms end to end at $0.035 per 1M input tokens; MoE runs around 9 ms at $0.042 per 1M input tokens. Output tokens are always free, batch discounts are available, and there is a free daily tier — enough to load-test a real pipeline before committing. For a checkout path, a 19 ms budget is workable in-line; for a control loop, the WebSocket session mode is the right shape.
The use cases that benefit most share a profile: high call volume, a closed answer space, and a clear cost of being wrong. Ticket routing and triage, fraud and promo-abuse checks, order and shipping decisions, moderation, scoring, gating, quality control on production lines, and warehouse or traffic monitoring all fit. So do AI agents: an agent that calls a decision API before acting gets a typed verdict with a confidence it can gate on, instead of a generated justification it must parse and second-guess. For ops and automation teams replacing brittle rule files, the migration path is incremental — encode one decision as a question, compare its outputs against the existing rules on replayed traffic, then cut over when the confidence distribution and the disagreement set both look sane.
A Kazakh software architect relocated to Tallinn, Estonia. Timur blogs in concise bursts—think “micro-essays”—on cyber-security, minimalist travel, and Central Asian folklore. He plays classical guitar and rides a foldable bike through Baltic winds.