Most teams meet the problem the same way: they ask a chat model to answer a question and “reply in JSON,” then spend the next quarter writing parsers, validators, and retry loops around output that was never a contract in the first place. The failure modes are familiar. A label comes back as “urgent!” instead of “urgent.” A confidence-free boolean hides the fact that the model was guessing. A prompt tweak that fixes one case quietly breaks twelve others. And because nothing is deterministic, every bug report turns into an unreproducible anecdote.
A decision API is a different shape of interface. Instead of generating text and hoping the text parses, it accepts a state and a set of questions defined in code, and returns typed answers that conform to a schema you control. The vocabulary is deliberately small and machine-shaped: choice returns exactly one of your labels, score returns a level on an ordered scale, truth returns a calibrated probability between 0.00 and 1.00, number returns a value on a grid you define, and point and box return locations inside an image. Nothing is free-form. Nothing needs to be scraped out of prose.
That distinction matters more than it first appears. A generative model produces a distribution over tokens; a decision model like DecisionNode’s “System One” produces a distribution over the answers you actually intend to act on, then commits to one. Every answer arrives with a calibrated confidence attached, which means the response is not just an answer but an answer plus a risk statement your code can branch on.
The other property that separates a decision API from a wrapper around a chatbot is determinism. The same request returns the same answer. That single guarantee converts decision logic into something testable: golden test sets become meaningful, production incidents become replayable, and audits stop depending on a model’s mood on a given Tuesday. If a decision pipeline cannot be re-run to the same result, it is not really a pipeline — it is a coin flip with logging.
Inside the Call: State In, Schema-Valid Decisions Out in a Single Pass
At the wire level, the shape is unremarkable in the best way. A single HTTPS endpoint — POST /v1/decide — accepts a payload containing the state (text, structured JSON, or up to 16 images or video frames) alongside the questions you have defined in code. The response is a schema-valid set of typed answers produced in one pass. There is no chain of intermediate prompts, no tool-calling dance, and critically, no second round trip whose only job is to repair malformed output.
For teams evaluating options, that endpoint contract is what a decision api should look like in practice: the schema lives in your repository, the model conforms to it, and the payload is boring enough to wrap in a thin client. DecisionNode ships SDKs for TypeScript, Python, Go, and Ruby, plus raw curl for everything else, and exposes MCP tools and webhooks so orchestration layers and AI agents can call decisions without bespoke glue.
The performance envelope is worth quantifying because it changes what is architecturally possible. DecisionNode Flash returns in roughly 5 ms server-side and about 19 ms end to end, while DecisionNode MoE runs around 9 ms. At those latencies, a decision stops being a background job and becomes an inline call inside a request handler, a webhook, or a control loop. Pricing follows the same logic: $0.035 per 1M input tokens on Flash and $0.042 on MoE, with output tokens always free — a pricing model that implicitly acknowledges the output is a handful of typed values rather than a paragraph — alongside batch discounts and a free daily tier for development and low-volume checks.
Two operational details matter for production design. First, images and video frames are first-class state, so vision-dependent decisions do not require a separate pipeline stitched onto the decision pipeline. Second, when a workload needs sustained throughput above roughly 10 decisions per second — drone flight loops, robot control, simulators, machine monitoring — sessions over WebSocket avoid per-request connection overhead. The same contract, a different transport.
Calibrated Confidence: Turning Probabilities Into Branching Logic
A probability is only useful if it means something. A number labeled “confidence” that is really just a softmax artifact will happily report 0.99 on a case it gets wrong. Calibration is the property that makes confidence actionable: when the API reports 0.93, roughly 93 out of 100 decisions at that level should be correct. With that property in place, confidence stops being a decoration on the response and becomes the control signal for the entire decision flow.
The practical pattern is a threshold with an escape hatch. Above a defined confidence threshold, code acts immediately — auto-route the ticket, approve the refund, pass the unit, close the gate. Below the threshold, the system does not guess harder; it takes a defined alternative path: re-check with additional state, escalate to a human reviewer, queue the case, or fall back to a conservative default. This is where most chat-model architectures fall apart, because their confidence signal is either unavailable or uncalibrated, leaving engineers to invent arbitrary cutoffs from log probabilities and vibes.
Determinism compounds the benefit. When the same request yields the same answer, you can build a regression corpus of real production states with known-correct outcomes and measure both accuracy and calibration after every change. You can shadow-run a new schema against live traffic and diff the results before switching over. You can replay the exact request behind a bad decision weeks later, see the identical response, and trace the failure to the schema, the state, or the threshold — not to model nondeterminism.
There is a subtler architectural payoff too. Calibrated confidence lets different services apply different risk appetites to the same decision. A fraud check on a $12 order and a fraud check on a $1,200 order can call the same endpoint with the same question and apply different thresholds. The decision model stays one system; the policy stays distributed across the services that own the risk. That separation is hard to achieve when decision logic is buried inside prompt strings.
Patterns That Pay Off: Routing, Fraud, Moderation, and Machine-Speed Loops
The clearest way to understand where decision APIs fit is to look at the workloads teams already run on brittle hand-written rules or on slow, inconsistent chat-LLM calls. In support operations, ticket routing and triage maps naturally onto a choice decision (which queue) plus a score (urgency) plus a truth value (is this a billing dispute?). In commerce and risk, fraud and promo-abuse checks combine structured order JSON with free-text signals, returning a probability your checkout service can threshold in-line rather than in a nightly batch.
Order and shipping decisions — split shipment or not, which carrier, is the address deliverable — are choice decisions with hard operational consequences. Moderation is a choice decision with a score attached, where the confidence value determines whether content is blocked, allowed, or sent to a review queue. Gating and scoring show up anywhere a product needs a consistent judgment applied at scale: feature eligibility, lead quality tiers, risk bands, compliance flags.
Physical operations are where the latency profile becomes decisive. Quality control on production lines needs a verdict on a frame before the next unit moves. Warehouse and traffic monitoring need continuous judgments over video streams, which is exactly the case for WebSocket sessions above 10 decisions per second rather than request-per-decision HTTP. The same endpoint that answers a support ticket can answer a conveyor-belt inspection at camera frame rates, because the interface is typed either way.
Vision-heavy decisions get shorter when the platform already understands images. DecisionNode’s boosters cover human age estimation, AI-generated image detection, face detection and recognition, OCR, and depth and segmentation — capabilities that otherwise arrive as four separate vendor integrations and a normalization layer. A single request carrying frames plus a question like “does this frame contain a damaged package, and where?” returns a choice, a confidence, and a box in one schema-valid response. For AI agent builders, this is the missing primitive: an agent that can decide before acting, with a deterministic, auditable record of what it decided and how sure it was.
Schema Design Patterns That Survive Production Traffic
Because the questions live in code, schema design becomes a first-class engineering activity — and the quality of the answers tracks the quality of the questions. A few patterns hold up consistently across the use cases above.
Make questions narrow and labels mutually exclusive. “Is this urgent?” invites ambiguity; “Which SLA tier applies?” with three explicit labels does not. If two labels can both be true, split the question into two decisions rather than forcing the model to arbitrate. Define ordered scales explicitly. A score of 1–5 is only meaningful if the code states what each level means; the same numbers mean different things to different teams otherwise.
Send the minimum state that fully disambiguates. Decision quality degrades when irrelevant context crowds out signal — a fifty-field order object where four fields matter is worse than a focused payload. Conversely, omitting state that a human reviewer would need produces confident wrong answers, which are more expensive than uncertain ones. Log confidence next to every decision. Persisting the returned value and its calibrated confidence together turns your database into a calibration dataset for free, and makes threshold tuning an analysis task instead of a guess.
Version schemas and roll out in shadow mode. Run a new label set or scale in parallel with the existing one, compare distributions, and only then route real traffic through it. Because responses are deterministic, a shadow comparison is a genuine comparison rather than noise. Treat thresholds as configuration, not constants. Risk appetite changes by customer tier, geography, and season; a threshold read from config lets product and ops teams adjust policy without a deploy, while the decision contract stays stable underneath.
Finally, resist the temptation to over-model. A decision endpoint returns a small number of typed values; a schema demanding fifteen answers per request multiplies latency and produces a confidence value that is difficult to interpret in aggregate. Start with the two or three decisions that actually gate a workflow, measure accuracy and calibration against real outcomes, and expand only where the data justifies it.