pplx-decider-flash vs Laya: Two Kinds of Decision Model, One Wrong Comparison

The numbers making the rounds are tidy and useless. One comparison index scores Laya at 69.5 and pplx-decider-flash-v1.2 at 68, a near-tie. Another scores Flash at 73.7 and ranks it first of 48. A third gives Flash 451 out of 504 against Laya multilingual's 240. Three sources, three verdicts, because each is measuring a different model on a different task set — and at least two of the three are measuring a Laya variant without saying which one. This is the comparison that actually matters, and the first honest sentence is that nobody has run it properly yet.

What can be compared is the shape of the two systems: what they are built to do, what they cost to run, and what each one demands from you before it produces a usable probability. On those axes they are not close rivals. They are different products that happen to share a job title.

One paragraph each

pplx-decider-flash-v1.2 is a 4B-class multimodal decision model from Perplexity, built on a Qwen3.5-4B backbone with a separate 255-way readout head. You give it a state — text, JSON, or an image up to 1.6 megapixels — and typed questions, and it returns calibrated probabilities in one forward pass. It is designed to work zero-shot: the saved temperature is 1.554, and the card reports 88.8% accuracy with expected calibration error of 0.021 on a 1,497-question development set. It is Apache-2.0, about 9 GiB in BF16, and costs $0.01 per million input tokens on Perplexity's API with output free.

Laya is a family of non-autoregressive decision encoders from Convai Innovations, released 18 September 2026 and also Apache-2.0. The English checkpoint is a 421M-parameter fine-tuned ModernBERT-large with a 512-token context; the multilingual model is a 322M-parameter mmBERT-base with 1,024 tokens; a third checkpoint, laya-typed-decisions, is the one that posts the headline scores. It answers all questions in a call in a single forward pass using per-option mask tokens, with no generation step and no image input.

Why the comparison tables disagree

The mismatch starts with the benchmark each vendor built. Perplexity scores its models on Decision Index 0.3, a composite over knowledge, language, retrieval, tools and arts. Convai scores Laya on a 400-case, 2,000-decision typed-decisions benchmark that it also publishes. Neither model has been run on the other's harness in public.

The third-party indexes fill that gap badly. Anchor Terminal's composite puts Laya fourth at 69.5 and Flash sixth at 68, a 1.5-point difference that is well inside the noise of a composite nobody can audit. Ollaya Bench reports 73.7 overall and rank one of 48 for Flash, with 82.4% macro accuracy, but publishes no harness. A Jev-authored task suite scores Flash at 451/504 and Laya multilingual at 240 — a rout, on a suite written by a competing model's maintainers. PublicAI's page manages to record Flash beating Laya 322M and Laya multilingual while also losing 3–0 to an unnamed "Laya".

That last entry is the whole problem in miniature. "Laya" is not one model. Comparing Flash to a 421M English encoder, a 322M multilingual encoder, and a fine-tuned benchmark specialist produces three different answers, and only one of them is the thing you would actually deploy.

The scoreboard we can defend

These are the dimensions where the two systems genuinely diverge, with each side's own published figures and the sourcing stated.

• Parameters — pplx-decider-flash-v1.2 is 4B class (the API docs say 4B, the card header says 5B in BF16) vs Laya at 421M English and 322M multilingual.

• Context — 262,144 tokens on Flash, trained to about 32,000 vs 512 tokens on Laya English and 1,024 on multilingual.

• Modality — Flash accepts text, JSON and images up to 1.6 MP vs Laya accepts text only.

• Zero-shot use — Flash ships calibrated, with a saved temperature and published error metrics vs Laya's base checkpoints, which the card itself calls "a fast base to specialise, not a zero-shot decision engine".

• Latency — Laya at 32.8 ms for one question on a T4, 72.3 ms for ten, 103–332 questions per second batched, and 193–464 ms on CPU vs Flash with no published service-level figure from Perplexity; the only figure the vendor publishes is a documentation test where ~248,000 input tokens took 16 seconds.

• Price — Flash at $0.01 per million input tokens, output free, on Perplexity's API vs Laya with no hosted price because it is a weights release you run yourself.

Latency and hardware: where Laya is not close

Laya's entire pitch is that a decision does not need a generative model, and the latency numbers support it. One question in 32.8 ms on a T4 for the multilingual checkpoint, 39.5 ms for English; ten questions in 72.3 ms; 103 to 332 questions per second when batched. On CPU, preloaded, it runs in 193 to 464 ms. A 322M encoder is small enough to sit inside a request path that cannot afford a GPU.

