Julia 1: 144M Open Decision Model Runs on CPUs and WebGPU
Supersonic Labs released Julia 1 as a 144.3-million-parameter open decision model for classification, routing, scoring and binary decisions. The model runs locally on CPUs or BF16-capable GPUs, ships under the Apache 2.0 license, and has a separate ONNX build for browser inference through WebGPU.
Julia 1 accepts a state or context, a question and 2–20 caller-supplied answer options, then returns the selected option and probabilities. Its native inference policy supports up to 8,192 tokens, while Supersonic Labs says its published accuracy benchmarks used a 1,024-token limit.
The release targets applications that already know their valid action space: agent tool routing, support classification, moderation, triage and other structured choices. The primary checkpoint is about 577 MB on Hugging Face, making it practical to test on hardware far below the memory requirements of multi-billion-parameter generative models.
Julia 1 specifications
| Item | Julia 1 |
|---|---|
| Parameters | 144.3M |
| Base encoder | JHU CLSP mmBERT-small |
| Task | Structured decision / text classification |
| Decision modes | Choice, ordered score, binary yes/no |
| Choices per request | 2–20 |
| Native context policy | Up to 8,192 tokens |
| Runtime | Python CPU or BF16-capable GPU |
| Browser runtime | ONNX Runtime WebGPU export |
| Main checkpoint | ~577 MB safetensors |
| License | Apache 2.0 |
| Model artifact | SupersonicLabs/Julia-1 on Hugging Face |
Julia 1 builds on the multilingual mmBERT-small encoder and adds a decision-specific head. The model returns scores over supplied choices instead of generating free-form text, so an application retains control over the set of actions that can be selected.
Published decision benchmarks
Supersonic Labs reports the following Julia 1 results in its release evaluation. These are developer-reported measurements, and the comparison values should be read within the published evaluation protocol.
| Evaluation | Julia 1 | Published reference |
|---|---|---|
| Typed Decisions | 73.15% | 72.70% |
| AG News pilot | 94% | 91% |
| Emotion pilot | 86% | 48% |
| Banking77 pilot | 64% | 87% |
The Banking77 result is useful because it exposes a current weakness instead of presenting only wins. That dataset has a large set of closely related intent classes, and Supersonic Labs attributes the lower result to its current filtering approach potentially removing the correct answer too early when many similar options compete.
These figures establish a starting point for evaluation, not a universal accuracy estimate. Production teams should measure the model on their own labels, languages, ambiguity patterns and error costs before allowing a decision to trigger consequential automation.
CPU and browser deployment
The main Julia 1 repository supports Python inference on CPU and CUDA. Its small parameter count and roughly 577 MB checkpoint make CPU deployment the most distinctive part of the release for local applications, lightweight services and agent control planes.
Supersonic Labs also publishes Julia-1-ONNX, which exports the same trained weights and decision graph for ONNX Runtime WebGPU. The browser package uses a Rust WebAssembly tokenizer and keeps inference in the browser when the model files are served locally.
For the WebGPU export, Supersonic Labs reports a median 75.47 ms per decision across 100 validation requests in Brave on Linux after warmup. All 100 predictions matched the original Julia 1 outputs in that test set, with a maximum absolute logit difference of 0.00225. Model loading and warmup from local browser cache took 5.84 seconds.
The same page reports 18.23 seconds for the original Julia 1 CPU runtime over those 100 requests on the test machine. The project correctly treats this as a runtime reference rather than a controlled WebGPU-versus-CPU speedup comparison because the execution stacks differ.
What the 8,192-token policy means
The current inference-policy.json sets max_length to 8192 and identifies that value as the native mmBERT positional limit. The project also states that long-context task accuracy has not been established.
That distinction matters for deployment testing. An 8K input can be accepted by the runtime, while the published decision-quality measurements were produced under shorter benchmark conditions. Applications planning to route long documents should evaluate accuracy across the actual input-length distribution instead of treating the context ceiling as an accuracy guarantee.
Where Julia 1 fits in an agent stack
A compact decision model can handle steps that have a finite output set before a larger generative model is invoked. Examples include selecting a tool, assigning a ticket queue, choosing an escalation level, evaluating a policy condition or deciding which workflow should receive a request.
This design can reduce the need to spend a generative-model call on every small routing decision. It also gives applications a constrained output surface: the caller supplies the valid choices and receives scores over those choices.
The model is less suitable when the task requires composing an explanation, generating new content or reasoning toward an answer that is absent from the supplied option set. Those workloads still require a generative or otherwise open-ended system.
Deployment checklist
For a local evaluation, start with the original Hugging Face checkpoint when CPU or CUDA inference is the target. Browser applications can test the separate ONNX/WebGPU repository. Keep a representative held-out set containing real labels and difficult near-neighbor classes, then measure per-class accuracy, calibration, latency and memory use on the intended hardware.
Agent deployments should also define a confidence policy. Low-confidence or high-impact decisions can be escalated to a larger model or human review, while routine high-confidence routing remains local. This makes the specialist model a control-plane component rather than a replacement for every model in the workflow.
Bottom line
Julia 1 is a small, inspectable decision model with an unusually broad deployment range: Python CPU, CUDA and browser WebGPU. Its 144.3M parameters, Apache-2.0 license, 2–20-option interface and published benchmark artifacts make it straightforward to prototype as a local classifier or agent router.
The main evaluation question is workload fit. The published results are promising on several classification tasks and substantially weaker on Banking77, so teams should benchmark their own taxonomy before moving routing or policy decisions into production.