# Hanzo Kai — One intelligence. Every modality. Every decision. > Calibrated probability decision model for discrete choices. Get confidence scores per option with zero output token cost via one API call. Kai 1 · Multimodal Decision Intelligence # See. Hear. Understand. When the answer has a type, Decide. One unified intelligence. Text, vision, audio, video, code, and system state evaluated into calibrated probabilities across your options — fast when it can be, deep when it needs to be. [Get decisions](#api)[Research access →](https://hanzo.ai/research-access?track=kai) [Read the docs →](https://docs.hanzo.ai/docs/decisions) POST /v1/decisionsexample statedeploymentproductiontestspassingsecurity_reviewpending passed rollbackready question · choiceShould the deploy continue? continue .17review .76stop .07 answerchoice · review · p .76usage.output_tokens · 0 Change the review. Only the answer moves — Kai evaluates the options, it does not write a reply.TypedThe answer space is known in advance. CalibratedA probability on every option. 0Output tokens generated. Reading the Decision Suite's research runs from api.hanzo.ai Clock.Decisions ## Decisions in a flash. One Kai decision on GPU, on your own hardware with Enterprise: cached, through the runtime, and served over HTTP. Beside it, the Decision Suite's tasks Kai wins, Kai's figure against the Jev's. Drawn to scale. Reading the decision timings from api.hanzo.ai [The Decision Suite and its timing runs →](https://hanzo.ai/benchmarks#decision-suite) Different computation for different jobs ## Language models write. Kai decides. Ask a writer for a decision and you get prose, then a parser, a retry and a guess at the schema. Ask Kai and the answer is already the type you asked for. generateexample “Based on the information provided, the mostappropriate action would probably be to escalate,although there are some considerations…” → parse → validate → retry → normalize decideexample "next": { "type": "choice", "choice": "escalate", "probabilities": { "escalate": 0.94, "resolve": 0.06 }} usage.output_tokens · 0 Zen is part of the same system. Reason with Zen; decide with Kai. Typed answers ## Ask in the shape of the answer. Three question types. Each answer carries its probabilities, so software knows how sure to be. choiceexample Which tool should run? search .81browser .14none .05 noulexample Is this request safe to run? false .97true .03 scoreexample How severe is the incident? 0 .011 .022 .063 .184 .515 .22 Sensitivity ## See what changes the answer. A bounded decision has edges. Move the evidence or the risk and watch the answer cross the line — and read the smallest change that would cross it. Know what would change the answer before you act on it. what flips the decisionexample continue .22review .78 what flips it+10 points of evidence turns review into continue. evidence completeness55% risk50% Incremental ## Only what the evidence touches recomputes. Switch a source off. The decisions that read it wake and settle again; the rest stay quiet. Compute follows uncertainty. vehicle.readiness@3example · scripted evidencecamera CAN audio SysML simulation replay Example: a scripted scenario, not model output. Switch a source off and only the decisions that read it run again. Decision Programs ## Decisions become programs. One question becomes many: evidence, code, Kai’s questions, Zen’s prompts, solvers and human approvals, wired into a versioned graph. The program library ships today. Sending a whole program in one call is being built. vehicle.readiness · a programexample evidence camera · CAN · SysML · simulation │kai fault bearing .91kai readiness no-go .96kai severity critical .86 │zen write the inspection plansolver schedule the bay │policy severity = critical → human_approvalhuman approve Reproducible ## Every decision leaves a record. Each answer names the checkpoint that gave it and a hash of the state it saw. Run the same state again and you know you asked the same question of the same model. Decision Packages bundle a program’s whole run — inputs, answers, probabilities, policy and result — for replay. The library ships today. POST /v1/decisions → the responseexample routing.checkpointthe checkpoint that answeredrouting.extrapolatedwhether the state ran past what it was trained to readrouting.sha256the hash of its weightsrouting.calibrationthe calibration appliedstate_hashthe hash of the state it readanswerseach answer, with probabilitiesusage.output_tokens0 Authority ## Kai recommends. Policy governs. A probability is advice. Your policy, written as code, keeps the authority — and a person signs where it says one must. kai · recommendsexample Allow the transfer? allow .94deny .06 policy · governsexample if amount > thresholdthen human_approval = required deterministic. no probability. final authorityexample HUMAN APPROVALrequired Kai informed it. It did not decide it. Results ## Kai beside Jev, on the same questions. Reading Kai's research runs from api.hanzo.ai Calibration ## Confidence you can act on. “Approve” at .51 and “approve” at .99 pick the same option. Only one should ship without a second look — so a decision model has to be right about how sure it is. .51 → .99The same choice, two different decisionsAn example: a probability is only useful if it means what it says. 0output tokens ## The answer is the distribution. There is nothing to generate. [Pricing →](https://hanzo.ai/pricing) Agents ## Agents need decisions more often than prose. Most of an agent’s steps are choices among known options. Each is one call, with its probability, and no prose to parse. Hanzo Dev asks Kai where to fix, what to do next and whether the work is done.[Hanzo Dev →](https://hanzo.ai/dev) an agent’s loopexample observedecide which tool? kaiactdecide which context? kaiactdecide which model? budget? kaidecide done, or keep going? kai One system ## Reason with Zen. Decide with Kai. Neither replaces the other. Zen writes what could be done; Kai says what should be. zen · then kaiexample zen write the migration plankai should the migration proceed? zen generate possible fixeskai choose the fix that meets the constraints enso · in progressexample request ↓enso what kind of computation? ├─ generate → zen └─ decide → kai Kai inside Enso is being built. Status ## What ships today. The model and the call are live. The decision plane around them is being built — in the open, and marked as such. KailiveUnified multimodal decision intelligence: text, vision, audio, video and code with adaptive reasoning (auto, fast, deep). The model id is kai. Vision, audio, video and adaptive reasoning: Kai-1.7 target. POST /v1/decisionslivechoice, noul and score questions, answered with calibrated probabilities. Observe and decideliveHold a multimodal state once with observe; decide over it later by handle. Decision ProgramslibraryVersioned graphs of questions, code, solvers and approvals. Decision Packages and policylibraryA run’s reproducible record, and the rules that govern it. Programs on the wirein progressSending a whole program in one call. Kai inside Ensoin progressEnso sending the decide-shaped part of a request to Kai. Open weightsnot yetThe Kai weights are closed; served via API and dedicated deployment. API ## One endpoint for decisions. Name the questions, define criteria, pass multimodal state. Kai evaluates the evidence and returns calibrated probabilities for every option — fast by default, deepening compute only when ambiguity requires it. Kai-1.7 target Set reasoning to "auto" (default), "fast", or "deep". In the SDKs it is post_decisions in Python and postDecisions in TypeScript. Hold a state once with observe, then decide over it by handle.[How to use it →](https://hanzo.ai/kai/guide)[The architecture →](https://hips.hanzo.ai/docs/hip-1332-kai-the-decision-model) POST /v1/decisionsexample { "model": "kai", "reasoning": "auto", // Kai-1.7 target "state": { "evidence": "sensor.vibration_peak_840hz", "telemetry": { "bearing_temp_c": 94.2, "rpm": 3600 }, "image": "data:image/webp;base64,..." // Kai-1.7 target }, "questions": { "status": { "type": "choice", "criteria": { "nominal": "vibration within threshold", "inspect": "harmonic anomaly detected", "shutdown": "immediate bearing failure risk" } } }} 200 OKexample "answers": { "status": { "type": "choice", "choice": "inspect", "probabilities": { "nominal": 0.02, "inspect": 0.94, "shutdown": 0.04 }} },"usage": { "input_tokens": 142, "output_tokens": 0 } Architecture ## Modular encoders. One decision core. Kai organizes specialized modular encoders into a unified decision engine. Long text (up to 32,768 tokens) and structured telemetry are evaluated natively today; high-resolution imagery, acoustic signals, and video frames project into the unified latent space as the Kai-1.7 target. The functional parts list: • Multimodal Decision Core (~850M architecture): High-capacity decision encoder with 32,768-token reach (YaRN stretched from 1,024 trained base), scoring questions and evidence with invariant option scoring.• Vision Encoder (~170M params, Kai-1.7 target): Spatial feature extraction for screenshots, diagrams, UI layouts, and physical component inspections.• Audio Encoder (~300M params, Kai-1.7 target): Continuous acoustic representation capturing speech intent, call center audio, and sensor acoustic harmonics.• Video Processor (Kai-1.7 target): Multi-frame temporal sampling bridge projecting dynamic scene progressions without token bloat.• Latent Fusion Bridge (~60M params, Kai-1.7 target): Cross-attention adapter projecting multimodal latents into Kai's decision geometry.• Decision Core (shipping): Parallel factorized candidate scoring over typed schemas (choice, noul, score) with zero option-option coupling (flip.order = 0.0000).• Adaptive Reasoning Engine (Kai-1.7 target): Dynamic compute scaling via reasoning: "auto". Sub-millisecond decisions on GPU, with automated refinement when ambiguity is high.• Nio policy (experimental): Decides from the consequences a caller states, and escalates to a person when it cannot count them. It enforces its rule; it does not repair consequences read wrongly. An earlier "zero dominated actions" figure is withdrawn: it was not a measurement of Kai. Multimodal decision architecture: ~850M parameters, sub-millisecond p50 on GPU, $0.021 / MTok base input, zero output tokens billed. kai · unified architectureexample inputs text · vision · audio · video · code · state │encoders text (320M, 32K) · vision (170M) · audio (300M)bridge latent fusion (~60M cross-attention) │core decision heads (choice · noul · score)adaptive reasoning: auto | fast | deepguard built-in policy & harm sensitivity │output calibrated distribution · 0 output tokens vision · audio · video · bridge · adaptive: Kai-1.7 target Use it for ## Any question with a known set of answers. Routing, triage, safety, approvals, agent control. If you can list the options, Kai can weigh them. Which tool should run next?choice Which team owns this ticket?choice Is this visual defect within tolerance?noul How severe is the incident risk?score Does this audio signal indicate bearing failure?noul Which fix meets the constraints?choice Should the agent keep going?noul Does a person need to approve this?noul Kai · Decision Model ## Calibrated decision intelligence. Every parameter, wire protocol, and metric. Evaluates multimodal evidence into discrete probabilities across typed schemas. Sub-millisecond p50 on GPU, zero output token cost, and 20 production enterprise recipes. Model Card Specifications kai Wire EndpointPOST https://api.hanzo.ai/v1/decisions Wire Schemanoul accepted as bool bool · choice · score Context WindowStretched from 1,024 trained base 32,768 tokens (multilingual YaRN) Latency FloorMeasured in production on GPU <1 ms p50 (one question, CUDA bf16) Output Token CostDeterministic probability distributions $0.00 / free (0 tokens) Input Token Pricing$0.000000021 per token $0.021 / million tokens Reasoning EngineKai-1.7 target auto · fast · deep Alignment & SafetyEscalates when consequences are unknown Nio policy profiles (experimental) [Get API key](https://platform.hanzo.ai/keys)[Documentation](https://docs.hanzo.ai/docs/decisions) Multi-Language SDKs & OSS Examples [GitHub Repo](https://github.com/hanzoai/kai) Runnable examples across all tier-one runtimes. Zero-install authentication with hanzo auth login or environment variable HANZO_API_KEY. [Pythonexamples/python](https://github.com/hanzoai/kai/tree/main/examples/python) [TypeScriptexamples/typescript](https://github.com/hanzoai/kai/tree/main/examples/typescript) [Goexamples/go](https://github.com/hanzoai/kai/tree/main/examples/go) [Rustexamples/rust](https://github.com/hanzoai/kai/tree/main/examples/rust) [cURLexamples/curl](https://github.com/hanzoai/kai/tree/main/examples/curl) [20 Enterprise Recipes & Standalone Rust CrateModular production blueprints, enterprise crates, and automated verification suites.](https://github.com/hanzoai/kai/tree/main/recipes) bash ``` # "reasoning" is the Kai-1.7 target: api.hanzo.ai refuses the field today (400). curl -X POST https://api.hanzo.ai/v1/decisions \ -H "Authorization: Bearer $HANZO_API_KEY" \ -H "Content-Type: application/json" \ -d '{ "model": "kai", "reasoning": "auto", "state": { "telemetry": { "bearing_temp_c": 94.2, "rpm": 3600 } }, "questions": { "triage": { "type": "choice", "criteria": { "nominal": "within specs", "inspect": "anomaly", "halt": "critical" } } } }' ``` Enterprise Solutions ## Battle-tested decision blueprints across high-throughput enterprise operations. Edge-to-cloud calibrated decision pipelines built for massive SKU inventories, cold-chain logistics, and automated triage. Retail availabilityStack: Kai-M + Kai ### Shelf & Ghost Inventory Triage Multimodal edge vision detects misplaced SKUs, out-of-stock items, and occluded facings. Kai outputs calibrated probabilities over discrete restock actions with zero output tokens.Read more[HIP-1332 (Kai Decision Spec)](https://hips.hanzo.ai/docs/hip-1332-kai-the-decision-model)[Kai 1: Decisions, Not Completions](https://hanzo.blog/blog/2026-10-07-introducing-kai/)[recipes/src/retail.rs](https://github.com/hanzoai/kai/tree/main/recipes) [Explore the shelf recipe](https://github.com/hanzoai/kai/tree/main/recipes) Supply chainStack: Kai-M + Kata ### Cross-Dock Pallet Triage Real-time dock sensors flag pallet damage, tilt, and stretch-wrap tears. Kai computes disposition probabilities under site safety controls and routes to restock or quarantine.Read more[HIP-1334 (Unified Edge Runtime)](https://hips.hanzo.ai/docs/hip-1334-research-unified-runtime)[Decisions, Not Completions](https://hanzo.blog/blog/2026-10-07-introducing-kai/)[recipes/src/industrial.rs](https://github.com/hanzoai/kai/tree/main/recipes) [Explore the logistics recipe](https://github.com/hanzoai/kai/tree/main/recipes) Asset protectionStack: Kai-M + Zen ### High-Value Returns Fraud Inspection Pairs high-resolution visual anomaly detectors with Kai discrete decision logic to flag item swaps, serial mismatches, tampering, and restock vs scrap dispositions.Read more[HIP-0039 (Vision Embeddings)](https://hips.hanzo.ai/docs/hip-0039-zen-model-architecture)[Your AI is Planning To Kill You](https://hanzo.blog/blog/2026-10-16-your-ai-is-planning-to-kill-you/)[recipes/src/retail.rs](https://github.com/hanzoai/kai/tree/main/recipes) [Explore the returns recipe](https://github.com/hanzoai/kai/tree/main/recipes) Cold chain and fleetStack: Kai-M + Kai ### Refrigeration & Fleet Anomaly Triage Continuous multivariate telemetry ingestion across trailer temperature, compressor vibration, and RPM sensors. Flags impending unit failure hours before spoilage thresholds trip.Read more[HIP-1145 (Telemetry Bounds)](https://hips.hanzo.ai/docs/hip-1145-research-experiment-record)[What Is a Decision Model?](https://hanzo.blog/blog/2026-09-30-what-is-a-decision-model/)[recipes/src/industrial.rs](https://github.com/hanzoai/kai/tree/main/recipes) [Explore the sensor recipe](https://github.com/hanzoai/kai/tree/main/recipes) Research & Architecture ## Deep-dives, ethics benchmarks, and decision model specifications. The research, the benchmark results and the specification, from the Kai team. [Decisions2026-10-07 ### Kai 1: Decisions, Not Completions Kai is Hanzo's decision model, served by the Hanzo API. Give it explicit state and a listed question, and it returns a typed, calibrated answer — a choice, a score, a yes/no, or a reasoned deferral.Read the article](https://hanzo.blog/blog/2026-10-07-introducing-kai/) [Alignment2026-10-16 ### Your AI is Planning To Kill You Why frontier models fail when real lives are on the line, and how Hanzo Nio enforces deterministic safety.Read the article](https://hanzo.blog/blog/2026-10-16-your-ai-is-planning-to-kill-you/) [Foundations2026-09-30 ### What Is a Decision Model? Generative models reason in unconstrained paragraphs. Decision models decide in typed, calibrated state transitions. Why the next frontier of AI is decisions, not completions.Read the article](https://hanzo.blog/blog/2026-09-30-what-is-a-decision-model/) [More on the Hanzo blog →](https://hanzo.blog) Read ## The model, the runs, the specification. One model, the questions it is scored on, and the writing. ### Models [KaiOne model. The id is kai.](https://hanzo.ai/models/hanzo/kai) [The callPOST /v1/decisions.](#api) [How to use it](https://hanzo.ai/kai/guide) ### Benchmarks [On this pageKai against Jev, on the same questions.](#benchmarks) [The suite](https://hanzo.ai/benchmarks) ### Research [HIP-1332The decision model.](https://hips.hanzo.ai/docs/hip-1332-kai-the-decision-model) [Kai 1Decisions, not completions.](https://hanzo.ai/blog/kai-decision-models) [HIP-1145How a run is recorded.](https://hips.hanzo.ai/docs/hip-1145-research-experiment-record) [HIP-1334The research runtime.](https://hips.hanzo.ai/docs/hip-1334-research-unified-runtime) [HIPs](https://hips.hanzo.ai) [Research](https://hanzo.ai/research) [Kai is one of three Hanzo model families. Compare them →](https://hanzo.ai/models) Paste and ship Paste this into any agent. It reads the skill manifest and calls Kai from there. Agent promptCopy ``` Read https://hanzo.ai/skill.md and use Hanzo Kai in my project. Start with: hanzo decisions create ``` ## When the answer has a type, ask Kai. [Request early access](https://hanzo.ai/research-access?track=kai)[Explore decision recipes](https://github.com/hanzoai/kai/tree/main/recipes)