Most teams that need a model to make a call — is this ticket urgent, is this order fraudulent, is this frame defective, which queue should this request land in — start the same way: a chat model, a system prompt that says “reply in JSON,” and a parser that prays. It works in a demo. Then it hits production, where the model occasionally adds a sentence before the JSON, hallucinates a label that isn’t in your enum, returns 0.7 where you expected a boolean, or silently changes its answer between two identical requests. The failure isn’t dramatic, which is exactly the problem: it’s a bad value in a downstream system that nobody notices until a batch of orders ships to the wrong address.
A decision api inverts that contract. Instead of asking a model to write text you then have to interpret, you declare the decision itself in code — the labels, the scale, the question — and receive a typed answer that already conforms to your schema. There’s no prose to parse and no post-processing layer to maintain. This is the model DecisionNode builds around: a “System One” decision engine that returns typed, calibrated decisions rather than generated text.
From Text Generation to Typed Decisions: What a Decision API Actually Returns
The core distinction is the output type. A general-purpose chat model returns a string; the caller is responsible for turning that string into something a program can branch on. A decision API returns the branch itself, in one of a small set of well-defined shapes. DecisionNode supports six: choice (exactly one of your labels, never an invented seventh option), score (a level on an ordered scale, useful for severity or priority), truth (a calibrated probability between 0.00 and 1.00), number (a value constrained to a grid you define), point and box (locations within an image).
That last point matters more than it first appears. When the answer space is a grid or a label set, you’re not just getting cleaner data — you’re getting a bounded error surface. A number on a grid can’t come back as “approximately 1,200–1,500 depending.” A choice can’t come back as “probably billing, but maybe account access.” The model has to commit, and the schema guarantees the commitment is expressible in your types.
The second half of the contract is calibration. Every answer carries a confidence value, and calibrated means the number is meant to be read literally: among answers the engine marks at 0.90, roughly nine in ten should be correct. That is a different claim from the softmax scores you get from a classifier trained on a different distribution, or from the self-reported confidence of a chat model, which tends to cluster near the top of the range regardless of whether it’s right.
For a technical audience, the practical consequence is that confidence becomes a control-flow primitive. Code can act automatically above a threshold, re-check or route to a human below it, and tune that threshold against real error budgets rather than gut feel. A ticket router that auto-assigns at 0.95 and queues for review at 0.70 is a defensible engineering design; a router that trusts a string match on a JSON blob is not.
Designing the Contract: State, Questions, and a Single HTTPS Endpoint
The request shape for DecisionNode is deliberately narrow: a single POST /v1/decide endpoint takes state plus the questions you’ve defined in code, and returns answers in one pass. State can be plain text, structured JSON, or up to sixteen images or video frames. The questions are declared by the developer — the label set, the ordered scale, the grid — rather than described in a prompt and hoped for.
That distinction is worth dwelling on because it’s where most “LLM in production” debt accumulates. When the decision lives in a prompt, the specification of the decision is a string that drifts: someone edits a sentence, someone else adds an example, and the behavior changes with no diff review worth the name. When the decision lives in code — an enum, a scale, a schema — it’s versioned, reviewed, tested, and diffable like any other interface. The model becomes an implementation detail behind a stable contract.
Because the endpoint is one HTTPS call returning schema-valid answers, integration is unremarkable in the best way. DecisionNode ships SDKs for TypeScript, Python, Go, Ruby, and curl, plus MCP tools, webhooks, and support for AI agents that need to decide before acting. For multimodal decisions — inspection frames, document images, screen captures — boosters extend the base model with specialized capabilities: human age estimation, AI-generated image detection, face detection and recognition, OCR, and depth and segmentation. These aren’t separate pipelines to orchestrate; they’re capabilities the same endpoint can draw on when the decision needs them.
Determinism rounds out the contract. Same request, same answer. That sounds like a baseline expectation until you’ve tried to write a regression test against a chat model, at which point it becomes the feature that lets you assert on decisions at all, seed reproducible fixtures, and investigate a production incident by replaying the exact state that produced it.
Latency, Determinism, and Thresholds: Running Decisions in Production Loops
Inference economics decide whether a decision API can sit on a hot path. DecisionNode offers two models. DecisionNode Flash runs at roughly 5 ms server-side and about 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 — a sensible arrangement for a product whose outputs are a label, a score, or a probability rather than paragraphs — with batch discounts available and a free daily tier for development and evaluation.
Those numbers put decisions inside request budgets that text generation can’t reach. A checkout flow can run a promo-abuse check inline rather than in a nightly job. An order and shipping decision can resolve routing before the confirmation page renders. A moderation gate can sit in front of content publishing without adding a visible stall. Product and ops teams get something rarer than accuracy: a decision they can afford to make on every event instead of sampling and reconciling later.
Above roughly ten decisions per second, per-decision HTTP overhead starts to dominate, so DecisionNode exposes sessions over WebSocket for sustained loops — drones, robots, simulators, machine monitoring. This is the regime where a decision API stops looking like a smarter classification endpoint and starts behaving like a control primitive: a monitoring loop on a production line scoring quality frames continuously, a warehouse system classifying inbound scans, a traffic monitoring agent evaluating intersections frame by frame, each decision carrying a confidence that determines whether the loop acts, escalates, or waits for another sample.
Threshold design is where all of these threads converge. With typed outputs and calibrated truth values, an agent loop can decide before acting and degrade gracefully: proceed confidently when the answer clears the bar, request more context when it doesn’t, and fall back to a deterministic safe path rather than guessing. Over time, replaying logged decisions against new thresholds — without re-sampling, because the engine is deterministic — turns threshold selection into measurement instead of intuition. Teams migrating off brittle hand-written rule stacks or slow, inconsistent chat-model JSON calls usually find that the harder work isn’t the integration; it’s going back through their rule set and realizing how many of those rules were unstated assumptions the model now has to be held to, one typed answer at a time.
Stockholm cyber-security lecturer who summers in Cape Verde teaching kids to build robots from recycled parts. Jonas blogs on malware trends, Afro-beat rhythms, and minimalist wardrobe hacks. His mantra: encrypt everything—except good vibes.