Most teams that put a language model into production start the same way: they write a prompt, ask for JSON, and then spend the next month building parsers, validators, retries, and fallbacks around output that still drifts on edge cases. The model is performing a generation task when the application actually needs a decision. That mismatch is why the decision api pattern has moved from novelty to core infrastructure for engineering teams building routing, risk, moderation, and automation systems.
A decision API reframes the contract entirely. Instead of sending free-form prose and hoping the response parses, the caller sends state — text, JSON, or up to 16 images and video frames — alongside questions defined in code. The service returns schema-valid, typed answers, each stamped with a calibrated confidence, so the calling system can act instantly when certainty is high and escalate, re-check, or take a safe path when it is not. DecisionNode builds exactly this: a “System One” decision model that returns structured decisions rather than generated text.
What a Decision API Returns — and Why the Type System Matters
A chat model returns tokens. A decision API returns values with declared types, and that difference reshapes everything downstream. On DecisionNode’s decision api, a single HTTPS call to POST /v1/decide resolves a fixed set of answer shapes: choice (one label from a set you define in code), score (a level on an ordered scale), truth (a calibrated probability between 0.00 and 1.00), number (a value on a grid), and point or box (locations inside an image).
The practical consequence is that your integration code stops being defensive. There is no regex scraping, no “repair the truncated JSON” helper, no retry loop hoping the model returns a member of your enum this time. A choice answer maps to a switch statement. A score answer maps to a tier lookup. A truth answer maps to a threshold comparison. The validation layer you would have written by hand becomes the response schema itself, and the caller can treat the endpoint like any other typed internal service.
Confidence is the second half of the contract. Every answer carries a calibrated confidence, meaning a 0.90 is intended to behave like a 0.90 across many calls — not a self-reported vibe from a model asked “how sure are you?” That enables a routing pattern that is genuinely hard to build on top of generated text: act above a threshold, escalate below it. An order-approval service might auto-clear anything above 0.95, queue 0.70–0.95 for a lightweight secondary check, and hand the remainder to a human. The threshold lives in code, is reviewable in a pull request, and applies uniformly.
Two structural properties make this testable. First, decisions are returned in one pass — no multi-turn chain where turn three contradicts turn one. Second, the model is deterministic: the same request yields the same answer. That means fixtures in your test suite stay green, cached decisions remain valid, and an audit trail can reproduce exactly what the system saw and concluded six months ago. When a support ticket was misrouted, you can replay the request instead of guessing.
Latency and Unit Economics: Why Milliseconds Change Architecture
Decision services live or die on where they can sit in a request path. If a call takes seconds, it belongs in an async worker behind a queue, which forces you to design around eventual consistency. If a call takes single-digit milliseconds, it can sit inline — inside a checkout flow, an API gateway plugin, an intake webhook, or a message consumer that must acknowledge within a tight window.
DecisionNode ships two models with explicit performance envelopes. 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 at $0.042 per 1M input tokens. Output tokens are always free, batch discounts are available, and there is a free daily tier — all of which matters when a decision runs on every ticket, every order line, or every frame.
The cost model is worth internalizing because it differs from generation pricing. With a chat model, spend scales with how verbosely the model explains itself, and prompts balloon as you add few-shot examples and formatting instructions. With a decision endpoint, the response is a bounded typed payload, output is not billed, and cost per call is predictable from input size alone. For high-volume gating — promo-abuse checks at signup, moderation on every uploaded asset — predictable unit economics is often the difference between shipping and shelving.
For control loops, request/response is the wrong shape. When a system needs more than 10 decisions per second — drone flight logic, robot manipulation, simulator stepping, continuous machine monitoring — WebSocket sessions keep a persistent connection open and remove per-call connection overhead. That is the same typed decision contract, just streamed, which lets a perception loop ask “is the aisle clear?” or “is this part within tolerance?” at sensor cadence rather than at human cadence.
Where Decision APIs Replace Rules Engines and Chat Wrappers
The migration typically starts in one of two places: a rules engine that has grown into thousands of `if` statements nobody dares edit, or an LLM wrapper prompt that works 92% of the time and fails silently the rest. Both are attempts to encode judgment in code that cannot express nuance, or in prose that cannot guarantee shape.
Consider ticket routing and triage. A platform defines its queue labels as a choice question, sends subject plus body as text state, and gets back a label with confidence. High-confidence tickets route automatically; low-confidence tickets collect a required field before routing. The rules engine’s fallback bucket drops from a third of volume to a rounding error, and every routing change becomes a label-set edit rather than a code deploy. The same shape covers moderation, scoring and gating, and fraud or promo-abuse checks, where a truth answer plus a threshold replaces hand-tuned heuristics.
Image-aware decisions follow the same pattern. Because a request can carry up to 16 images or video frames, quality control on production lines, warehouse monitoring, and traffic monitoring can combine a point or box answer — where in the frame is the defect — with a choice answer about defect class and a confidence value. Boosters extend this without a separate vision stack: human age estimation, AI-generated image detection, face detection and recognition, OCR, depth, and segmentation attach to the same decision call, so age-gating or document verification is one request rather than three vendor integrations.
For agent builders, the interesting property is deciding before acting. An autonomous agent that can call tools needs a cheap, fast judgment about whether the next action is safe, relevant, or within policy — and it needs that judgment as a probability, not a paragraph. MCP tools and webhooks expose the same endpoint to agent runtimes, and SDKs for TypeScript, Python, Go, Ruby, and plain curl keep the integration surface small enough that a first decision can ship in an afternoon: define the questions, pick the labels, set the threshold, wire the escalate branch.
Granada flamenco dancer turned AI policy fellow in Singapore. Rosa tackles federated-learning frameworks, Peranakan cuisine guides, and flamenco biomechanics. She keeps castanets beside her mechanical keyboard for impromptu rhythm breaks.