Most teams that ship AI-powered features eventually hit the same wall: the model returns a plausible-sounding paragraph, and somewhere downstream a parser is trying to turn that paragraph into a boolean, a label, or a number a loop can act on. That gap — between fluent language and executable decisions — is where incidents, retries, and silent failures live. A decision API is built to close it. Instead of asking a generative model to describe what it thinks, you send state and a small set of questions defined in code, and you get back typed, schema-valid answers in a single pass. No prose to parse, no regex, no “I’m sorry, I can’t help with that” hiding inside a JSON field.
The useful frame for developers and platform teams is mechanical: what actually comes back, how a request is shaped, and why calibrated confidence changes the control flow you write around the call.
What a Decision API Is (And Why It Isn’t a Chat Model Wrapped in JSON)
The difference between a decision API and a generative endpoint wearing a JSON schema is architectural, not cosmetic. A chat model wrapped in a schema still generates tokens first and constrains them afterward; the output is a guess that happens to be well-formed. A decision engine inverts that: it treats the problem as selection from a vocabulary you supply, then returns the answer with a confidence attached. DecisionNode’s System One model works this way — it returns typed, calibrated decisions rather than generated text.
The answer vocabulary is deliberately narrow, which is exactly what makes downstream code simple. Five response types cover most operational questions: choice (one label from your list), 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 inside an image). If a question can’t be expressed as one of those, it is usually two questions — and splitting it tends to be an improvement rather than a compromise.
Determinism matters as much as typing. The same request returns the same answer, which means your test suite is meaningful, incident replays are trustworthy, and a decision made in staging can be reproduced in production. Anyone who has debugged a nondeterministic model call sitting in a payment, routing, or eligibility path understands why this is a hard requirement and not a nice-to-have.
There is a governance benefit too. Questions are declared in code, reviewed in pull requests, and versioned alongside the service that depends on them. Nobody is quietly editing a system prompt in a dashboard at 2 a.m., and the decision logic shows up in the repository history that audit and postmortem processes actually expect to inspect.
State In, Typed Answers Out: Anatomy of a Decision Call
Every request goes to a single HTTPS endpoint, POST /v1/decide. You send state plus questions. State can be text, structured JSON, or up to 16 images or video frames in a single request — useful when a decision depends on a scanned form, a shelf photo, or a sequence of frames from a line camera. The questions come from your code, not from a chat transcript, so the logic is expressible in a diff and reviewable like anything else in the repo.
A ticket-routing call might send the subject, body, and account tier as state, then ask a choice question over the routing labels the team maintains, plus a truth question for “is this likely a billing dispute.” The response returns the label, the probability, and a calibrated confidence for each. An order-eligibility check is the same shape with a truth answer. A quality-control call attaches a frame and asks for a box around a defect. An agent deciding whether to act asks for a choice between proceed, ask, and escalate.
The runtime is designed to sit inside request paths rather than behind a spinner. DecisionNode Flash answers in roughly 5 ms server-side and 19 ms end to end at $0.035 per 1M input tokens; DecisionNode MoE runs around 9 ms at $0.042 per 1M input tokens. Output tokens are always free, batch discounts are available, and there is a free daily tier for development. For loops above 10 decisions per second — drones, robots, simulators, machine monitoring — WebSocket sessions replace one-shot HTTP calls and keep the round trip out of the critical path. Client libraries exist for TypeScript, Python, Go, Ruby, and curl, alongside MCP tools, webhooks, and AI agent integrations. The full endpoint contract and SDK surface are documented at decisionnode.com.
Calibrated Confidence and the Control Flow It Unlocks
A probability is only as useful as its calibration. When a model reports 0.9 and is right roughly nine times out of ten on your traffic, thresholds become engineering parameters instead of superstition. Every answer carries a calibrated confidence, which enables the pattern most teams converge on: act automatically above a high threshold, take a conservative path below a low one, and route the ambiguous middle band to a human or a second check. A 0.51 and a 0.99 stop sharing the same code path.
That three-tier shape repeats across domains. Fraud and promo-abuse checks ask truth questions about account age, velocity, and device signals, then send only the uncertain band to review. Ticket routing asks a choice question over queue labels and escalates when confidence drops. Order and shipping decisions ask about address plausibility, split eligibility, and carrier selection. Moderation, scoring, and feature gating use the same structure with different vocabularies.
Vision decisions are where the input format earns its keep. Since a request can carry up to 16 images or frames alongside text and JSON, one call can answer “is this pallet damaged?” with a box, “what does the label say?” with OCR text, and “does this frame match the reference?” with a truth value. Boosters — human age estimation, AI-generated image detection, face detection and recognition, OCR, depth, and segmentation — compose into the same request rather than demanding separate pipelines. On a production line or a warehouse floor, that is the difference between one 19 ms round trip and four stitched-together services with four failure modes.
Agent builders tend to arrive at this pattern from the opposite direction. An autonomous agent that generates a plan and then acts on it has no obvious place to put a guardrail. An agent that calls a decision endpoint before acting gets a typed answer plus a confidence and can choose to proceed, ask, or stop. The same holds for long-running loops: a drone, robot, or simulator session over WebSocket is simply a stream of decisions with an explicit budget for uncertainty.
The common thread is observability. Once every decision returns a typed answer and a calibrated number, rules stop being folklore buried in a 200-line if/else and become data you can log, chart, tune, and roll back.
Hailing from Zagreb and now based in Montréal, Helena is a former theater dramaturg turned tech-content strategist. She can pivot from dissecting Shakespeare’s metatheatre to reviewing smart-home devices without breaking iambic pentameter. Offstage, she’s choreographing K-pop dance covers or fermenting kimchi in mason jars.