# Julia 1: A 144M-Parameter Decision Model Trained for $104

> Source: <https://dev.to/jamilxt/julia-1-a-144m-parameter-decision-model-trained-for-104-59i2>
> Published: 2026-09-27 18:15:29+00:00

A small AI lab in Brazil just released a model with an unusual claim. Not "beats GPT." Not "agentic superintelligence." The claim is this: a 144.3-million-parameter model that picks the right answer from a list you give it, runs on a CPU, on a tablet, on a 12-year-old laptop class of chip, and the entire training cost about R$540. That is US$104.08.

The model is Julia 1, from Supersonic Labs. It went up on [Hugging Face](https://huggingface.co/SupersonicLabs/Julia-1) under Apache 2.0. If you read my piece on [Jev vs Laya](https://dev.to/jamilxt/jev-vs-laya-the-same-ai-idea-one-closed-and-one-open-3c6e), this is a third entrant in the same category, and in one benchmark it beats both.

Most production AI pipelines do not need text generation. They need a label. When a support ticket arrives, you do not want a paragraph about billing. You want one word: `billing`.

A large language model does this expensively. It streams tokens like "The correct category is: billing" so your code can parse the label back out. A decision model skips all of that. You supply a context, a question, and 2 to 20 options. The model returns scores for each option in the order you gave them.

Julia 1 handles three question types through one interface:

Because the model never generates text, it cannot produce a malformed answer. A wrong label is still possible. A broken JSON string is not.

The team published their evaluation from September 24, 2026, against the Jev reference values from the same protocol. Three wins, one honest loss:

Why does Banking77 hurt? Each native call accepts 2 to 20 options. For 72 banking intent categories, Julia uses a Router that narrows candidates in groups before the final pick, and that narrowing can discard the correct answer. Long lists of similar categories are the model's concrete weak spot, and the team names it instead of hiding it.

There is also breadth: on [MASSIVE](https://huggingface.co/datasets/AmazonScience/massive), a scenario-classification test across 52 locales, Julia 1 scored 71.50% over 154,648 examples. Portuguese came in at 86.25% and US English at 86.75%.

Benchmarks on borrowed H200s are easy. The interesting table is the CPU one. A September 25 re-run on a plain CPU scored 72.55% on the typed decisions, essentially the same quality as the GPU run.

No GPU. No API round trip. The weights are 550.5 MiB, and the process fits in under 400 MB of RAM on a tablet. This is the "runs on the hardware people already own" thesis made concrete.

The team's explanation is refreshingly direct. Training a multilingual model from scratch needs data, infrastructure, time, and money they did not have. So they started from [mmBERT-small](https://huggingface.co/jhu-clsp/mmBERT-small), a multilingual encoder from Johns Hopkins CLSP, kept its tokenizer, added a decision head, and trained the model to score supplied options.

Total cloud GPU spending for training and experiments: about R$540, or US$104.08.

Julia 1 is not a fine-tuned Qwen model and not a chat model. It is a general-purpose encoder adapted into a specialist. The whole point is that the specialist task, choose among supplied options, is cheap to evaluate and cheap to serve.

For Julia 2, they plan to drop mmBERT and build their own foundation architecture. That is a bigger bet, and the current page is open about limits: no external knowledge, no multi-step reasoning, and pilots of 100 examples are signals, not guarantees.

If you currently use an LLM call to classify, route, or score, the economics deserve a look. Supersonic's planned hosted API is $0.025 per million input tokens and $0.00 for output. Jev charges $0.042 per million input tokens. Laya is free if you host it. And Julia 1 you can host yourself on a CPU you already own, at Apache 2.0, with this snippet from their model card:

``` python
from julia import load_model
engine = load_model("Julia-1", device="cpu")
result = engine.predict(
    state="I was charged twice for the same order.",
    questions={
        "team": {
            "type": "choice",
            "criteria": {
                "billing": "Billing and payment disputes",
                "shipping": "Shipping and delivery",
                "access": "Account access and login",
            },
        },
    },
)
```

The honest guidance, which the team itself gives: evaluate the exact questions and options from your own domain, keep option lists short, and keep a human in the loop for consequential decisions. A 73% router that costs nothing to run may still beat a 95% LLM pipeline that costs dollars per day, but only if you measure it on your data.

The interesting story here is not that a 144M model beats a reference on three of four benchmarks. It is that the full loop, train, evaluate, publish weights, publish failures, publish the invoice, now costs about the price of a decent pair of headphones.

When a two-person-class lab in Brazil can put a working, multilingual, Apache-licensed specialist model on Hugging Face for a hundred dollars, the barrier to useful, narrow AI stops being capital and starts being taste: choosing a real problem, picking the right foundation, and publishing your failures alongside your wins.

That part has been true for a while in software. It is now true for models too.

*Links: [Julia 1 announcement](https://supersoniclabs.ia.br/julia-1/) · [Hugging Face repo](https://huggingface.co/SupersonicLabs/Julia-1) · [mmBERT-small](https://huggingface.co/jhu-clsp/mmBERT-small)*