Julia 1 Is a Compact Model for Finite-Choice Decisions

Supersonic Labs has introduced Julia 1, a 144.3-million-parameter classification model that chooses among answers supplied with a question. In a post on X, @supersonicai describes it as the company’s first classification model designed to run on almost anything.

Julia 1 is not a chatbot or a text-generation model. Its job is narrower: take a state or piece of context, a question and between two and 20 candidate answers, then select one and return scores for the supplied options. The linked materials describe Python CPU and CUDA support, plus a separate browser implementation using WebGPU.

Image credit: @supersonicai on X

What Julia 1 is designed to do

Julia 1 uses one decision interface for several related tasks. A developer can use it to classify text, route a request, assign an ordered level or answer a Boolean, or yes-or-no, question. The model does not generate a new answer in free-form text; it compares the options provided by the caller.

Supersonic Labs gives a support-routing example. If the state is “I was charged twice for the same order,” the options might be Billing, Shipping and Account access. Julia 1 selects the most appropriate destination. A follow-up question could ask how urgent the request is, with low, medium and high as ordered choices.

The same format can therefore represent different kinds of decisions:

• Choice: select one option from a set such as Billing, Shipping and Account access.

• Score: select an ordered level such as low, medium or high.

• Noul: answer a Boolean question using false and true options in the required order.

The model’s output includes the selected answer and scores in the order supplied by the caller. The model card says those scores are full softmax probabilities, not guaranteed certainty. The result depends on the wording of the state, question and options, so clear and distinct candidate answers matter.

How the finite-choice interface works

A native Julia 1 call accepts between two and 20 options. The options are part of the input rather than a fixed classification head chosen when the model is trained. That lets the same interface handle different labels and workflows without adding a new output head for every application.

The approach is useful for classification and routing when the relevant evidence is already present in the supplied context. It is not evidence that Julia 1 can reliably provide missing facts, solve algebraic problems or perform long chains of reasoning. The published evaluations focus on choosing among answers supplied with each question.

For larger option sets, the Python runtime includes a Router that narrows candidates in groups before a final decision. That extends the practical use of the interface, but it changes the problem: the final probabilities cover the surviving candidates rather than all original choices. The Banking77 evaluation also shows why this matters. The model can lose the correct category during narrowing when labels are numerous and similar.

Built on mmBERT-small

Julia 1 adapts mmBERT-small, a multilingual encoder and tokenizer, for decision tasks. An encoder processes input into representations for downstream tasks; unlike a generative language model, it is not designed to write an open-ended response. Supersonic Labs added decision components that score supplied alternatives in the context of a state and question.

The released Julia checkpoint has 144.3 million parameters, and its weights occupy about 550.5 MiB in the supplied model repository. The repository contains the weights and inference code, but not the private training pipeline. The artifacts are listed under the Apache 2.0 license.

The model card distinguishes the runtime’s limits from the historical benchmark setup. The current runtime supports up to 8,192 combined tokens, while the historical accuracy benchmarks used a 1,024-token limit. The supplied launch page also describes an evaluated 1,024-token configuration. These figures should not be treated as evidence that accuracy has been established for 8,192-token inputs.

What the published evaluations show

Supersonic Labs reports an evaluation dated September 24, 2026, using H200 hardware, BF16 inference and strict input encoding. On the typed-decisions suite, Julia 1 answered 1,463 of 2,000 decisions correctly, or 73.15%, compared with 72.70% from the Jev protocol’s supplied comparison reference. That figure comes from the protocol’s reference results, not from a newly run Jev evaluation.

The typed suite combines several decision forms. The model card reports 428 of 600 correct for Choice, 484 of 600 for Noul and 551 of 800 for Score. Those results describe the supplied test protocol; they do not establish performance in an arbitrary production workflow.

The linked launch page and model card also report three 100-example classification pilots:

These comparison figures are supplied reference values from the Jev protocol, not results from a new Jev run. The first two pilot results are encouraging signals, but each uses only 100 examples. Banking77 is the most important qualification in the set: Julia 1 trails the supplied reference by 23 percentage points, and the test uses a ranking and top-16 shortlist rather than a native 72-option call. The result supports the company’s warning that long lists of similar options are a concrete area for improvement.

The company also reports a MASSIVE scenario-classification evaluation across 52 locales. Julia 1 selected the correct scenario in 110,573 of 154,648 cases, for 71.50% macro accuracy. The reported figures were 86.25% for European Portuguese and 86.75% for US English. This test covers one of 18 scenarios and does not measure intent classification or slot filling.

A separate CPU run dated September 25, 2026 reports 1,451 of 2,000 typed decisions correct, or 72.55%. It reports 94 correct AG News answers, 86 correct DAIR Emotion answers and 60 correct Banking77 answers, with three abstentions in the Banking77 set. Those results were recorded under different conditions from the September 24 evaluation and should not be read as a controlled accuracy comparison between hardware types.

The clearest limitation: long, similar option lists

Julia 1’s strongest fit is a decision where the context contains the necessary evidence and the candidate answers are clear. The Banking77 result shows the opposite case: many categories, similar wording and a narrowing stage can make the correct answer disappear before the final selection.

This limitation has practical consequences for routing systems. Developers should test the exact labels, descriptions, questions and real-world examples they plan to use. A high score on AG News, Emotion or MASSIVE does not guarantee accuracy for a new domain, every language or a consequential workflow. The model materials recommend human review for consequential decisions.

Where Julia 1 can run

The original Julia 1 repository provides a Python 3.11-or-newer runtime. CPU inference works with a standard PyTorch installation, and CUDA is available when PyTorch detects a suitable BF16-capable GPU. The model should remain loaded between requests to avoid repeatedly paying its initialization cost.

The separate Julia-1-ONNX repository exports the same weights and decision graph for browser inference. It uses ONNX Runtime WebGPU, WGSL kernels and a Rust WebAssembly tokenizer. A browser with WebGPU is required, and the browser downloads about 551 MB of external weights before creating and warming the session.

The launch page also reports measurements from an Intel Core i5-1235U evaluation package, including 294.81 ms per typed decision, 107.83 ms per AG News decision, 89.83 ms per DAIR Emotion decision and 3,713.54 ms per Banking77 decision. Those workloads use different inputs and test procedures, so the figures should not be combined into a single CPU speed ranking.

The browser repository reports that its 100 WebGPU predictions matched the original runtime on the validation requests, with a maximum absolute logit difference of 0.00225. This is an output-parity check on that request set, not a new WebGPU accuracy evaluation. The original accuracy suite was not rerun in WebGPU, and floating-point rounding could still change a decision when competing options are nearly tied.

Where the model may fit

Julia 1 is best understood as a compact, finite-choice decision model for developers who need one interface for classification, routing, ordered scoring and yes-or-no checks. Its CPU runtime and browser WebGPU export broaden the environments in which developers can test that approach, including local Python applications and browser-based tools with compatible hardware.

The published results show measurable strengths on several supplied tests, but they also show a substantial failure mode with long, similar option lists. Before using Julia 1 in a real system, developers should measure latency, memory use and decision quality with their own contexts and candidate answers. The available evaluations support experimentation with explicit-choice workflows; they do not establish general-purpose reasoning, guaranteed accuracy or suitability for high-stakes automation.

Read the Supersonic Labs launch announcement, the Julia 1 model repository and the Julia 1 WebGPU repository for the supplied implementation details and evaluation records.

Sources

• @supersonicai