Decision API: Typed, Calibrated Answers Instead of Parsed Prose

The hardest part of shipping an automated decision is rarely the model — it’s the contract. Your service needs an answer it can branch on, not a paragraph it has to interpret. A decision api inverts the usual pattern: rather than generating text and hoping something downstream can parse it, the endpoint accepts your application state plus the questions you defined in code, and returns values already shaped like the data structures your service already uses. For teams building routing, risk, or quality pipelines, that single inversion deletes an entire layer of glue code, retry logic, and defensive parsing.

What a Decision API Actually Returns

A decision API is defined less by what you send and more by what comes back. You send state — free text, structured JSON, or up to 16 images and video frames — together with questions you declared in code, to a single HTTPS endpoint (POST /v1/decide). The response is schema-valid and typed, produced in one pass rather than a chain of prompts. Five answer types cover most operational questions: choice returns exactly one of the labels you defined, such as auto-approve, escalate, or flag-for-review; score places the input on an ordered scale you control; truth returns a calibrated probability between 0.00 and 1.00; number returns a value on a grid; and point plus box return locations inside an image, which is what lets a camera frame answer a question like “where is the misplaced pallet?” without a separate vision stack.

The part that changes architecture is the confidence attached to every answer. Each response carries a calibrated confidence value, so your code can express policy directly: act instantly when confidence clears a threshold, and re-check, request more state, or take a safe path when it doesn’t. That turns “the model said something, now what?” into a deterministic branch your on-call engineers can read, reason about, and tune. Contrast this with a chat model asked to reply in JSON: you get prose that sometimes parses, key names that drift between deploys, no meaningful probability you can threshold against, and no guarantee that the same input produces the same output twice. DecisionNode’s System One model is built to return typed, calibrated decisions instead of generated text, which means the response is data first and language never.

Determinism deserves its own paragraph because it is the quiet enabler of everything else. Same request, same answer. That property lets you write unit tests against real decision logic instead of mocking a chatbot, replay logged production requests into a staging environment, and run regression suites whenever you adjust a label set or a threshold. When a decision is disputed weeks later, you can reproduce it exactly. For developers who have spent nights debugging non-reproducible model behavior, this is the difference between a feature you ship and a feature you babysit.

Replacing Rule Sprawl and JSON Prompting

Most production decision logic starts as a handful of conditionals and ends as a file nobody wants to own. Thresholds get hardcoded, exceptions accumulate, and every new edge case — a shipping address mismatch, a promo code used from a new device, a ticket written in mixed languages — adds another branch. The alternative that teams often try next is prompting a general-purpose chat model with a JSON instruction. It works in a demo and fails in production: latency measured in seconds, inconsistent output shapes, and a cost model where every token of reasoning is billed. Wiring a decision api into the pipeline splits the responsibilities cleanly — your code owns the policy, the model owns the judgment — and the judgment layer becomes a network call with a fixed contract.

Latency and cost shape which decisions you can afford to make. DecisionNode Flash runs at roughly 5 ms server-side and about 19 ms end to end, while DecisionNode MoE runs at roughly 9 ms server-side. Pricing is per 1M input tokens — $0.035 for Flash and $0.042 for MoE — with output tokens always free, batch discounts available, and a free daily tier that covers development and low-volume services. Those numbers matter because they change the economics of checking every request rather than sampling. If a decision costs fractions of a cent and returns in single-digit milliseconds, you can move validation from an asynchronous nightly job into the request path, where it actually prevents bad outcomes.

The pattern that emerges is a decision boundary your code enforces. Take promo-abuse screening: a truth answer returns the probability that the redemption is abusive. Below 0.60, auto-approve silently. Above 0.90, block and log the reason labels. In between, route to a human review queue and attach the raw state so the reviewer sees exactly what the model saw. Because the confidence is calibrated rather than merely confident-sounding, thresholds are comparable across label sets and can be tuned against historical outcomes instead of intuition. The same structure works for ticket triage assigning one of your queue labels, for order and shipping decisions choosing between hold, split, and release, and for content moderation where the cost of a false negative is very different from the cost of a false positive.

Tooling matters as much as the endpoint. Official SDKs for TypeScript, Python, Go, and Ruby, plus plain curl, mean the first integration is usually hours rather than a sprint. MCP tools and webhooks make the same decisions callable from AI agents that need to check before acting, and the deterministic contract means an agent’s tool call behaves predictably inside a loop.

Where Decision APIs Earn Their Latency Budget

Concrete deployments clarify the value better than abstract architecture. In support operations, a decision endpoint reads the ticket body and metadata, returns a choice for routing plus a score for priority, and the ticketing system assigns without an LLM ever writing a customer-facing sentence. In warehouse and traffic monitoring, frames from existing cameras go in as images and come back as point and box answers, so the same pipeline that flags a blocked aisle can flag a vehicle in a restricted lane. On production lines, quality-control checks ask a direct question about each unit passing a camera and get a typed verdict with a confidence the line controller can threshold on, holding a unit for inspection instead of scrapping it on a coin flip.

Boosters extend what the state itself can express without adding services to your stack. Human age estimation, AI-generated image detection, face detection and recognition, OCR, and depth plus segmentation can be applied as part of the decision rather than as a separate preprocessing pipeline with its own deployment, auth, and monitoring surface. That consolidation is often the largest hidden saving — one endpoint, one credential, one set of traces, one schema to validate in CI.

Throughput-sensitive systems need a different transport. DecisionNode sessions over WebSocket support loops above 10 decisions per second, which is the regime drones, robots, simulators, and continuous machine monitoring actually live in. A ground robot evaluating a dozen candidate directions per second, or a simulator stepping thousands of frames in a training run, cannot pay an HTTP round trip per question; a persistent session keeps the decision cadence aligned with the control loop while preserving the same typed answers and calibrated confidence the request/response path returns.

For product and platform teams, the practical framing is this: a decision API is not a model you host, it is a contract you depend on. You define the questions and labels in code, version them alongside the services that consume them, and treat threshold changes as reviewable configuration. DecisionNode fits that framing deliberately — one endpoint, five answer types, calibrated confidence on every response, deterministic results, and a free daily tier that lets a developer prove the integration before anyone signs off on production traffic. The teams that get the most from it are the ones that stop asking the model to explain itself and start asking it for exactly the value their code needs to branch on.