Most teams that need software to “decide” something still reach for one of two tools: a hand-written rule tree that starts readable and ends unmaintainable, or a chat model politely instructed to reply in JSON and trusted to comply. A decision API rejects both approaches. It treats a decision as a structured data type with its own schema, its own confidence value, and its own deterministic behavior — so the calling code stops parsing prose and starts branching on values it can verify.
What a Decision API Is — and Why It Isn’t a Chat Model Wrapped in JSON
A decision API is an endpoint whose contract is a typed answer, not generated text. The caller sends state — plain text, structured JSON, or up to sixteen images or video frames — alongside questions that are defined in code rather than improvised in a prompt. One HTTPS call to a single endpoint (in DecisionNode’s case, POST /v1/decide) returns schema-valid answers in one pass. There is no completion to trim, no markdown fence to strip, no retry loop hoping the model returns valid JSON this time.
The distinction matters more than it sounds. Prompting a chat model to “reply only in JSON” produces output that is usually parseable, occasionally truncated, and never guaranteed. It also produces a different answer to the same question on Tuesday than it did on Monday, which means nobody can write a meaningful test against it. A purpose-built decision api is deterministic: the same request returns the same answer. That single property is what makes decisions unit-testable, replayable from a log, auditable during a postmortem, and safe to run in a CI regression suite. DecisionNode is built as a “System One” decision model — a fast, direct decision path rather than a deliberative text generator — precisely so that determinism isn’t compromised for fluency.
Cost and latency follow the same logic. A chat model bills you for output tokens it generates to explain itself; a decision model returns a small typed value and should never need to narrate. That changes the economics of putting a model in a hot path. Instead of a slow, inconsistent call tucked behind a feature flag, you get a component that behaves like any other service dependency: bounded latency, stable output shape, predictable spend. The mental model shifts from “call the AI and clean up the mess” to “call the decision service and trust the type.”
The Five Primitives: Choice, Score, Truth, Number, Point and Box
Decision APIs earn their keep by being opinionated about the answer shapes they return, because generic objects force every caller to reinvent validation. The primitives that cover most production decisions are narrow and well-defined.
Choice returns one of your labels — the routing queue, the category, the eligible plan, the moderation action. You define the label set in code, so the response can only be a member of that set. Score returns a level on an ordered scale, which is what you want for severity, priority, or a star rating where “adjacent” answers are meaningfully closer than distant ones. Truth returns a calibrated probability between 0.00 and 1.00 — the is-this-fraud, is-this-duplicate, does-this-photo-show-damage question. Number returns a value on a grid, useful for quantities and estimates. Point and box return locations inside an image, which is how a decision about a photograph becomes actionable rather than merely descriptive.
The underrated piece is that every answer carries a calibrated confidence, not a softmax score dressed up as certainty. Calibration means the number behaves like a probability you can budget against: among answers reported at 0.90, roughly nine in ten should be correct. That turns confidence into a policy lever. Code checks the answer against a threshold and acts immediately above it; below the threshold it re-checks, escalates to a human, requests more state, or takes a documented safe path. Without calibration, a threshold is a magic number someone guessed. With it, the threshold is a measurable trade-off between automation rate and error rate that a product team can tune deliberately.
Because answers are schema-valid by construction, validation code shrinks dramatically. There is no defensive parsing branch, no partial-response fallback, no LLM-specific error taxonomy. The decision layer returns a decision; the shape is guaranteed; the confidence tells you what to do with it.
Putting It in Production: Latency, Sessions, and Real Decision Loops
Latency is the constraint that decides where a decision API can live. DecisionNode Flash runs at roughly 5 ms server-side and 19 ms end to end at $0.035 per 1M input tokens; DecisionNode MoE runs at about 9 ms at $0.042 per 1M input tokens. Output tokens are always free, which is the correct pricing posture for a system whose outputs are deliberately tiny. Batch discounts and a free daily tier make it practical to evaluate against real traffic before committing.
Integration surface is deliberately boring: SDKs for TypeScript, Python, Go, Ruby and plain curl, plus MCP tools and webhooks for teams wiring decisions into agent workflows — an agent calls the decision endpoint before acting, rather than reasoning its way into an action. For loops that exceed roughly ten decisions per second, WebSocket sessions hold a persistent connection instead of paying a round trip per call. That’s the regime where decision APIs get interesting: drones, robots, simulators, and continuous machine monitoring can’t afford conversational latency or conversational variance.
Boosters extend the input side without changing the contract — human age estimation, AI-generated image detection, face detection and recognition, OCR, depth, and segmentation. A quality-control station on a production line can ask whether a wrap is seated correctly and get a box back; a warehouse system can ask whether a pallet is staged in the right bay; a traffic monitor can score congestion level on an ordered scale. Ticket routing and triage, fraud and promo-abuse checks, order and shipping decisions, moderation, scoring, and gating all reduce to the same pattern: define the question in code, send the state, branch on the typed answer and its confidence.
The operational discipline that makes this durable is logging every request-response pair with its confidence, sampling below-threshold decisions for human review, and replaying those samples as regression fixtures. Determinism makes the replay meaningful; calibration makes the review targeted; typed outputs make the whole loop something a platform team can own rather than a prompt someone is afraid to touch.
A Dublin cybersecurity lecturer relocated to Vancouver Island, Torin blends myth-shaded storytelling with zero-trust architecture guides. He camps in a converted school bus, bakes Guinness-chocolate bread, and swears the right folk ballad can debug any program.
