Every non-trivial application eventually becomes a decision machine. Should this ticket go to billing or to infrastructure? Is this order suspicious enough to hold? Does this frame from the production line show a defect? Most teams start by hand-writing rules, then discover the rules multiply faster than the logic they replaced. The next instinct is to ask a chat model to “respond in JSON” — which works until it doesn’t, and when it doesn’t, the failure arrives at runtime as a parse error, a hallucinated label, or a confidence score nobody can interpret.
A decision API is the alternative: an endpoint that accepts a description of a situation and returns a structured verdict about it, constrained to a shape your code already declared. The pattern is simple to state and surprisingly rare in practice — the client sends state and questions, the server returns answers that validate against the schema on the first pass, every time.
What a Decision API Is, and Why Typed Beats Generated
In a decision API, the caller supplies two things. The first is state: text, arbitrary JSON, or media such as images and video frames. The second is questions defined in code — not prompt prose assembled at runtime, but declarative questions the application owns, versioned alongside the rest of its logic, with their allowed answers spelled out. The service evaluates both and returns answers in a single round trip.
On decisionnode.com, that contract is one HTTPS call: POST /v1/decide. State can arrive as text, JSON, or up to 16 images and video frames — a detail that matters more than it sounds, because most operational decisions require mixed evidence. A damaged-package claim is a photo plus an order record plus a policy question. A warehouse exception is a frame plus a scan event. Supporting both in one payload removes the glue layer most teams end up writing anyway.
The answers are where the design earns its keep. Instead of free text, the response is typed: a choice that is guaranteed to be one of your labels; a score that is a level on an ordered scale you defined; a truth that is a calibrated probability between 0.00 and 1.00; a number snapped to a grid; a point or box locating something inside an image. Nothing needs parsing, and nothing can return a label that doesn’t exist in your enum.
Compare that with the “reply in JSON” pattern that teams inherit from chat LLMs. It is a generation problem wearing a structured-output costume: the model is predicting tokens, so the schema is a strong suggestion rather than a constraint. You get drift between prompt versions, occasional malformed payloads, and confidence numbers that reflect tone rather than evidence. A decision API inverts this. The output space is closed, so the model’s job is to select within it, not to compose something plausible.
Two properties then make the results safe to wire into control flow. The first is calibration: each answer carries a confidence that is meant to be read literally, so a threshold like 0.90 is a real operating point rather than a vibe. The second is determinism: the same request returns the same answer, which makes decisions reproducible, testable in CI, and auditable after the fact. DecisionNode’s framing of this is a “System One” decision model — fast, single-pass judgment that returns several typed answers per request instead of a paragraph you have to mine.
Designing the Decision Contract: Schemas, Thresholds, and Latency Budgets
The practical work of adopting a decision API is not integration — it’s contract design. You are deciding, in code, what the answer space looks like. For a triage system that means a literal set of routing labels. For a risk check it means a scale such as clear, review, block and the evidence that separates them. For visual inspection it means a box plus a defect class. Getting those definitions tight is what makes downstream code trivial: a switch on a choice, a comparison against a truth value, a coordinate handed to a cropping routine.
From there, threshold routing becomes the core pattern. Above a confidence you trust, act automatically and log the decision. Below it, take the safe path — queue for human review, request a second frame, fall back to a conservative default. This is where calibration pays off: operators can tune the threshold against real outcomes rather than guessing, and re-tuning doesn’t require rewrites, only a constant change.
Latency and cost shape the rest. DecisionNode ships two models: Flash, at roughly 5 ms server-side and 19 ms end to end, priced at $0.035 per 1M input tokens, and MoE, at roughly 9 ms and $0.042 per 1M input tokens. Output tokens are always free, batch discounts apply, and a free daily tier covers development and smoke tests. For interactive product flows those numbers fit inside an ordinary request budget; for tight loops, sessions over WebSocket handle workloads above roughly 10 decisions per second — drones, robots, simulators, continuous machine monitoring.
Tooling matters too, because the decision layer has to live inside real repositories. SDKs for TypeScript, Python, Go, Ruby and raw curl keep the call site small; webhooks let asynchronous pipelines react without polling; MCP tools expose the same endpoint to AI agents so they can decide before acting rather than narrating an intention. Optional boosters — human age estimation, AI-generated image detection, face detection and recognition, OCR, depth and segmentation — cover the perception sub-tasks teams otherwise reinvent badly, and they return the same typed shapes as everything else.
Where Decision APIs Earn Their Keep: Routing, Risk, Quality, and Agents
The clearest wins appear wherever decisions are high-volume, low-ambiguity in structure, and expensive to get wrong. Ticket routing and triage is the canonical example: a support queue where a typed choice routes to the right team, a score captures urgency, and a truth value flags probable escalation. Because the answer is a label rather than a sentence, the escalation path is a conditional, and the audit trail records the exact confidence that drove it.
Fraud and promo-abuse checks lean on the probability type. A promo redemption can carry a calibrated truth for “this looks like a multi-account claim,” letting the system allow, challenge, or block at different bands. Order and shipping decisions — hold, split, upgrade, reroute — benefit from the same shape applied to structured JSON state. Moderation, scoring, and gating follow identical mechanics: closed label sets, calibrated confidence, deterministic replay when someone asks why a decision was made last Tuesday.
Physical operations are where the mix of modalities gets interesting. Quality control on a production line reads frames from a fixed camera and returns a box plus a defect class plus a confidence; a confident defect triggers a reject, an uncertain one triggers a second frame or a human glance. Warehouse monitoring turns shelf or dock imagery into exception flags. Traffic monitoring turns a live feed into counts and states that a control loop can consume. In each case the deciding factor is the same: the model returns typed answers with confidence, so the surrounding automation can act immediately above threshold and degrade gracefully below it.
For AI agents and automation platforms, the value is structural. An agent that calls a generative model to ask “should I proceed?” gets prose and a temperature. An agent that calls a decision endpoint gets a choice, a probability, and a confidence it can branch on — which is the difference between an agent that acts and one that narrates. The same holds for platforms replacing brittle hand-written rule trees: the rules don’t disappear, they consolidate into a small number of well-defined decision contracts that are versioned, tested, and observable like any other interface. Once decisions are an API call with a stable schema, they inherit the ordinary engineering affordances — retries, canaries, metrics, rollbacks — that business-critical logic has always needed.
