Skip to content

Build Independently confirmed2 publishers 3 min read Published

Supersonic Labs trained Julia 1 for $104 on cloud GPUs, then benchmarked inference on a laptop CPU

Supersonic Labs' Julia 1, a 144.3M-parameter model trained for about $104, picks labels from a caller's list on an ordinary CPU. On its own 72-label Banking77 pilot it scored 64 of 100, which shows where the 20-option cap keeps it from replacing an LLM classifier.

The Engineer · Build desk

Send a correction

Illustration accompanying Supersonic Labs trained Julia 1 for $104 on cloud GPUs, then benchmarked inference on a laptop CPU
Generated illustration

What happened

  • Julia 1 takes a context, a question and 2 to 20 options supplied by the caller, and returns one score per option in the order they were given.
  • On 2,000 typed decisions it got 73.15% right, against a reference value of 72.70% for Jev, a rival decision model.
  • The Brazil-based lab put the weights and code on Hugging Face under an Apache 2.0 license on September 26.

Why it matters

  • What's now possible capability A label-only pipeline moved onto Julia 1 can drop its output parser and its malformed-response retries, because the only failure left is a wrong index into its own list.
  • What it limits constraint Taxonomies with more than 20 labels or many near-duplicate intents depend on a router that can throw out the right answer, so they need their own evaluation before any swap.
  • What it costs cost Serving cost becomes CPU time. At about 3.4 sequential decisions a second on a budget laptop chip, throughput decides how many machines a high-volume queue needs.
  • Who has to decide decision The accuracy evidence is company-run pilots with no LLM baseline, so a team choosing between Julia 1 and its current LLM call has to settle it with a test on its own labels.

On each call, the caller sends a context, a question and its own candidate labels. It gets back a score for each label, in the order it sent them [3]. The integration code is an argmax plus an index into a list the caller already holds. A generative model doing the same job streams text such as "The correct category is: billing", and the caller then has to parse the label back out [19]. Julia 1 never generates text, so it cannot return a malformed answer. It can still return the wrong label [16].

The same interface covers three question types: pick one option from a closed list, place the input on an ordered scale, or give the probability that a statement is true [4].

The $104.08 is the lab's cloud GPU bill for training and experiments [2]. An adopter does not pay it. The weights are on Hugging Face under Apache 2.0 [1], so the running cost is CPU time. The bill is small because of a design choice I think is correct. According to the dev.to write-up, the team lacked the data, infrastructure, time and money to train a multilingual model from scratch. Instead it took mmBERT-small, a multilingual encoder from Johns Hopkins CLSP, kept its tokenizer, and trained an added decision head to score supplied options [11].

Quality held on CPU. The GPU evaluation scored 73.15% on 2,000 typed decisions [17]. A September 25 re-run on a plain CPU scored 72.55% [18], 0.6 points lower [25]. An Apple M4 took a median 33.15 ms per decision one call at a time, about 30 a second [21]. Batched 16 at a time, it reached about 51 a second [8]. On an Intel Core i5-1235U the median was about 295 ms [8], roughly 3.4 sequential decisions a second [24]. The Samsung SM-X510 tablet ran at 203 ms through ONNX Runtime, with the 550 MB weights memory-mapped and peak process memory at 393 MB [9]. RuntimeWire reports five decisions a second on that tablet, running on CPU after the accelerator path fell back [10]. That is consistent with 203 ms per call [20].

The lab documented the failure itself. Each native call accepts 2 to 20 options [3]. Banking77 has 72 labels, so Julia 1 sends them through a Router that narrows candidates in groups before the final pick. That narrowing can discard the correct answer [7]. If an early round drops the right intent, the final pick has no correct option left to choose. Julia 1 got 64 of 100 against an 87% reference [6], 23 points behind [22].

The wins deserve the same scrutiny as the loss. On a 100-example pilot each example is worth one point, so the 38-point emotion gap (86 of 100 against 48%) rests on 100 cases [5][23]. The typed-decision margin over Jev is 0.45 points, or 9 of 2,000 cases [26]. Jev is another small decision model in the same category [17]. The published evaluation does not include a head-to-head against a generative LLM on the same labels. RuntimeWire describes the pilots as company-reported results, not evidence of performance across production workloads [14]. The lab's page lists the limits: no external knowledge, no multi-step reasoning, and 100-example pilots that are signals, not guarantees [12].

These numbers transfer only under three conditions. A team's labels have to fit in 20 options or survive the router. The labels have to be distinct from one another. And 200 to 300 ms per decision on low-end hardware has to fit the latency budget [8][9]. The lab's own example, routing a ticket to billing, shipping or access [4], meets the first two. For label sets like that, I think a trial against an existing LLM classifier makes sense. According to the dev.to write-up, Supersonic's planned hosted API costs $0.025 per million input tokens with no output charge, against $0.042 for Jev [13].

What to watch

  • Independent runs on long label sets like Banking77, or a router change that stops early rounds from discarding the correct label.
  • Whether the hosted API launches at the planned $0.025 per million input tokens with free output.
  • Julia 2, which the lab says will drop mmBERT for a foundation architecture of its own.

Clarity's read

What the record supports and how the coverage leans. The claims behind it follow.

Reality

Evidence40
Adoption
Not scored
Hype gap+15
Incentives45
Confidence55
Why these scores

Claim ledger

