What a Decision Engine Is — and Why a Chat Model in a JSON Wrapper Isn’t One
A decision engine is not a chatbot with a stricter system prompt. In practice, it is a service that accepts a machine-readable description of the current state of something — an inbound ticket, an order, a transaction, a frame from a camera on a production line — together with a set of questions declared in code, and returns answers drawn from a fixed type system instead of prose. The output is a plan: this label, this level, this probability, this coordinate. Nothing downstream has to parse a paragraph to find out what the system meant.
That distinction matters because the popular alternative — prompting a chat LLM to “reply in JSON” — is not a decision interface. It is text generation with a hopeful schema. The failure modes are familiar to anyone who has shipped it: keys that drift between calls, labels invented outside your enum, output that occasionally arrives wrapped in an apology, and retries that cost more latency than the decision was worth. Worse, the model’s flexibility is the problem. You do not want creativity when the question is whether to hold an order for manual review.
A purpose-built decision engine inverts the interface. Rather than asking a model to write an answer you then try to interpret, you define the answer space up front and the service is constrained to it. DecisionNode’s System One model works this way: it returns typed, calibrated decisions rather than generated text, and it does so in a single pass. Same request, same answer — which is what makes a decision layer testable at all. Determinism turns decisions into fixtures you can assert on in CI, replay against historical data, and audit months later when someone asks why a specific ticket was escalated.
Typed output also changes how teams argue about quality. A generated sentence is graded on vibes; a label is graded against a labeled set. A score is graded on rank correlation. A probability is graded on calibration — how often the 0.80 answers are actually right. That shift from subjective review to measurable error is usually the moment a prototype becomes production software, and it is the reason typed, calibrated decisions deserve to be a first-class architectural concept rather than a prompt-engineering detail.
The Contract: State In, Typed Answers Out, Confidence Attached
The interface is deliberately small. Send state, declare questions, receive typed answers — one HTTPS request to POST /v1/decide carries the whole exchange. State can be plain text, structured JSON, or up to 16 images and video frames when the situation is visual, which means the same endpoint handles a support ticket and a pallet on a loading dock without a second integration or a second vendor conversation.
The answer types map directly onto the decisions engineering teams already write code against. Choice returns exactly one label from the set you supplied — route, queue, category, verdict. Score returns a level on an ordered scale, which is what you want for severity, priority, or a quality grade. Truth returns a calibrated probability between 0.00 and 1.00, the right representation when the decision is a threshold rather than a category. Number returns a value on a defined grid. Point and box return locations inside an image, so spatial questions come back in the same schema as everything else.
Every answer carries a calibrated confidence, and that is the part that changes system design. Code can act instantly when confidence clears a threshold and take a bounded alternate path when it doesn’t: re-check with more context, escalate to a human, or fall back to a conservative default. You get a designed degradation path instead of an all-or-nothing call, and the threshold becomes a tunable in your release process rather than a mystery buried in a prompt.
The operational profile is deliberately boring. 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 about 9 ms and $0.042 per 1M input tokens. Output tokens are always free, batch discounts are available, and a free daily tier covers development. SDKs for TypeScript, Python, Go, Ruby, and curl — plus MCP tools, webhooks, and AI-agent integrations — mean the first working call is typically minutes of effort. For loops above 10 decisions per second, such as drones, robots, simulators, or machine monitoring, sessions over WebSocket remove the per-request overhead that would otherwise dominate the budget.
Where Decision Engines Earn Their Keep: Routing, Risk, and the Physical World
A decision engine pays for itself wherever a workflow currently runs on hand-written rules that have grown branches, or on chat-LLM calls that are slow and inconsistent. Ticket routing and triage is the canonical case: a support platform needs a queue assignment, a priority level, and a confidence it can trust, and it needs all three in the same tick as the webhook. A confidence-aware decision lets the platform auto-route the clear majority and reserve human judgement for the ambiguous tail, without a second model call to decide whether the first one was sure.
Risk and revenue workflows follow the same shape. Fraud and promo-abuse checks return a verdict plus a probability, so an ops team can block above 0.95, queue for review in the middle band, and let the rest through untouched. Order and shipping decisions — hold, split, expedite, reroute — become label outputs with an ordered severity attached. Moderation, gating, and scoring all reduce to the same pattern: a constrained answer space, a calibrated number, and a threshold that product and ops teams can revisit without a model retrain.
Physical operations are where the latency and the vision path matter most. Quality control on a production line needs a pass/fail/fix label on a camera frame within the cycle time, and warehouse or traffic monitoring needs counts, states, and locations at sustained rate — the kind of loop that belongs on a streaming session rather than a request-per-frame client. Boosters cover the specialised primitives such an operation would otherwise stitch together from separate vendors: human age estimation, AI-generated image detection, face detection and recognition, OCR, and depth and segmentation. Each one returns through the same typed contract, so the integration surface stays flat as scope grows.
For teams building AI agents, the decision layer plays a different but equally practical role: decide before acting. An agent about to send an email, issue a refund, or move a robot arm can call a decision engine first and get a typed go/no-go with a confidence attached, rather than reasoning its way into an irreversible action and hoping the prose was sound. That pattern — one deterministic, schema-valid call guarding each consequential step — is often the difference between an agent that ships and one that stays behind a flag.
