Sarvam Prism: A 44-Millisecond Judgement Model Built for Enterprise Decisions

On November 3, 2026, the Indian company Sarvam AI released a model with a very literal name: Prism. It does not write essays, draw pictures or chat. It does just one thing — pick from a given set of options, and give a probability for each one. That sounds narrow, but Sarvam argues it is exactly the step that shows up most often in enterprise work: which queue a support ticket should be routed to, which category a document belongs to, whether a recorded agent run needs human review, or whether a prompt is a jailbreak attempt. None of those questions needs a long answer; they need a judgement that is fast, accurate, and honest about its own confidence. Prism is designed for that kind of "System One" rapid judgement, and its release matches the positioning: open weights, so enterprises can keep training it on their own data and run it on their own infrastructure.

The core numbers should come first, because almost the whole announcement revolves around them. Sarvam says Prism, built on Sarvam 105B and obtained by LoRA fine-tuning, scores an average of 71.8 and answers in a median of just 44 milliseconds on a single NVIDIA B200 GPU. Among the 25 decision models Sarvam tested, it is the highest-scoring model that answers in under 100 milliseconds. The phrase "highest under 100 ms" is the key: Sarvam does not claim Prism is the highest-scoring model overall, but that it occupies a new point on the trade-off curve between accuracy and speed. The announcement itself acknowledges that a few models score higher, but take two to six times as long. In other words, Prism's strategy is not "smartest," but "smart enough, and fast enough to sit inside every request in a pipeline."

That 71.8 needs to be unpacked. Sarvam averages three indices. The first is the Jev Decision Index, 37 public benchmarks, where Prism scores 67.0. The second is Sarvam's own recreation of the Artificial Analysis Decision Index, in which the private knowledge test is replaced with curated hard questions that include an "I don't know" option, where Prism scores 65.9. The third is an internal Indian-language benchmark, where Prism scores 82.5. For comparison, Perplexity Decider v1.2 averages 68.0 at 117 ms, Jev 1.14 averages 64.5 at 196 ms, Clef averages 62.6 at 222 ms, and Microsoft-Decision-1 averages 61.1 at 85 ms. One detail must not be lost: Jev 1.14 and Microsoft-Decision-1 are available only through an API, so Sarvam plots their publicly reported times, while measured from Sarvam's own cluster they took 431 ms and 533 ms respectively. If measured times are used, Prism's speed advantage looks larger; if reported times are used, the comparison is fairer to the competitors. Sarvam publishes both, which is to its credit, and anyone quoting the 44 ms figure should also state that it is a median, on one B200, with requests sent one at a time.

How Prism works explains why it can be so fast. It is not a generative model: given a state, a question and options, it completes the judgement in a single forward pass, with a small scoring head returning a probability for each option and no token-by-token generation. That design sets its scope: it fits tasks where the options are already given, not tasks that need open-ended generation. In training, Sarvam uses two equally weighted loss terms: cross-entropy with 5 percent label smoothing, and a Brier loss that measures squared probability error. Sarvam attributes Prism's good calibration to those two choices. The attention design is also neat: the state and question form one block that is read in both directions, each option sees that block and itself but never the other options, and only the answer token sees everything. Sarvam says that isolation makes each judgement independent, while bidirectional reading adds about 3 points on the Jev Decision Index. On the engineering side, Sarvam sends the large block through a fast kernel with no mask and applies the custom mask only to the thin strip of option and answer rows, making attention 2.6 times faster on requests over 2,048 tokens, while FP8 quantisation changed the Jev score by only 0.01 points.

The journey from 664 ms to 44 ms is itself a good engineering case study. Prism started at 664 ms per median request, running in 16-bit precision across two B200 GPUs. Sarvam converted the weights to FP8 so the model fits on a single GPU, ran all 128 experts in one grouped kernel, captured the forward pass as a CUDA Graph, folded the FP8 conversion into the expert kernels, and merged the fine-tuning adapter into the model weights. Together, those steps deliver a 15.1-fold speedup with no drop in accuracy. That chain shows Prism's speed is not just about a small model, but about system-level optimisation stacked together. For enterprises that want to deploy it themselves, there is also a hard floor: running Prism in FP8 requires one GPU with at least 120 GB of memory. That is not a condition every ordinary server meets, so "run it on your own infrastructure" comes with a hardware precondition. At the same time, a single question can take up to 131,072 tokens, so very long agent traces can be evaluated in one pass rather than split into chunks.

