Most teams that try to put intelligence into a production system hit the same wall. The hand-written rules engine starts clean and ends up as a 4,000-line conditional that nobody dares delete. The alternative — a chat LLM prompted to “respond only with valid JSON” — works in a demo and then quietly fails in production: a hallucinated label that isn’t in the enum, a confidence score invented out of nothing, a 900 ms p99, and output-token costs that scale with every retry. Neither approach gives engineers what they actually need, which is a small, typed, reliable answer to a well-defined question at machine speed.
A decision api is the architectural answer to that gap. Instead of asking a model to generate text and then parsing it, you define your questions and allowed answers in code, POST a state payload to a single HTTPS endpoint, and receive a schema-valid typed result in one pass. The state can be plain text, structured JSON, or up to 16 images and video frames; the questions are declared by you, so the model never decides what format to return — only what the answer is. DecisionNode implements this as a “System One” decision model: same request, same answer, every time.
The result types are deliberately narrow and deliberately useful. Choice returns exactly one of your labels — no invented categories. Score returns a level on an ordered scale, which is what most ranking and prioritization work actually needs. Truth returns a calibrated probability between 0.00 and 1.00 rather than a vibe. Number returns a value on a defined grid, point returns a coordinate, and box returns a region inside an image. Six primitives cover a surprising amount of operational logic: routing, gating, scoring, moderation, defect detection, and localization all collapse into combinations of those types.
The important difference from a rules engine isn’t that the model is smarter — it’s that the interface is boring. A rules engine is also typed and deterministic, but it requires a human to enumerate every condition. A decision API keeps the determinism and the schema discipline while moving the condition-writing burden onto a model that can generalize across messy text and imagery. You get the ergonomics of a function call with the input flexibility of a perception system.
Calibrated Confidence Is the Contract That Makes Automation Safe
The single most common production failure in AI-assisted systems isn’t a wrong answer; it’s a wrong answer delivered with no way to distinguish it from a right one. Teams compensate by adding a second model to grade the first, or by writing heuristic post-filters, or by routing everything through human review and losing the automation benefit entirely. A decision API removes that work by attaching a calibrated confidence to every answer, on every type, whether it’s a choice, a box, or a probability.
Calibration means something specific: when the system reports 0.90 on a class of decisions, roughly 90 of every 100 of those decisions should be correct. That property is what lets application code branch on a number instead of guessing. Above your threshold, act immediately — route the ticket, approve the order, release the unit. Below the threshold, take the safe path: re-check with a richer payload, escalate to an ops queue, or fall back to a deterministic rule. The threshold itself becomes a tunable business parameter rather than a hidden assumption, and you can adjust it per workflow without touching the model.
This is where a decision API genuinely diverges from the “reply in JSON” pattern. A chat model’s stated confidence is generated text, correlated with fluency rather than accuracy. A calibrated output is a measurement, and measurements can be validated. You can pull the logged confidences and outcomes from a few weeks of traffic, plot accuracy against confidence bucket, and see whether the 0.8–0.9 band is behaving as advertised. If it isn’t, the fix is visible and bounded. If it is, you can justify expanding automation into a workflow that previously required a human in the loop.
Determinism compounds the benefit. Because the same request yields the same answer, every decision is reproducible in a test suite, replayable from a logged payload during incident review, and auditable months later. Teams get regression tests over decisions — feed a fixture of 200 real states, assert the expected labels and minimum confidence bands, run it in CI. That kind of test harness is nearly impossible to maintain against a generative endpoint whose output shifts between calls. It’s the difference between shipping a model and operating one.
Latency, Throughput, and Cost in Real Deployments
Decision latency determines which workflows are eligible for automation. A system that takes 700 ms per call is fine for asynchronous ticket triage and useless for a production line running at 60 units per minute. DecisionNode exposes two models to cover that range. DecisionNode Flash returns in 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 and $0.042 per 1M input tokens, for cases where the added capacity on harder inputs matters more than the extra few milliseconds. Output tokens are always free, which matters once you stop thinking of decisions as generated content and start thinking of them as small structured results.
For anything above roughly 10 decisions per second — drone flight controllers, robot arms, simulators, continuous machine monitoring — the request/response pattern itself becomes the bottleneck rather than the model. DecisionNode addresses this with sessions over WebSocket, so a control loop can stream state and receive typed decisions without paying connection setup on every frame. There’s a free daily tier for development and a batch discount for bulk workloads such as backfilling historical decisions or running overnight quality sweeps over recorded footage.
The cost model is worth comparing honestly against the alternative. With a generative endpoint, every decision consumes input tokens and output tokens, and retries on malformed JSON multiply both. With a typed decision call, output cost is zero and retries are unnecessary because the schema is enforced by the endpoint rather than requested in a prompt. For a workflow doing a million decisions a month, that difference usually lands in the range of one to two orders of magnitude, before accounting for the engineering time spent building and maintaining JSON repair logic.
Operationally, the surface area is small: one endpoint, SDKs for TypeScript, Python, Go, Ruby and plain curl, plus MCP tools, webhooks, and first-class support for AI agents that need to decide before acting. There’s no orchestration layer to run, no prompt registry to version, and no vector store to keep warm. Teams typically wire it in behind an existing service boundary and treat it like any other internal dependency — timeouts, retries, circuit breakers, and a confidence threshold as configuration.
Where Decision APIs Fit: Triage, Fraud, Quality Control, and Agent Guardrails
Ticket routing and triage is the canonical entry point. A support payload containing subject, body, customer tier and recent order history goes in; a choice from your queue labels plus a priority score comes out, with confidence attached. Above threshold, the ticket routes automatically. Below threshold, it lands in a human queue with the model’s top candidates visible. The same shape applies to moderation, where the labels are policy categories and the confidence threshold is set per category — strict for publish-blocking decisions, looser for flagging.
Risk workflows lean on the truth type. A promo-abuse check takes account age, device signals, order velocity and payment metadata, and returns a calibrated probability that the order is fraudulent; the business rule then becomes an explicit risk appetite rather than a hand-tuned scorecard. Order and shipping decisions — split shipment or hold, expedite or standard, substitute or backorder — map naturally onto choice plus score, and because the answers are deterministic, the same order replayed in an audit produces the same documented outcome.
Visual workflows use the spatial types. Quality control on a production line sends a frame and receives a box around the suspected defect plus a confidence; below threshold, the unit is flagged for manual inspection rather than scrapped. Warehouse and traffic monitoring follow the same pattern — count, classify, and localize, with point and box returns feeding downstream geometry. Optional boosters such as human age estimation, AI-generated image detection, face detection and recognition, OCR, depth and segmentation extend the base types without requiring a separate pipeline for each capability.
For AI agent builders, a decision API functions as a guardrail layer between planning and action. An agent that is about to send an email, issue a refund, or click a button can submit its intended action and the relevant context and receive a typed verdict with calibrated confidence — proceed, block, or escalate — in single-digit milliseconds. That’s a far stronger safety property than asking the same model that generated the action to also approve it, and it keeps the agent’s control flow in ordinary code that can be tested, reviewed, and replayed when something goes wrong.
Harare jazz saxophonist turned Nairobi agri-tech evangelist. Julian’s articles hop from drone crop-mapping to Miles Davis deep dives, sprinkled with Shona proverbs. He restores vintage radios on weekends and mentors student coders in township hubs.