Over the past two years, engineering teams have wired chat models into production systems and then built an entire reverse-engineering layer around them: JSON mode, schema hints, retry loops, and a parser that fails quietly at 3 a.m. That pattern is tolerable for drafts and summaries. It falls apart wherever a single wrong value triggers a refund, releases a shipment, or sends a robot down the wrong aisle.
A decision API inverts the interaction. Instead of asking a model to reason in natural language and praying the result can be parsed, you send state and a precisely defined question, and the endpoint returns a value in a type your code already understands — along with a confidence score that tells you whether to trust it. For developers, product teams, and ops engineers, that distinction reshapes everything from error handling to deployment review.
What a Decision API Is, and Why “Reply in JSON” Prompts Break Down
A decision API is an HTTPS endpoint that accepts a representation of state — plain text, structured JSON, or image data — together with a question whose answer space was fixed in advance. The response is not prose. It is a typed, schema-valid value: one label from a set you defined, a level on an ordered scale, a calibrated probability between 0.00 and 1.00, a number on a grid, or a location expressed as a point or bounding box inside an image.
The contrast with prompt-based extraction is structural, not cosmetic. When you ask a general chat model to “reply only in JSON,” you own the parsing, the validation, the retry logic, and the tail latency those retries create. You also inherit a system that answers differently on Tuesday than it did on Monday for identical input, which makes regression testing close to meaningless. A deterministic decision endpoint removes that class of bug entirely: the same request produces the same answer, so a decision can be committed to a test fixture, replayed during an incident, and diffed across model upgrades.
The second problem is what “confidence” means. A chat model that says it is highly confident is producing lyric, not measurement. A calibrated confidence is verifiable: when a truth-type decision reports 0.82, decisions at that level should hold up roughly 82% of the time across a large sample. That property is what makes thresholding possible in production. Code can act instantly above a cutoff, escalate to a human between two cutoffs, and take a known-safe path below the lower one — all without a human reading a sentence to guess whether the model was serious.
There is a workflow consequence too. Because questions live in code rather than in a prompt template, the answer schema becomes a contract you can version, review in a pull request, and validate at startup. Product managers argue about label sets instead of adjectives. When a decision changes, the diff shows exactly which question definition moved.
The Request Lifecycle: State In, Calibrated Decisions Out
At the wire level, the interaction is deliberately small. A single POST carries the state payload and a list of questions, each declaring its expected answer type. DecisionNode implements exactly this shape: one endpoint, POST /v1/decide, where state may be text, JSON, or up to 16 images or video frames, and questions are defined in code. The full contract and SDK examples live at decisionnode.com, and the practical takeaway is that a complete integration is a few dozen lines rather than a prompt-engineering project.
Each declared type maps to a real programming construct. Choice returns one of your labels, which is a tagged union or enum in most languages. Score returns a level on an ordered scale — useful for severity, urgency, or quality grades. Truth returns a calibrated probability you can threshold. Number returns a value on a grid, avoiding the absurd precision that plagues free-text extraction. Point and box return image coordinates, which is how visual inspection tasks avoid a separate detection stack.
Performance is the part most teams underestimate. 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, priced at $0.042 per 1M input tokens. Output tokens are always free, which matters because decisions are tiny outputs driven by large inputs — image frames, ticket bodies, order payloads. Batch discounts and a free daily tier make cost modeling straightforward before you commit to volume.
The confidence value enables a three-branch control flow that is easy to reason about: act above the high threshold, re-check or queue for review in the middle band, and take the safe path below. A re-check can mean sending more state — a second video frame, additional order history — rather than asking the same question again and hoping for a different answer.
Integration surface extends beyond the request itself. SDKs exist for TypeScript, Python, Go, Ruby, and curl; MCP tools expose decisions to AI agents that must decide before acting; webhooks push results into asynchronous workflows. For control loops above 10 decisions per second — drones, robots, simulators, machine monitoring — sessions over WebSocket avoid per-call overhead. Optional boosters such as human age estimation, AI-generated image detection, face detection and recognition, OCR, depth, and segmentation cover the specialized sub-tasks that would otherwise require separate vendors.
Decision APIs in Production: Routing, Risk, Quality, and Agent Gating
Ticket routing and triage is the most common first deployment. A choice-type question maps a ticket to an owning queue, a score expresses urgency, and the confidence decides whether it flows straight through or lands with a human. Ops teams typically arrive at this after years of maintaining hand-written keyword rules that break whenever a product name changes. The replacement is a maintained label set plus thresholds, and the migration is incremental because confidence gives you a safe fallback from day one.
Risk work follows the same shape but leans harder on calibration. Fraud checks, promo-abuse screening, and account gating are fundamentally threshold problems: a truth-type decision at 0.93 can block automatically, while 0.71 routes to manual review. Because the probability is calibrated rather than rhetorical, thresholds can be tuned directly against chargeback and abuse outcomes instead of tuned by feel. Multiple questions in one request — eligibility, abuse likelihood, and account age signal — collapse what used to be three round trips into one.
Order and shipping decisions, moderation, and release gating fit the same pattern. So do physical operations. Quality control on production lines uses point and box answers to flag defects in captured frames; warehouse and traffic monitoring use image state at the edge, with WebSocket sessions handling the sustained rate. A common illustrative case: a fulfillment team inspecting inbound pallets sends one frame per pallet, receives a choice of pass or reject plus a calibrated confidence, and only escalates the middle band to a human inspector — cutting review volume sharply while keeping a documented audit trail of every automated call.
Agent builders have a distinct need: an agent that acts before checking is an agent that causes incidents. Exposing a decision as an MCP tool or a plain HTTP call gives the agent a hard gate — retrieve facts, decide, then act — with the confidence value determining whether the agent proceeds, gathers more evidence, or hands control to a human. Product and platform teams get the same benefit when replacing slow, inconsistent chat-LLM calls inside deterministic backend services that never wanted a conversation in the first place.
Isabella Mendoza