Flash is a different deployment class. Nine gigabytes of BF16 weights fit on a 16 GB consumer card, and one third-party benchmark reports about 10.4 GB of VRAM and 90–127 ms per decision on an RTX 5090. That is respectable for a 4B model and roughly three times Laya's T4 latency on hardware that costs many times more. If your constraint is milliseconds on cheap hardware, the argument is over before accuracy enters it.

The fine-tuning question

This is the part the comparison tables hide, and it is decisive.

Laya's headline 0.766 accuracy belongs to laya-typed-decisions, a checkpoint fine-tuned on the benchmark's own training split. The base English checkpoint scores 0.362 on the same benchmark, against a majority-class baseline of 0.461 and random guessing at 0.318. In other words, the model you download cold is worse than always answering with the most common label. Convai says so directly on the card. An independent reproduction study on arXiv also reported that one headline metric, soft accuracy of 0.509 against the published 0.471, failed to reproduce, and argued the calibration data is contaminated by construction.

Flash's claim is the opposite shape: a vendor-reported 60.05 on Decision Index with one question per request, from a model you are meant to use as shipped. That claim is unverified — Perplexity built the benchmark, and its card says the training work included the official training splits of several Decision Index tasks, decontaminated against the test sets. That is a defensible practice stated plainly, but it also means the model has seen in-domain data for the benchmark it is scored on, and the decontamination is Perplexity's own claim rather than an audited fact. But the burden is different. With Laya you must fine-tune and re-calibrate before the published numbers mean anything; the card recommends temperature fitting because raw probabilities run overconfident, with ECE falling from 0.466 to 0.081 after refitting. With Flash you are trusting a vendor's calibration on data you have not seen.

Neither is free. One costs engineering time, the other costs verification time.

Language and cardinality

Laya multilingual supports 100-plus languages in principle and 45 of 51 in practice, by the card's own "usable" threshold of three times random. Its XNLI score outside English is 0.731, against 0.521 for the English-only checkpoint, and MASSIVE intent accuracy across 13 other languages is 0.451. Those are modest numbers, but they exist, and Flash has no published multilingual evaluation at all. If your traffic is not English, the vendor with the multilingual eval is the safer starting point even where its scores are low.

Cardinality runs the other way. Laya degrades badly on high-cardinality choice questions: 0.425 on Banking77's 72 labels against Jev's 0.870, because 77 options at default settings receive about three to four tokens each. The card advises raising the option budget or splitting coarse-to-fine. Flash accepts up to 255 options and has no published high-cardinality benchmark, so the safe reading is that Flash is designed for the case Laya documents as a weakness and has not shown its work.

What a thousand decisions cost

Laya has no per-decision price because you host it. On a T4 at 103–332 questions per second, a million decisions is somewhere between 50 minutes and three hours of GPU time. At commodity cloud rates that is cents to a few dollars, plus the engineering to deploy and monitor it.

Flash on the API is easy to compute. A 400-token state, one question: 1,000 decisions is 400,000 input tokens, which at $0.01 per million is $0.004. A million decisions is about $4. Self-hosting the weights removes the per-token cost but puts you back on a GPU with roughly 9 GiB of weights and a noncausal attention pattern that stock causal servers do not reproduce.

The trap is batching. Flash bills the state again for every question, so three questions per state triples the bill. If your gate asks several things at once, the cheap model is not cheap.

This is also the layer where the routing question appears. A decision model is a gate in front of generation, and the generation side is where most of the spend sits. OrcaRouter puts 200-plus models behind one key with no markup on list prices, so a cheaper generator or a vendor price cut applies the same day, and automatic failover keeps a misrouted request from failing outright. We do not host pplx-decider-flash or Laya. The one decision model we do serve is TypeSafe's Jev, as jev-1.13 and jev-1.14, which is worth knowing if you want a hosted decider without standing up a GPU.

How to choose, in order

• Non-English traffic — start with Laya multilingual, then measure. It is the only side with published cross-lingual numbers.

• Sub-100 ms on commodity hardware — Laya. On a T4 it answers in 33 ms; Flash needs a modern GPU and reportedly takes 90–127 ms there.

• Images in the state — Flash, with no real competition. Laya has no vision path.

• Long states — Flash. A 512-token window rules Laya out for anything resembling a document.

• No labelled data and no time to fine-tune — Flash, at least as a starting point. Laya's base checkpoint is below the majority baseline.

• More than 20 options per question — Flash, or Laya with a raised option budget and a coarse-to-fine split.

The honest summary is that these models compete for the same job description and almost never for the same deployment. Laya is a fast, tiny, fine-tunable encoder for high-volume classification in languages you can test. Flash is a general-purpose, calibrated, multimodal judge with a large context and a vendor scoreboard behind it. The comparison tables that put them 1.5 points apart are not wrong so much as meaningless: they average away exactly the properties that decide the choice.