A familiar pattern has emerged in production systems: a service needs a judgment — is this ticket urgent, does this image show a defect, is this order likely fraudulent — so the team wires up a chat model, asks it to “reply in JSON,” and then spends the next quarter hardening the parser. The output is a string that may or may not match the schema, the confidence field is whatever the model claims to feel, and the same input can produce two different answers ten minutes apart. That gap between unstructured generation and operational decision-making is exactly what a decision api is built to close. Instead of prompting for text and hoping the structure holds, you send state and a question, and you get back a typed answer your code can branch on immediately.
The distinction matters for anyone shipping automation. A decision endpoint is not a smaller chatbot; it is a contract. The questions are authored in code, the response types are fixed, and every answer arrives with a calibrated confidence attached, so the calling service knows not just what the model concluded but how much to trust it before taking an irreversible action.
What a Decision API Returns: Types Over Text
A decision call has two halves. The first is state: the evidence the system should reason over. Depending on the domain, that state might be a block of text, a structured JSON payload, or up to 16 images or video frames from a camera or upload pipeline. The second half is the question set, defined by the developer in code rather than improvised in a prompt. Both are sent to a single HTTPS endpoint, POST /v1/decide, and the full answer comes back in one pass.
The response vocabulary is small, and that is deliberate. A choice answer resolves to one of the labels you supplied — useful for routing, triage, and classification. A score answer lands on an ordered scale, which suits severity, quality grading, and risk bands. A truth answer is a calibrated probability between 0.00 and 1.00, the appropriate shape for bets you intend to aggregate or threshold later. A number answer snaps to a grid, keeping values discrete and comparable across calls. Point and box answers return locations inside an image, so spatial questions — where is the damage, where is the pallet — come back as coordinates rather than prose descriptions of coordinates.
For a technical audience, the practical value is that downstream code stops being defensive. There is no JSON.parse wrapped in a retry loop, no schema validator bolted on after the fact, no fallback branch for “the model wrote a sentence instead of a value.” The response is already validated against the shape you declared, so the integration work collapses to mapping fields onto business logic.
DecisionNode’s model is described as a “System One” decision model, which is a useful framing: it is tuned to produce a conclusion about a specific question, not to explain itself at length. The confidence attached to each answer is calibrated, meaning a stated 0.90 should behave like a 0.90 across many calls. That property is what makes threshold logic trustworthy — and it is the thing that ad-hoc “reply in JSON” prompts almost never provide.
Designing the Decision Contract: State, Questions, and Confidence Gates
Once answers are typed, the interesting engineering moves upstream into question design. A good decision contract names the labels precisely, keeps the answer set small enough to reason about, and pairs each question with the action the system will take at each confidence level. Teams typically find that two or three well-chosen questions outperform a single sprawling one, because each answer can be gated independently.
The confidence value is the hinge. Above a threshold, code acts instantly and autonomously — auto-route the ticket, approve the refund, release the package down the line. Below the threshold, the same code takes a safe path: escalate to a human, request a second frame, re-check with additional state, or hold the item. This two-tier pattern converts a probabilistic model into a deterministic control flow, and it is the reason calibrated confidence matters more than raw accuracy in most operational settings. A model that is right 95% of the time but cannot tell you which 5% it is unsure about is harder to deploy than one that flags its own uncertainty.
Consider a support queue. State is the ticket text; the question set asks for a category as a choice, a priority as a score, and a spam likelihood as a truth. Routing runs on the category, SLA clocks start on the priority, and anything below the confidence threshold lands in a review lane. The same structure shows up in fraud and promo-abuse checks, where a probability answer feeds a rules layer that already exists, and in moderation pipelines where a single label determines whether content publishes, queues, or blocks.
Image-heavy domains benefit from the same discipline. Quality control on a production line can ask for a pass/fail choice plus a box around the defect; warehouse and traffic monitoring can ask for counts and classifications directly from frames. When a question needs extra signal, boosters extend the state without changing the contract — human age estimation, AI-generated image detection, face detection and recognition, OCR, depth, and segmentation. The questions and answer types stay stable while the underlying perception gets sharper.
Latency, Determinism, and Loops: Running Decisions in Production
Decision endpoints earn their place in an architecture when they are fast enough to sit on the hot path and predictable enough to test. DecisionNode publishes two models along that curve. DecisionNode Flash runs around 5 ms server-side and roughly 19 ms end to end, priced at $0.035 per 1M input tokens. DecisionNode MoE runs around 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 evaluation. For teams cost-modeling a high-volume gate — order and shipping decisions, scoring, access gating — the absence of output-token charges removes a variable that usually dominates chat-LLM budgets.
Determinism is the other production requirement. Identical requests return identical answers, which means the decision layer can be unit tested, replayed from logs, and regression-checked when question sets change. Anyone who has tried to test around a nondeterministic chat completion knows how much engineering time that property saves.
Throughput shapes the transport choice. For request/response patterns, one POST per decision is the norm, and SDKs for TypeScript, Python, Go, Ruby, and curl cover most stacks, with MCP tools and webhooks for agent and automation workflows. When the workload becomes a loop — drones, robots, simulators, machine monitoring — and exceeds roughly 10 decisions per second, sessions over WebSocket keep the channel warm instead of paying connection overhead per call. This is also where the “decide before acting” pattern for AI agents becomes practical: an agent can call the decision endpoint as a policy check ahead of each tool invocation, using the returned confidence to proceed, retry, or hand control back to a human.
A sensible rollout follows the data. Start by replacing the brittle hand-written rule blocks that already exist, since those have known inputs, known outputs, and a measurable error rate. Instrument the confidence distribution before tightening thresholds, then shift the safe-path actions from human review to automated re-checks as the distribution settles. Teams that treat the decision contract as versioned code — questions, labels, thresholds, and fallbacks reviewed like any other interface — get the compounding benefit: every added question improves a shared decision layer rather than spawning another bespoke prompt.
Beirut architecture grad based in Bogotá. Dania dissects Latin American street art, 3-D-printed adobe houses, and zero-attention-span productivity methods. She salsa-dances before dawn and collects vintage Arabic comic books.