Most teams building automated decisions end up choosing between two frustrating options. The first is a pile of hand-written rules: fast and deterministic, but brittle, expensive to maintain, and quietly wrong the moment reality drifts away from the assumptions baked into the conditionals. The second is a chat-style LLM prompted to “reply in JSON”: flexible, but slow, non-deterministic, prone to malformed output, and impossible to trust with a hard threshold because the confidence it reports is not calibrated to anything. A decision API exists to close that gap. Instead of asking a model to generate prose that your code then parses and hopes for the best, you send state and questions to an endpoint that returns typed, schema-valid answers in a single pass — each one carrying a confidence score your code can actually act on. That shift changes the integration surface from “parse and retry” to “threshold and proceed,” which is what production systems have needed all along.
What a Decision API Is and Why Typed Outputs Change the Integration
The mechanics are deliberately boring, which is the point. A decision API exposes one HTTPS endpoint — in DecisionNode’s case, POST /v1/decide — that accepts a state payload and a set of questions defined in code. State can be text, JSON, or media: up to sixteen images or video frames in a single request. The questions are not free-form prompts. They are declared in code with the answer types you want back, so the response shape is known before the request is sent. That contract is what separates a decision API from a general-purpose generation model.
The answer types map directly onto the decisions software actually makes. Choice returns one of the labels you supplied — the routing queue, the category, the disposition. Score returns a level on an ordered scale, useful for severity, priority, or risk bands. Truth returns a calibrated probability between 0.00 and 1.00, which is the primitive you want for fraud checks, abuse detection, and any gate that needs a numeric threshold rather than a vibe. Number returns a value on a grid, and point and box return locations inside an image, which is what makes visual quality checks tractable without a separate vision pipeline.
The critical property is calibration. Every answer comes back with a confidence value that reflects how often the model is right when it reports that level of certainty. That lets your code do something genuinely useful: act instantly when confidence clears your threshold, and fall back to a human review queue, a second pass, or a conservative default when it does not. You are no longer choosing between “trust every answer” and “trust nothing.”
Two more properties matter for engineering teams. First, the underlying model — DecisionNode describes it as a “System One” decision AI model — is deterministic: the same request returns the same answer. That makes unit testing meaningful, makes replaying production traffic a valid debugging technique, and makes audit logs defensible. Second, this is not a chat model wearing a JSON costume. A dedicated decision api is optimized for narrow, well-specified questions with typed outputs, which is precisely the shape of most operational decisions a product or ops team needs to automate.
Latency, Cost, and Throughput: What Real-Time Decisioning Actually Requires
Decision quality is only half the problem. A decision that arrives after the user has already clicked, the parcel has already shipped, or the frame has already left the camera is worthless. Latency budgets therefore drive architecture, and this is where rule engines and chat LLMs both struggle — one because rules cannot generalize, the other because generation is inherently expensive and slow.
DecisionNode offers two models with different trade-off profiles. DecisionNode Flash runs at roughly 5 ms server-side and about 19 ms end to end, priced at $0.035 per 1M input tokens. DecisionNode MoE runs at roughly 9 ms, priced at $0.042 per 1M input tokens. In both cases output tokens are free, because there are no output tokens to speak of — the response is a compact typed answer, not a paragraph. Batch discounts and a free daily tier make it practical to run evaluation suites and backfills without a separate budget conversation. For teams accustomed to paying per generated token and watching latency balloon with response length, the cost model is a meaningful change in how you size a decisioning workload.
Because answers are produced in one pass, there is no prompt chain to orchestrate, no tool-call loop to supervise, and no second request to reformat the first one’s prose into something parseable. The request contains the questions; the response contains the answers. That simplification cascades through the codebase: fewer retries, fewer timeout branches, fewer schema-validation failures at 2 a.m.
Throughput follows the same pattern. For decision loops above roughly ten decisions per second — the regime of drones, robots, simulators, and continuous machine monitoring — DecisionNode exposes sessions over WebSocket, which keeps a persistent channel open instead of paying connection overhead on every call. At lower volumes, the plain HTTPS endpoint is sufficient, and clients exist for TypeScript, Python, Go, Ruby, and curl, alongside MCP tools and webhooks for wiring decisions into agents and event-driven systems. AI agents in particular benefit from calling a decision endpoint before acting: rather than reasoning in prose about whether to proceed, the agent gets a typed verdict with a calibrated probability and a clear branch condition.
Real-World Patterns: Routing, Gating, Fraud, and Quality Control
The clearest way to understand a decision API is through the decisions teams already have to make, usually badly, with rules or ad hoc model calls. Consider ticket routing and triage. Instead of a keyword table that misroutes anything phrased unusually, you define a choice question over your queue labels and send the ticket text as state. The returned label routes the ticket; the returned confidence determines whether it goes straight to the queue or to a human sorter. Because the model is deterministic, you can replay last month’s tickets and measure exactly how routing would have changed before flipping the switch.
Fraud and promo-abuse checks follow a similar shape but lean on the truth answer type. You ask a question whose answer is a calibrated probability — is this account likely fraudulent, is this coupon likely being stacked abusively — and your code applies a threshold. Above the threshold, block or challenge; below it, allow; in the ambiguous band, route to review. Gating, scoring, moderation, and order or shipping decisions all reduce to the same pattern: define the labels or scale in code, send the context, then branch on the answer and its confidence rather than on a guess about the model’s mood.
Visual and operational use cases extend the same contract to media. Point and box answers turn a camera frame into a located defect for production-line quality control, a detected vehicle for warehouse or traffic monitoring, or a region of interest for downstream processing. DecisionNode’s boosters — human age estimation, AI-generated image detection, face detection and recognition, OCR, depth, and segmentation — cover common sub-tasks without requiring a separate model host for each. You send up to sixteen images or frames in one request and get typed answers back for all of them.
The integration discipline that makes these systems reliable is consistent across scenarios. Keep questions narrow and explicit rather than open-ended. Define the schema once, in code, and version it. Log the state, the question set, the answer, and the confidence together so that a threshold can be re-tuned later against real outcomes. Run a shadow mode before enforcement — score traffic without acting on it, compare against human dispositions, and only then move the threshold. Because the same request always yields the same answer, that shadow data is trustworthy in a way that chat-LLM samples never are, and the resulting pipeline stays fast enough to sit inline in a request path rather than behind a queue.
VeraRFlynn