If you have ever shipped a prompt that asks a chat model to “reply with JSON,” you already know the failure modes. The model wraps the object in prose. It invents an enum value you never defined. It returns 0.8 for a score when your scale is 1–5. It passes in staging and drifts in production, and suddenly your order-routing service is retrying a call that was never deterministic in the first place. The problem is not that language models are bad at judgment — it is that a text generator is the wrong interface for a system that needs a decision.
That mismatch is exactly what a decision API is designed to remove. Instead of asking a model to talk, you ask it to decide, and you get the decision back in a shape your code can branch on without guessing.
What a Decision API Is — and Why Typed Output Changes the Contract
A decision API is an endpoint that accepts the current state of your world, plus a set of questions you define in code, and returns schema-valid answers in a single pass. The state can be plain text, a structured JSON payload of facts, or up to 16 images and video frames. The questions are not free-form prompts written by hand at runtime — they are declarations in your codebase, which means they live in version control, get reviewed in pull requests, and can be regression-tested like anything else.
The answer vocabulary is deliberately small. A choice returns one of your labels. A score returns a level on an ordered scale. A truth returns a calibrated probability between 0.00 and 1.00. A number returns a value on a grid. A point or box returns a location inside an image. There are no nested prose fields, no “explanation” string that quietly becomes the real payload, and no schema drift between calls.
Compare that to the common workaround of calling a chat LLM with a “respond only in JSON” instruction. That pattern puts a parser between you and the model, and every parse failure becomes your incident. Typed output removes the parser from the critical path entirely: the response either conforms to your schema or the request failed, and those are two very different things to handle.
Two properties make typed decisions genuinely usable inside automation. First, every answer carries a calibrated confidence, so the number is meaningful rather than decorative — it reflects how often answers at that confidence level have actually been correct, which lets you set thresholds with intent instead of vibes. Second, the system is deterministic: the same request produces the same answer, so replaying a logged decision reproduces it exactly. That is the difference between a component you can audit and a component you can only hope about.
This is the model DecisionNode builds on — a decision engine exposed as a decision api that returns typed, calibrated decisions rather than generated text. The distinction matters most to teams replacing brittle hand-written rule stacks, where every new edge case adds another conditional, or replacing slow chat-LLM calls that answer a yes/no question with three paragraphs and a caveat.
Inside the Request: State, Questions, and Calibrated Confidence
Operationally, the interface is one HTTPS call to POST /v1/decide. You send state and questions together; you get typed answers back. Because the service carries its own judgment model rather than generating tokens, latency sits in a range that makes it viable inside a request path rather than behind a queue. DecisionNode Flash runs at roughly 5 ms server-side and 19 ms end to end, priced at $0.035 per 1M input tokens. DecisionNode MoE runs at roughly 9 ms, priced 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 and low-volume production use.
The confidence value is where most of the engineering leverage lives. A response of truth: 0.94 with matching confidence lets code act instantly; the same field at 0.58 tells the same code to escalate, re-check with more state, or take the safe path. That pattern produces decision flows that look less like a chain of if-statements and more like a control loop:
Above the high threshold, auto-approve or auto-route. Between thresholds, request a second signal — a booster, an extra image frame, a human glance. Below the low threshold, fail closed and hand off. Every branch is explicit, testable, and logged with the number that drove it, which is precisely the property compliance and post-incident review tend to ask for and hand-written rules rarely provide.
Integration paths are broad enough to avoid forcing an architecture change. SDKs exist for TypeScript, Python, Go, Ruby, and plain curl, alongside MCP tools, webhooks, and patterns for AI agents that need to decide before acting. For loops that exceed roughly 10 decisions per second — drones, robots, simulators, machine monitoring — sessions over WebSocket replace per-call HTTP overhead. And when a decision needs perception, optional boosters layer it on: human age estimation, AI-generated image detection, face detection and recognition, OCR, depth, and segmentation.
Real Workloads Where a Decision API Beats Rules and Chat Calls
The clearest fit is high-volume triage. Ticket routing and triage is a classic case: a support ticket arrives as text, and the decision API returns a choice over your queue labels plus a confidence. Confidence-aware routing means well-understood tickets skip the queue entirely while ambiguous ones land with a human — and unlike a keyword rule set, the model handles paraphrase without a ticket per synonym.
Risk and revenue decisions follow the same shape. Fraud and promo-abuse checks return a probability you can threshold; order and shipping decisions return a choice among fulfillment paths or a number on a cost or delay grid. Moderation, scoring, and gating all reduce to a typed answer plus a confidence, which is what makes them safe to automate at the edges: aggressive automation above the threshold, conservative behavior below it.
Physical operations benefit from the same contract with images in the state. Quality control on production lines can ask for a choice among defect classes and a box locating the defect in the frame. Warehouse and traffic monitoring can ask for counts, states, or classifications per frame, with vision boosters supplying depth or segmentation where the raw decision needs spatial grounding. These are workloads where a 200 ms generative call is structurally wrong and where a 5–9 ms decision call fits inside the cycle time.
The pattern that ties these together is architectural rather than industry-specific. When a decision returns in single-digit milliseconds, is deterministic, and arrives with a calibrated confidence attached, it stops being a probabilistic service you wrap in defensive code and becomes a component you can place directly in the request path — evaluated on every event, logged with its confidence, and replayed exactly when someone asks why the system chose what it chose. That is the practical difference between adding intelligence to a system and adding uncertainty to it.
Lyon pastry chemist living among the Maasai in Arusha. Amélie unpacks sourdough microbiomes, savanna conservation drones, and digital-nomad tax hacks. She bakes croissants in solar ovens and teaches French via pastry metaphors.