If only scores and speed are considered, Prism could easily be mistaken for another benchmark-chasing model. What sets it apart is calibration — how honest the model is about its own confidence. For an enterprise to automate a decision, it must act automatically only above a confidence threshold and hand off to a human below it. That mechanism is safe only if the confidence itself is trustworthy. Sarvam's evaluation covers every threshold from 50 percent to 95 percent, and finds that Prism makes fewer errors than its confidence scores predict, in both English and Indian languages. For answers given with at least 90 percent confidence, Prism predicts 3.3 percent errors and makes 2.2 percent in English, and predicts 5.4 percent and makes 4.4 percent in Indian languages. The comparison models generally underestimate their errors: in English, Perplexity Decider, Microsoft-Decision-1 and Jev 1.14 underestimate by factors of 1.5, 1.8 and 2.7 respectively, and in Indian languages the other models make 2.7 to 4.8 times as many errors as their confidence scores predict. The English test uses 226,088 questions from 37 public benchmarks, and the Indian-language test uses the same benchmarks in 10 Indian languages and Hinglish, totalling 20,108 questions. The practical meaning is direct: an overconfident model quietly auto-approves cases that should have gone to a human, while a well-calibrated model leaves uncertain cases to people.

Order invariance is another detail that is easy to overlook but frequently bites in real systems. Many models change their answer when the options are shuffled, which means the same question in a different order can yield a different conclusion. Sarvam tested 2,000 questions: each was run four times in four shuffled orders and four times in the original order. With Prism's step of putting options into one fixed order before scoring, none of the 2,000 answers changed. Without that step, reading options in the order sent, Prism changed 4.0 percent of answers when shuffled. The comparison models look worse: Perplexity Decider, GLiDE 1.2 and mammoth-1 give the same answer on repeats in the original order, but change 9 to 10 percent of answers when shuffled, while Jev 1.14 changes 5.6 percent even when nothing changes and 12.3 percent when shuffled. Sarvam's fix is not complicated — fix the order before scoring, then map each probability back to its original option name — but it costs no extra computation and loses no accuracy, while removing a source of erratic behaviour in automated systems.

Agent-trace evaluation is the set of experiments closest to a current developer pain point. Agent work needs checking: did the task succeed, does the run need human review, and if it failed, which agent caused it. Sarvam used three sets of recorded runs — web-agent runs labelled by experts, customer-service conversations labelled by task completion, and failed runs labelled with the failing step and responsible agent — totalling 700 runs and 1,770 questions. Prism scored 75.0 percent on whether the task succeeded, 86.4 percent on whether the run needs human review, 69.6 percent on which agent caused the failure, and 78.5 percent overall, ahead of Clef, Jev 1.14, Microsoft-Decision-1 and Claude Haiku 5.5. The speed and cost comparison is equally stark: Prism scores a full agent run in about half a second on a single GPU, while Claude Haiku 5.5, called through its API, takes a median of 2.5 seconds per run and costs $0.64 per 1,000 runs. The labels here come from human experts or the environment's own automatic checks, not from another AI model's judgement, which makes the results more credible. Still, 700 runs is a limited sample, and whether the results generalise to more complex, longer production traces remains to be verified.

The security numbers need to be read more cautiously. Sarvam used an internal cybersecurity benchmark of 5,517 questions across nine tasks, built from vulnerabilities published since July 2026. Models must classify whether an artefact is part of a phishing campaign, whether an incoming prompt is trying to jailbreak, and attack types into MITRE frameworks. Prism scored 89.0 percent, ahead of Clef at 84.5 percent, Jev 1.14 at 78.6 percent and Microsoft-Decision-1 at 76.1 percent. Sarvam itself notes that this evaluation set has not yet been released publicly, and that it will be expanded and released in the coming weeks. Until it is public, outsiders cannot independently reproduce the 89.0 percent figure or judge whether coverage across attack types is balanced. Treating it as a directional signal is reasonable; treating it as settled fact is premature. Likewise, Sarvam says Prism has been tested on real-world uses such as a speech-to-speech harness, trace evaluation, prompt-injection guardrails, intent routing for customer support, model routing and document intelligence, with more benchmarks to be released over time.

Seen in a wider picture, Prism's arrival marks the moment when the "decision model" category is turning from a concept into a contested track. Sarvam acknowledges in its announcement that TypeSafe created the category last month, naming its Jev model after Kahneman's System One thinking — the fast, intuitive mode of judgement. Within a month, models from Perplexity, TypeSafe, Microsoft and others are already being compared head to head. Sarvam's play is clear: do not compete on the breadth of general chat, but on speed, calibration and deployability for a narrow task, and lower the adoption barrier with open weights. The weights are released on Hugging Face under the Apache 2.0 licence, and the model is also available as an API on Sarvam Indus. That combination is attractive for enterprises because they can first verify performance quickly through the API, and then, once convinced, move the model into their own infrastructure and keep training it on their own data.

