Most teams that add a model to a product do not actually want text. They want a value their code can branch on: a label, a level, a probability, a coordinate. The gap between those two things is where a surprising amount of engineering time disappears — retry loops around malformed JSON, regex cleanup on model output, fallback paths for the one request in fifty that returns a paragraph instead of a field, and a nagging inability to write a unit test that means anything. A decision api closes that gap by treating the response the way an API should: as a contract, not a suggestion.
What a Decision API Does Differently From a Chat Completion Call
The conventional approach to getting structured output from a language model is to ask nicely. You write a prompt that says “respond only in JSON matching this schema,” you add a few examples, and you hope. In practice this produces a pipeline that is probabilistic at two layers instead of one: the model may answer the question incorrectly, and it may also fail to format the answer correctly. Those are different failures with different remedies, but they arrive through the same channel, so teams end up writing validation code that cannot distinguish between a bad decision and a bad serialization.
A decision API removes the second failure mode entirely. Instead of generating tokens that happen to look like data, the endpoint accepts a request — state plus a set of questions you defined in code — and returns schema-valid typed answers in a single pass. In DecisionNode’s case that means one HTTPS call to POST /v1/decide, with state supplied as text, JSON, or up to 16 images or video frames. The response types are deliberately narrow and deliberately useful: choice (one label from a set you supply), 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 within an image).
That narrowness is the point. A choice type cannot return eighteen words when you expected “billing.” A score type cannot return 4.7 when your scale is 1–5. Because the question set lives in your code rather than in a prompt string, it is versionable, reviewable, and diffable alongside the rest of your service. When a product manager asks what changed between two releases of your triage logic, the answer is a commit, not a rewritten paragraph of instructions.
The second structural difference is determinism. Chat models vary between calls by design; sampling temperature, batching, and provider-side version changes all contribute. DecisionNode is deterministic — the same request returns the same answer — which means fixtures are meaningful, regression suites are stable, and caching is a legitimate optimization rather than a correctness hazard. For a technical audience, this is the difference between a component you can put behind a hard SLA and one you have to put behind a retry budget.
Calibrated Confidence: The Part That Makes Automation Safe
Typed output solves the parsing problem. It does not, on its own, solve the trust problem. A label is only actionable if you know how much weight to put on it, and raw model scores are notoriously poorly calibrated — a 0.9 from an uncalibrated classifier often means nothing closer to 0.7 in the real world, which is exactly the kind of mismatch that produces confident, expensive mistakes in production.
Every answer returned by a decision engine of this shape carries a calibrated confidence, meaning the reported probability tracks observed accuracy on comparable inputs. That single property unlocks a deployment pattern that is far more defensible than a binary accept/reject rule. You set a threshold in code. Above it, the service acts instantly and autonomously — route the ticket, approve the order, pass the unit, gate the user into the fast path. Below it, the request is diverted: re-checked with more context or a heavier model, escalated to a human queue, or handled by a conservative default. The decision logic becomes explicit, tunable, and auditable, and the threshold lives next to the business rule it encodes rather than buried in a prompt.
Two model tiers make this pattern practical at different points on the cost curve. 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 about 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 and load testing. For high-frequency loops — drones, robots, simulators, machine monitoring — sessions over WebSocket handle sustained rates above 10 decisions per second without paying HTTP handshake overhead on every frame. Everything else fits comfortably inside a normal request/response cycle, and the available SDKs (TypeScript, Python, Go, Ruby, plus curl, MCP tools and webhooks) mean integration is measured in hours rather than sprints.
The practical consequence for product and ops teams is that confidence becomes a product surface. You can ship a conservative threshold on day one, watch the distribution of confidences in production, and widen autonomy as the numbers justify it — no model retraining, no prompt archaeology, just a constant in your config.
Where Decision APIs Replace Brittle Rules and Slow LLM Round-Trips
The clearest way to understand the category is through the workloads that motivated it. The first is triage and routing: support tickets, inbound leads, abuse reports, and internal requests all arrive as unstructured text that has to become a queue assignment and a priority. Hand-written keyword rules decay the moment language shifts; a chat model asked to classify is accurate enough but slow and inconsistent at volume. A typed choice plus a calibrated truth value gives routing logic a clean input and a clean escape hatch for ambiguous cases.
The second is risk and eligibility checks — fraud screening, promo-abuse detection, order and shipping decisions — where the cost of a false positive (blocked legitimate customer) and a false negative (absorbed loss) differ sharply. A calibrated score lets you place the accept and reject boundaries independently, with a review band between them, which is difficult to express with a single threshold on an uncalibrated number. Moderation and gating follow the same shape.
The third, and the one most teams underestimate, is visual and operational decisions. Because a request can carry up to 16 images or video frames alongside questions, quality control on a production line, warehouse and traffic monitoring, damage assessment, and document intake all collapse into the same call pattern: frames in, boxes and labels and scores out. Boosters for human age estimation, AI-generated image detection, face detection and recognition, OCR, depth and segmentation extend the same endpoint into domains that would otherwise require three separate vendors and a normalization layer.
The fourth is the one quietly reshaping architecture right now: agents that decide before they act. An autonomous workflow that calls tools needs a cheap, fast, deterministic gate that answers “is this action appropriate, is this input in scope, which of these five tools applies” before committing to an expensive step. Wrapping that gate in a conversational model is both slower and less predictable than routing it to an endpoint that returns a label in milliseconds. Teams already running decision logic across ticketing, fraud checks, and production-line QC often find the agent use case emerges naturally — same endpoint, same schema discipline, same confidence threshold, one more caller in the graph.
Rio biochemist turned Tallinn cyber-security strategist. Thiago explains CRISPR diagnostics, Estonian e-residency hacks, and samba rhythm theory. Weekends find him drumming in indie bars and brewing cold-brew chimarrão for colleagues.