Ranked by verification strength, evidence, and original report placement.

  1. [1]

    Supersonic Labs, a Brazil-based lab, released Julia 1, a 144.3-million-parameter model, on September 26 and published the weights and code on Hugging Face under an Apache 2.0 license.

    Reported Supported Source: RuntimeWireView cited source
  2. [2]

    Supersonic says cloud GPU costs for Julia 1's training and experiments totaled about R$540, or $104.08.

    Reported Supported Source: Supersonic Labs, via RuntimeWireView cited source
  3. [3]

    Julia 1 takes a context, a question and 2 to 20 options, and returns scores for each option in the order they were given.

    Reported Supported Source: dev.to write-upView cited source
  4. [4]

    Julia 1 handles three question types through one interface: Choice (pick one option from a closed list, e.g. which team should handle a ticket: billing, shipping, or access), Score (place the input on an ordered scale), and Noul (return the probability that a statement is true).

    Reported Supported Source: dev.to write-upView cited source
  5. [5]

    Julia 1 scored 94 of 100 on AG News (4 labels) against 91% for the reference, and 86 of 100 on emotion classification (6 labels) against 48% for the reference.

    Reported Supported Source: Supersonic Labs evaluation, via dev.to write-upView cited source
  6. [6]

    On Banking77 (72 labels), Julia 1 got 64 of 100 right against 87% for the reference; the team presented it as the one loss among its results.

    Reported Supported Source: Supersonic Labs evaluation, via dev.to write-upView cited source
  7. [7]

    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 weak spot.

    Reported Supported Source: dev.to write-upView cited source
  8. [8]

    On an Apple M4, Julia 1 took a 33.15 ms median per decision one call at a time, and about 51 decisions per second batched 16 at a time; on an Intel Core i5-1235U budget laptop chip it took about 295 ms median for typed decisions.

    Reported Supported Source: Supersonic Labs benchmarks, via dev.to write-upView cited source
  9. [9]

    On a Samsung Galaxy tablet (SM-X510), Julia 1 took 203 ms per decision through ONNX Runtime on Android 16, with the 550 MB weights memory-mapped and peak process memory at 393 MB.

    Reported Supported Source: Supersonic Labs benchmarks, via dev.to write-upView cited source
  10. [10]

    The lab reports five decisions per second on the tablet, using CPU execution after its available accelerator path fell back to CPU.

    Reported Supported Source: RuntimeWire, reporting Supersonic LabsView cited source
  11. [11]

    Training a multilingual model from scratch needed data, infrastructure, time and money the team did not have, so it started from mmBERT-small, a multilingual encoder from Johns Hopkins CLSP, kept its tokenizer, added a decision head, and trained the model to score supplied options.

    Reported Supported Source: dev.to write-upView cited source
  12. [12]

    The lab's page lists limits: no external knowledge, no multi-step reasoning, and pilots of 100 examples are signals, not guarantees.

    Reported Supported Source: dev.to write-upView cited source
  13. [13]

    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.

    Reported Supported Source: dev.to write-upView cited source
  14. [14]

    The small pilots are company-reported results, not evidence of performance across production workloads.

    Reported Supported Source: RuntimeWireView cited source
  15. [15]

    For Julia 2, the team plans to drop mmBERT and build its own foundation architecture.

    Reported Supported Source: dev.to write-upView cited source
  16. [16]

    Because the model never generates text, it cannot produce a malformed answer; a wrong label is still possible.

    Reported Supported Source: dev.to write-upView cited source
  17. [17]

    In the team's evaluation from September 24, 2026, Julia 1 got 73.15% right on 2,000 typed decision cases, against a Jev reference value of 72.70% from the same protocol; Jev is another model in the same decision-model category.

    Reported Supported Source: Supersonic Labs evaluation, via dev.to write-upView cited source
  18. [18]

    A September 25 re-run on a plain CPU scored 72.55% on the typed decisions.

    Reported Supported Source: dev.to write-upView cited source
  19. [19]

    A large language model classifying text streams tokens like "The correct category is: billing" so code can parse the label back out.

    Reported Supported Source: dev.to write-upView cited source
  20. [20]

    203 ms per decision equals about 4.9 decisions per second, consistent with the reported five per second on the tablet.

    Derived Supported
  21. [21]

    At a 33.15 ms median, one-at-a-time calls on the M4 give about 30 decisions per second.

    Derived Supported
  22. [22]

    On Banking77 Julia 1 was 23 points behind the reference.

    Derived Supported
  23. [23]

    On a 100-example pilot each example is one percentage point; the emotion gap is 38 points.

    Derived Supported
  24. [24]

    At about 295 ms per decision, the i5-1235U handles roughly 3.4 sequential decisions per second.

    Derived Supported
  25. [25]

    The plain-CPU re-run scored 0.6 points below the GPU evaluation on typed decisions.

    Derived Supported
  26. [26]

    The typed-decision margin over the Jev reference is 0.45 points, equal to 9 of 2,000 cases.

    Derived Supported

Sources

2 independent publishers whose own reporting we read for this story.

  1. dev.to

    1 article · September 27, 2026

    Julia 1: A 144M-Parameter Decision Model Trained for $104
  2. runtimewire.com

    1 article · September 26, 2026

    Supersonic Labs releases a 144M-parameter classifier built for CPU inference

Topics and entities