Prism's limits should be stated just as clearly. First, it only solves judgement problems where options are given; it cannot replace general models for generation, reasoning and long-form writing, and using it on the wrong kind of task makes its speed irrelevant. Second, one of its three indices is Sarvam's own internal Indian-language benchmark, and its security benchmark is also internal — until those are independently reproduced, they remain vendor-reported. Third, its deployment bar is not low: a single card with 120 GB of memory means smaller teams may still start with the API route. Fourth, 44 ms is a median under specific hardware and test conditions; latency in a real production environment will vary with batching, concurrency, context length and infrastructure differences. With all those qualifiers counted, Prism is still a release worth watching — not because it tells a bigger-model story, but because it tells a more practical engineering story: once agents start running at scale, the layer that checks them, routes them and guards them will itself need a model that is fast, accurate and honest.

Looking one step further, Prism's positioning raises a more general question: as general models grow stronger, why do we still need a model dedicated to judgement? The answer lies in cost structure and in where responsibility sits. A general model is good at open-ended tasks, but every judgement costs a string of generated tokens — slow, expensive, and with a confidence that is often linguistic confidence rather than a probability usable as an automation threshold. A decision model reverses the trade: it gives up open-ended generation in exchange for a probability distribution from a single forward pass. What enterprises usually need from automation is not "let the model improvise," but "choose among clearly defined options, with a measurable risk attached to the choice." In that light, Prism is not a shrunken general model but a product with a different division of labour: general models understand and generate, decision models decide and route at critical nodes.

That division of labour will matter more as agents are deployed at scale. Every step an agent takes can create a node that needs judgement: was this step correct, should it continue, should a human be called, is this conversation an attack, which category does this document belong to? If every node calls a general model, cost and latency accumulate quickly, and output format and stability become hard to guarantee. Prism's approach is to unify those nodes into a standard input of state plus question plus options, handled by one fast, calibrated model. Its 131,072-token context matters here too: a very long agent trace does not need to be split into chunks, so it can be read in one pass, reducing information loss and boundary errors. None of this means general models will be replaced; it means future systems will contain both kinds — one kind that does the work, and one kind that checks the work.

Competitively, the decision-model category is still very early, and standards are far from settled. Sarvam itself acknowledges that TypeSafe created the category only last month, and that the models being compared differ in evaluation conventions, deployment modes and timing statistics. Perplexity's Decider, TypeSafe's Jev, Microsoft's decision model and Sarvam's Prism each have different strengths: higher on one index, closer on speed, or stronger in a particular language. Prism's current lead rests mainly on its average score, its sub-100-millisecond speed and its calibration, but all of those rest on Sarvam's own evaluation system. The most important thing to watch next is whether an independent, public decision-model benchmark emerges, so different vendors' models can be compared on the same questions and the same hardware conventions. Until then, any "number one" claim should carry the qualifier "in one vendor's own tests."

Finally, a deployment checklist for teams that want to try Prism. First, define the options: a decision model can only choose among given options, so if your task's options are themselves unclear, design them first rather than expecting the model to invent them. Second, set a threshold and keep a human loop: choose a confidence threshold from Prism's calibration curve, automate above it, hand off below it, and regularly review handed-off cases to see whether the threshold needs adjusting. Third, test order stability on your own data: shuffle the option order and confirm answers do not drift, which matters especially for support routing, classification and risk-control settings. Fourth, assess deployment cost: if you plan to run it locally, confirm you have a single card with 120 GB of memory; if not, validate through the API first before investing in hardware. Fifth, track the publication of internal benchmarks: once the security benchmark and more real-world benchmarks are released, validate again on your own data. Only after those five steps does Prism move from being a model in a blog post to a judgement layer you can actually trust inside your system.

One more point deserves separate emphasis: do not treat a vendor-reported "number one" as "the industry's standard answer." Prism's scores, speed and calibration were all obtained inside an evaluation system built by Sarvam itself, and the comparison models differ in deployment mode and timing conventions. The most convincing verification usually comes from independent benchmark reproduction, real deployment feedback from the open-source community, and threshold performance and failure distributions from production use. Until that evidence appears, the safest way to read Sarvam's announcement is as a list of vendor claims to be checked one by one, not as a settled report card. That attitude is not distrust of Sarvam specifically; it is the basic caution that should apply to every model launch.