Somewhere between a rules table that has grown into a 4,000-line if/else monster and a chat model that returns prose when you asked for JSON, most engineering teams hit the same wall: the system needs to make a small, boring, high-stakes judgment thousands of times a minute, and nothing in the stack is shaped like that job. A decision API is the missing primitive. It is an HTTP endpoint that accepts structured state plus a question you defined in code, and returns a typed answer your program can branch on immediately — no parsing, no regex, no retry loop against a stochastic text generator.
What a Decision API Is — and Why “Just Reply in JSON” Isn’t One
A decision API is a service that separates the decision from the generation. You send state and a question; you get back a value of a known type. DecisionNode, for example, exposes a single HTTPS endpoint — POST /v1/decide — where the request body carries both the state and the questions your application has already declared in its own code. State can be text, JSON, or up to 16 images or video frames. The response is schema-valid and arrives in a single pass, not as free-form text that a downstream validator has to rescue.
The important part is what comes back. Instead of a paragraph you have to coerce into structure, you get one of a small set of primitives: a choice drawn from labels you supplied, a score that places the input on an ordered scale, a truth expressed as a calibrated probability between 0.00 and 1.00, a number snapped to a grid, or a point and box describing a location inside an image. Your type definitions stop being aspirational and start being the actual contract between the model and your application logic.
Two properties make this different from prompting a chat model to “reply in JSON.” The first is determinism: the same request produces the same answer. That single guarantee changes how you test, how you replay incidents, and how you argue with auditors, because a decision becomes reproducible rather than merely documented. The second is that the schema lives in your repository, not in a prompt string maintained by whoever last touched the support macro. You version it, you diff it, you fail the build when a label disappears.
Anyone who has shipped an LLM-in-the-request-path feature knows the failure modes: prompt sprawl across five services, quietly drifting output shapes, temperature settings nobody remembers choosing, validation layers that reject 2% of traffic at 3 a.m., and tail latency that behaves like weather. Framing the problem as a decision api removes that whole class of accidental complexity. The model still does the perception and judgment work; it simply does it behind a function signature. For a technical audience, that is the entire pitch: judgment becomes an interface, and interfaces can be typed, tested, and put behind a circuit breaker.
Typed Answers and Calibrated Confidence: A Contract Your Code Can Enforce
The most underrated output type is confidence. Every answer from DecisionNode carries a calibrated confidence value alongside the decision itself, which means a confidence of 0.90 should be right roughly nine times out of ten when measured against ground truth. That is a very different thing from a raw logit or a self-reported “I’m 95% sure,” and it is what lets you write two-branch logic that holds up under load: act automatically above your threshold, and below it, either re-check with more context, escalate to a human queue, or take a conservative default path.
In practice this turns thresholds into ordinary configuration. A moderation system might auto-approve above 0.95 and auto-remove below 0.05, routing the middle band to reviewers. A shipping service might accept an address match above a cutoff and request confirmation below it. Because the underlying primitives map cleanly onto types — choice for routing labels, truth for risk probabilities, score for severity tiers, number for quantities, point and box for spatial work — you can generate the client types directly and let the compiler catch drift before a bad response ever reaches production.
Latency and cost matter just as much as correctness when the decision sits inline. DecisionNode ships two models: Flash at roughly 5 ms server-side and about 19 ms end to end at $0.035 per 1M input tokens, and MoE at roughly 9 ms server-side at $0.042 per 1M input tokens. Output tokens are free, batch discounts are available, and there is a free daily tier for development and low-volume jobs. Those numbers put a decision comfortably inside a request handler or a page-render path, which is a fundamentally different design space from wrapping a chat completion in a timeout and hoping.
Integration surface matters for teams that are not single-language. SDKs exist for TypeScript, Python, Go, Ruby, and plain curl, with MCP tools, webhooks, and integrations aimed at AI agents that need to decide before they act. A platform team can standardize on one endpoint while product squads keep working in their own runtimes, and ops teams get a uniform thing to monitor: request rate, confidence distribution, threshold breach rate, and fallback volume, all of which are far more informative dashboards than “model error rate.”
Where Decision APIs Earn Their Keep: Triage, Fraud, Gating, and Control Loops
Support and service desks are the classic starting point. A ticket arrives as text, sometimes with screenshots attached, and the system needs a choice from your queue labels plus an urgency score. Because the labels are defined in code, the routing table stops drifting from the classifier, and a calibrated truth value on “is this a billing dispute” lets you auto-route the obvious majority while sending the ambiguous remainder to a human. The same pattern covers moderation queues and intake forms where the categories change quarterly.
Fraud and promo-abuse checks are where confidence calibration pays for itself twice. Risk decisions are rarely clean binary calls, and a truth value lets you gate an order into three lanes — allow, step-up verification, or block — instead of one brittle cutoff tuned by whoever was on call the week chargebacks spiked. Order and shipping decisions follow the same shape: address quality, delivery-window feasibility, substitution approval, refund eligibility. Each is a small judgment made millions of times, and each is a terrible fit for a chat model in the hot path.
Physical operations push the requirements further. Quality control on production lines, warehouse monitoring, and traffic analysis all involve images and video frames, and the point and box outputs let you report where in the frame a defect or obstruction appeared, not just whether one exists. Boosters handle the specialized perception work — OCR, segmentation, depth, face detection and recognition, human age estimation, and AI-generated image detection — so you are not stitching five vendors together for one decision. And because agents increasingly need to decide before they act, the pattern extends naturally to tool-using systems: check the state, get a typed verdict, then call the tool.
When the decision rate climbs above roughly ten per second, a request/response loop stops being the right shape. DecisionNode supports sessions over WebSocket for control loops — drones, robots, simulators, machine monitoring — where the same deterministic, calibrated answer needs to come back on a tight cadence instead of a fresh TCP handshake. Whether the loop runs a thousand times a second on a factory floor or forty times an hour in a billing workflow, the operational story is the same: log each decision with its inputs and confidence, replay it deterministically when something looks wrong, and treat the threshold as a product decision that lives in config alongside the rest of your policy.
MichelleLLozano