A small AI lab based in Brazil just shipped a language model that does the opposite of what everyone else in AI is chasing. While OpenAI, Google, and Anthropic push toward trillion-parameter systems that write essays and generate video, Supersonic Labs released Julia 1 on September 26, 2026: a 144.3-million-parameter open-weight model that does not write a single word of prose. It picks an answer from a list you give it, hands back a probability score, and runs on a laptop CPU with no GPU required. MarkTechPost broke the story the same day, and finance.biggo.com followed with its own coverage, both flagging it as a rare case of an AI lab going smaller instead of bigger.
The release matters less for its size and more for what it refuses to do. Julia 1 cannot draft an email, summarize a document, or hold a conversation. Feed it a context, a question, and between 2 and 20 candidate answers, and it returns a probability for every option in the order you supplied them. That narrow design is deliberate, according to the model’s Hugging Face card, and it is why a model roughly 1,400 times smaller than a typical frontier system can still beat a proprietary structured-decision rival on three of four benchmark pilots.
Don't miss new tech stories on Google
Add Tech Insider once in the Google app and our stories appear in your news suggestions.
What Julia 1 Actually Does
Julia 1 is built around a single idea: most business decisions are not open-ended writing tasks, they are picks from a short list. According to MarkTechPost’s report, the model exposes one API that covers three distinct decision types. The first, called choice, picks one label out of 2 to 20 described options, which covers classification and routing tasks like sorting support tickets or directing a request to the right downstream system. The second, score, returns the expected index on an ordered rubric, such as ranking a response as low, medium, or high risk. The third, internally labeled noul, returns the probability that a yes-or-no statement is true.
Every response comes back in the same order the caller submitted the options, with full softmax probabilities attached to each one, and any caller-supplied IDs (billing references, for example) pass through unchanged. Crucially, the model does not generate free text at any point in the pipeline. That single constraint is what keeps the parameter count down and the latency low, and it is also what separates Julia 1 from general chatbots like ChatGPT, Gemini, or Claude, all of which are built to produce open-ended language rather than select from a fixed menu.
The weights are published on Hugging Face under the Apache 2.0 license, a permissive open-source license that allows commercial use, modification, and redistribution. The model runs locally with Python 3.11 or newer on a CPU or a BF16-capable GPU, and an ONNX build runs directly in a browser tab via WebGPU. Supersonic Labs has announced a hosted API but it is not open to the public yet, according to the model card and MarkTechPost’s writeup.
The 144.3M-Parameter Number, Explained
Julia 1’s exact parameter count, 144.3 million, is not an arbitrary marketing figure. It traces directly back to its base architecture. According to MarkTechPost, Julia 1 starts from JHU CLSP’s mmBERT-small, a roughly 140-million-parameter multilingual ModernBERT encoder trained on more than 1,800 languages. Supersonic Labs kept the encoder and tokenizer intact, then added a dedicated decision head on top and trained it on decision-formatted examples rather than open text.
The lab has explicitly stated that Julia 1 is not a fine-tuned Qwen model, an important clarification given how many “new” small models in 2026 turn out to be repackaged versions of existing open-weight families. The runtime technically supports up to 8,192 combined tokens, but the published benchmarks were run with a 1,024-token limit. The complete FP32 checkpoint weighs in at approximately 550.5 MiB, small enough to fit comfortably on a phone or a budget laptop.
Perhaps the most striking number in the entire release is the training cost. Supersonic Labs disclosed total cloud GPU spend for training and experimentation at roughly R$540, or about US$104.08, according to MarkTechPost’s reporting. For comparison, frontier labs routinely spend hundreds of millions of dollars training a single flagship model. Julia 1’s entire budget would not cover a single day of compute for a model like GPT-6 Astra. The lab has not released its private training pipeline, and a successor, Julia 2, built on the lab’s own foundation architecture rather than a borrowed encoder, is reportedly already in development.
Benchmark Results: Where Julia 1 Wins and Where It Fails
Supersonic Labs ran its primary evaluation on September 24, 2026, using H200 BF16 inference with strict encoding. The comparison baseline throughout is TypeSafe’s Jev, a proprietary structured-decision model, though the comparison uses published reference values from the Jev benchmark protocol rather than a fresh, live run of Jev itself, a distinction MarkTechPost’s report is careful to flag.
On a general Typed Decisions test spanning 2,000 examples, Julia 1 scored 73.15% (1,463 out of 2,000) against a 72.70% reference figure for Jev, a narrow win of less than half a percentage point. On AG News, a four-label classification pilot, Julia 1 hit 94 out of 100 versus a 91% reference. On the DAIR Emotion set, a six-label pilot, the gap widened sharply: Julia 1 scored 86 out of 100 against just 48% for the Jev reference. On the 18-scenario MASSIVE multilingual benchmark, Julia 1 posted 71.50% macro accuracy across 52 locales, with stronger results in Portuguese (86.25% for pt-PT) and English (86.75% for en-US), likely reflecting the lab’s Brazilian base and the multilingual training of the underlying mmBERT-small encoder.
Then there is Banking77, a 72-label intent classification benchmark, and it is where Julia 1 stumbles badly. The model scored just 64 out of 100 against an 87% reference figure for Jev, described in MarkTechPost’s coverage as “the clear failure” of the release. A follow-up CPU run on September 25 reproduced most of the numbers closely (72.55% on Typed Decisions), but Banking77 dropped further still, to 60 out of 100 with three abstentions. The pattern is consistent: Julia 1’s compact decision head handles small label sets well but degrades as the number of semantically overlapping categories grows past a few dozen.
It’s worth noting that the classification pilots (AG News, DAIR Emotion, Banking77) each used only 100 examples, a small sample size that limits how much statistical confidence anyone should place in single-point comparisons. The Typed Decisions test, at 2,000 examples, is the more statistically grounded of the two evaluation types.
| Benchmark | Julia 1 Score | Jev Reference | Sample Size | Result |
|---|---|---|---|---|
| Typed Decisions | 73.15% (1,463/2,000) | 72.70% | 2,000 | Narrow win |
| AG News (4 labels) | 94% (94/100) | 91% | 100 | Win |
| DAIR Emotion (6 labels) | 86% (86/100) | 48% | 100 | Large win |
| Banking77 (72 labels) | 64% (64/100) | 87% | 100 | Clear loss |
| MASSIVE (18 scenarios, 52 locales) | 71.50% macro accuracy | Not disclosed | Multi-locale set | Standalone result |
Source: MarkTechPost, based on Supersonic Labs’ own published model card and benchmark disclosures, September 24-26, 2026.
CPU Speed: The Real Selling Point
The benchmark scores are debatable, but the latency numbers are what actually justify the “runs on a CPU” headline. Supersonic Labs published per-device measurements that show Julia 1 operating at genuinely practical speeds without a discrete GPU in sight. On an Apple M4 chip, a single decision took a median of just 33.15 milliseconds. On a Samsung SM-X510 tablet running inference through ONNX Runtime, the median jumped to 203 milliseconds with 393.1 MB of peak memory use. On an Intel Core i5-1235U laptop CPU, a common mid-range chip found in millions of business laptops, AG News-style decisions took a median of 107.83 milliseconds.
The exception is Banking77, where the 72-label narrowing process pushed latency up to 3,713.54 milliseconds on the same Intel chip, since the model has to filter through significantly more candidate labels before returning a decision. Supersonic Labs’ official X account (@supersonicai) claimed Julia 1 classifies five times faster than Jev on an i5 laptop, but MarkTechPost’s reporting flags that comparison as apples-to-oranges: the Jev pilot measured Jev as a hosted service called remotely from France, not a local CPU run, so the two latency figures are not directly comparable.
| Device | Task | Median Latency | Notes |
|---|---|---|---|
| Apple M4 | Single decision | 33.15 ms | Fastest measured device |
| Intel Core i5-1235U (laptop CPU) | AG News (4 labels) | 107.83 ms | Common business laptop chip |
| Intel Core i5-1235U (laptop CPU) | Banking77 (72 labels) | 3,713.54 ms | Label narrowing slows response sharply |
| Samsung SM-X510 tablet | ONNX Runtime inference | 203 ms | 393.1 MB peak memory |
Source: Supersonic Labs device benchmarks, as reported by MarkTechPost, September 25-26, 2026.
Julia 1 vs TypeSafe’s Jev vs GLiNER2.5 Multi
MarkTechPost’s coverage places Julia 1 alongside two direct rivals in the small structured-decision category: TypeSafe AI’s Jev and Fastino’s GLiNER2.5 Multi. The three models take noticeably different approaches to roughly the same problem, and the differences say a lot about where each company is betting its resources.
Jev is closed. TypeSafe has not disclosed its parameter count or base encoder, and it only offers hosted API access in early availability rather than downloadable weights, with a proprietary license. GLiNER2.5 Multi, built by Fastino on a 287-million-parameter mDeBERTa-v3-base encoder, takes the opposite approach: it is open-weight under Apache 2.0 like Julia 1, but it targets a broader task set that includes classification, named-entity recognition, relation extraction, and structured record extraction, not just choice-based decisions. Julia 1 sits at the narrowest and smallest end of the three: fewer parameters than either rival, a tighter task scope limited to choice, score, and yes/no decisions, and a hard cap of 20 options per call (Jev, by contrast, supports up to 255 options per call through TypeSafe’s own routing system).
On pricing, Supersonic Labs has floated a planned API rate of $0.025 per million input tokens, undercutting Jev’s disclosed $0.042 per million tokens, while GLiNER2.5 Multi remains free to run since it is fully self-hosted. On the shared classification pilots, Julia 1 beat both rivals on AG News (94% vs 91% for Jev and 70% for GLiNER2.5) and DAIR Emotion (86% vs 48% and 44%), but lost on Banking77 (64% vs 87% for Jev and 61% for GLiNER2.5), the one benchmark where label-set size seems to punish Julia 1’s compact architecture the most.
| Feature | Julia 1 | TypeSafe Jev | GLiNER2.5 Multi |
|---|---|---|---|
| Developer | Supersonic Labs | TypeSafe AI | Fastino |
| Access | Open weights | Hosted API, early access | Open weights |
| License | Apache 2.0 | Proprietary | Apache 2.0 |
| Parameters | 144.3M | Not disclosed | 287M |
| Base encoder | mmBERT-small | Not disclosed | mDeBERTa-v3-base |
| Decision types | Choice, score, yes/no | Typed structured decisions | Classification, NER, relations, records |
| Options per call | 2 to 20 | Up to 255 | Label list per schema |
| Runs locally on CPU | Yes | No | Yes |
| Input price per 1M tokens | $0.025 (planned) | $0.042 | Free (self-hosted) |
Source: Julia 1 model card, TypeSafe launch materials, and GLiNER2.5 Multi documentation, as compiled by MarkTechPost.
Why This Is Different From the Chatbot Arms Race
Every major AI headline in 2026 has been about scale: bigger context windows, larger parameter counts, more expensive training runs. GPT-6 Astra launched with pricing built around $10 per million tokens for enterprise-grade reasoning. GPT-6 Sol and Luna undercut Claude Opus 5.5 on price but are still full-scale generative systems measured in the hundreds of billions of parameters. Even the open-weight side of the industry has trended upward, with releases like IBM’s Granite, Mistral Large 3, and Falcon H1 spanning a combined parameter gap of 645 billion across just three models.
Julia 1 runs directly counter to that trend, and that is precisely the point. A huge share of real-world AI deployment in business settings is not open-ended generation at all. It’s routing a support ticket to the right queue. It’s flagging whether a transaction looks fraudulent. It’s scoring a document as low, medium, or high risk. It’s answering a yes-or-no policy question. These are exactly the tasks Julia 1 targets, and running them through a 100-billion-plus-parameter chatbot is both wasteful and, in many enterprise environments, a nonstarter on cost or data-residency grounds. A model that fits in 550 MiB and answers in under 110 milliseconds on a five-year-old laptop chip can run entirely on-premises, with no API call, no per-token billing beyond the (still unreleased) hosted option, and no data leaving the building.
This “small, task-specific model” philosophy has precedent in the broader open-source ecosystem. Google’s Gemma line and Microsoft’s Phi family have both pushed toward smaller, more efficient checkpoints, and comparisons like Gemma 4 vs Phi-4 Mini vs Qwen3.5 show a 4.75x size gap between competing “small” models that are all still general-purpose generators. Julia 1 goes a step further by abandoning generation entirely, which is also why direct benchmark comparisons against those families, or against efficiency-focused releases like Qwen-Image-2.1’s 7B open-weight model, don’t really apply. Julia 1 isn’t competing on the same axis. It’s not trying to be a smaller GPT. It’s trying to be the fastest possible switchboard operator.
Historical Context: The Small-Model Movement
The idea of task-specific, sub-200-million-parameter models is not new; it predates the current generative AI boom by years. BERT, released by Google in 2018, kicked off the modern encoder-model era at 110 million parameters (base) and 340 million (large), and it was built for exactly the kind of classification and scoring tasks Julia 1 now targets. DistilBERT and other distilled variants pushed that efficiency further through the early 2020s. What changed by 2023 and 2024 was that generative decoder models, GPT-style architectures optimized for producing text, captured nearly all of the industry’s attention and funding, pushing efficient encoder-based classifiers into the background even though the underlying business need for them never went away.
mmBERT, the JHU CLSP encoder Julia 1 builds on, is itself part of a 2025-era revival of encoder architecture research, an effort to modernize BERT-style models with the training techniques and multilingual coverage generative models popularized, while keeping the compact, non-generative structure that suits classification. Julia 1’s arrival in September 2026, at the tail end of a year dominated by trillion-parameter reasoning models and agentic AI systems, reads as a pointed reminder from a small independent lab that not every AI problem needs a frontier model, and that the market for cheap, fast, boring classification has not gone away just because chatbots got more interesting.
Market Impact and Industry Reaction
Because Julia 1 is a niche, task-specific release from a small independent lab rather than a hyperscaler, its immediate market impact is narrower than a frontier model launch, but the signal it sends is broader. Enterprise teams evaluating open-source AI deployment risk have spent much of 2026 debating whether open-weight models introduce security exposure that closed, hosted systems avoid. Julia 1’s Apache 2.0 license and fully local execution path sidestep that entire debate for a specific slice of use cases: if a model never phones home and never sees a network connection, most of the attack surface discussed in that debate simply doesn’t apply.
The roughly $104 training cost also lands at a moment when the industry has been fixated on the opposite extreme of AI spending. Coverage of SoftBank’s more than $11 billion bond sale tied to its OpenAI stake and AMD’s climb past a $1 trillion valuation on the back of AI infrastructure demand illustrate just how much capital is flowing toward frontier-scale compute. Julia 1 is, in effect, a rounding error next to those numbers, and that gap is exactly why MarkTechPost and other outlets flagged it: it demonstrates that a useful, benchmarked, production-viable model can still be built and shipped for less than the cost of a mid-range laptop, using someone else’s pretrained encoder as a foundation rather than training from scratch.
For competitors like TypeSafe and Fastino, Julia 1’s release adds direct price and licensing pressure. TypeSafe’s Jev remains proprietary and hosted-only, at a higher token price than Julia 1’s planned API rate, at a time when open-weight alternatives are closing the accuracy gap on most (though not all) shared benchmarks. That dynamic mirrors what has already played out in the general-purpose LLM market, where DeepSeek’s open releases have repeatedly forced proprietary rivals to cut prices or justify their premium with capability gaps.
Limitations Supersonic Labs Has Acknowledged
To its credit, Supersonic Labs has been unusually direct about where Julia 1 falls short, according to MarkTechPost’s reporting. The model compares only the answers a caller supplies; it cannot be relied on to surface missing facts, perform algebra, or work through multi-step calculations, since it was never trained to reason beyond the option set it’s handed. The Router component, used to narrow large label sets like Banking77’s 72 categories down to a manageable shortlist before final scoring, can itself drop the correct label during that narrowing step, which is very likely the root cause of the Banking77 underperformance rather than a flaw in the scoring head itself.
Julia 1 is also not a drop-in replacement for a standard Hugging Face Transformers pipeline, and as of the September 26 release, no Hugging Face inference provider was serving the model, meaning anyone who wants managed hosting rather than local deployment has to wait for Supersonic Labs’ own API. The lab’s own guidance advises developers to evaluate the model against their own specific questions before deployment and to keep a human in the loop for any decision with real consequences, a caveat worth taking seriously given how thin the classification pilot sample sizes (100 examples each) really are.
What Developers Need to Get Started
Getting Julia 1 running locally follows the same pattern as most modern Hugging Face releases, with a few decision-model-specific wrinkles. The model card specifies Python 3.11 or newer as a baseline requirement, alongside a standard PyTorch installation for CPU inference. No native router build is required for basic usage, and the model can optionally run on a BF16-capable GPU for higher throughput. The published maximum sequence length is 8,192 tokens, though production benchmarks were run at a 1,024-token ceiling, so developers should test their own prompt lengths before assuming the full 8K window behaves identically.
# Minimal local inference pattern (per Julia 1 model card)
from transformers import AutoModel, AutoTokenizer
model_id = "SupersonicLabs/Julia-1"
tokenizer = AutoTokenizer.from_pretrained(model_id)
model = AutoModel.from_pretrained(model_id).to("cpu")
context = "Customer reports a delayed refund."
question = "Which team should handle this ticket?"
options = ["Billing", "Shipping", "Technical Support", "Account Security"]
# Model returns softmax probabilities in the same order as `options`
For browser or edge deployment, Supersonic Labs also published an ONNX build that runs via ONNX Runtime and WebGPU, meaning Julia 1 decisions can execute client-side in a web page with no server round-trip at all. That path was the one used for the Samsung SM-X510 tablet benchmark, and it’s likely the deployment mode most consumer-facing apps would actually use, since it avoids both API costs and network latency entirely.
How Julia 1 Fits Into the Broader Efficient-AI Trend
2026 has been a year of AI models chasing bigger context windows and higher benchmark scores almost every month, from GPT-6 Astra vs Gemini 3.8 vs DeepSeek V4.1 comparisons showing an 83x capability gap on certain tasks, to enterprise pricing wars playing out across nearly every model family on the market. Against that backdrop, small, single-purpose releases like Julia 1 rarely make front-page news, but they matter to a very specific and very large audience: engineering teams building internal tools who don’t need, and can’t justify the cost of, a frontier reasoning model for a task as mundane as routing a form submission.
The comparison to tools already covered on this site is instructive. Guides on running an LLM locally and shrinking LLMs through GGUF quantization both point at the same underlying demand: developers want models that run on hardware they already own, without a subscription or an API key. Julia 1 arrives already quantization-friendly by design, since it never needed the billions of extra parameters a general chatbot carries around for open-ended text generation in the first place.
5 Predictions for Where This Goes Next
1. Julia 2 will target the Banking77-style failure mode directly. Supersonic Labs has confirmed Julia 2 is already in development, using the lab’s own foundation architecture instead of a borrowed mmBERT-small encoder. Given how sharply Julia 1’s accuracy dropped on the 72-label Banking77 test, expect the next version’s marketing to lean heavily on large-label-set performance.
2. The hosted API, once live, will undercut TypeSafe’s Jev on price but face scrutiny on uptime and support. A small independent lab charging a planned $0.025 per million tokens will need to prove it can match the reliability enterprises expect from a paid API, something open weights alone don’t guarantee.
3. Expect copycat “tiny decision model” releases from other small labs. A production-viable model trained for roughly $104 in cloud compute lowers the barrier to entry for other independent teams dramatically. If Julia 1 gets real developer adoption, similar narrow, cheap-to-train alternatives are likely to follow within months.
4. Larger labs will treat this as validation, not competition. Don’t expect OpenAI, Google, or Anthropic to build a rival decision-only model. It’s far more likely that frontier labs simply note the demand and continue offering structured-output modes bolted onto their existing generative models, even if that approach remains slower and more expensive per decision than a purpose-built model like Julia 1.
5. Enterprise adoption will hinge entirely on independent third-party evaluation. Supersonic Labs’ own benchmarks, while unusually transparent about the Banking77 failure, are still self-reported. Whether Julia 1 gets real traction likely depends on whether independent developers publish their own head-to-head tests against Jev and GLiNER2.5 Multi on tasks that matter to them, not on the September 24 numbers alone.
The Bigger Picture for Enterprise AI Buyers
The takeaway for anyone evaluating AI tooling in late 2026 isn’t that Julia 1 is going to replace ChatGPT, Claude, or Gemini for any team’s core product. It’s that the market for AI has quietly split into two very different shopping lists. One list is for generative, conversational, agentic systems, the kind covered extensively in comparisons like ChatGPT vs Claude vs Gemini vs Grok, where the competition is about reasoning depth, context length, and subscription pricing. The other list, much less discussed but arguably just as large in terms of real deployed volume, is for narrow, fast, cheap classification and routing, and that’s the list Julia 1 is trying to top.
Given the self-reported nature of the September 24-25 benchmarks, the thin 100-example pilot sizes, and the acknowledged Banking77 weakness, buyers should treat Julia 1 as a promising but unproven contender rather than a settled leader in its category. Still, a 144.3-million-parameter model beating a proprietary rival on three of four pilot tests, running in roughly 33 milliseconds on an Apple M4, and costing about $104 to train is a combination worth watching regardless of where the benchmarks eventually settle.
Frequently Asked Questions
What is Supersonic Labs’ Julia 1?
Julia 1 is a 144.3-million-parameter open-weight decision model released on September 26, 2026, by Supersonic Labs, a small AI lab based in Brazil. It picks an answer from a set of 2 to 20 candidate options rather than generating free text, and it is published on Hugging Face under the Apache 2.0 license.
Does Julia 1 require a GPU?
No. Julia 1 is designed to run on a plain CPU, and Supersonic Labs published latency benchmarks on an Apple M4, an Intel Core i5-1235U laptop chip, and a Samsung SM-X510 tablet. It can optionally use a BF16-capable GPU for faster throughput, and an ONNX build runs in a browser via WebGPU.
How much did Julia 1 cost to train?
Supersonic Labs disclosed total cloud GPU spend for training and experimentation at approximately R$540, or about US$104.08, according to MarkTechPost’s reporting on the model card.
What base model is Julia 1 built on?
Julia 1 starts from JHU CLSP’s mmBERT-small, a roughly 140-million-parameter multilingual ModernBERT encoder trained on more than 1,800 languages. Supersonic Labs kept the encoder and tokenizer and added a new decision head trained on decision-formatted examples. The lab has stated Julia 1 is not a fine-tuned Qwen model.
How does Julia 1 compare to TypeSafe’s Jev?
Julia 1 beat Jev’s published reference values on the Typed Decisions, AG News, and DAIR Emotion pilots, but scored notably lower on the 72-label Banking77 benchmark (64% vs 87%). Jev remains proprietary and hosted-only, while Julia 1 ships as downloadable open weights under Apache 2.0.
Can Julia 1 generate text like ChatGPT or Claude?
No. Julia 1 does not generate free-form text at any point. It only selects among candidate answers supplied by the caller and returns probability scores, which is fundamentally different from generative chatbots like ChatGPT, Gemini, or Claude.
Is a hosted API available for Julia 1?
Not yet as of publication. Supersonic Labs has announced a hosted API with a planned rate of $0.025 per million input tokens, but it was not publicly open as of the September 26, 2026 release, according to MarkTechPost.
What are Julia 1’s biggest limitations?
Julia 1 can only compare answers it is given; it cannot surface missing facts or perform multi-step calculations. Its Router component can drop the correct label when narrowing large option sets, which likely explains its weak Banking77 score. It is also not a drop-in Hugging Face Transformers pipeline, and no managed inference provider was serving it at launch.
Related Coverage
- ChatGPT vs Claude vs Gemini vs Grok: $292 Plan Gap [2026]
- OpenAI Preps GPT-6 Cyber, Its 4th Security Model [2026]
- Meta vs Google Stock: $2.3 Trillion Cap Gap [2026]
- Veo 3.1 API Setup: Migrate From Sora 2 in 12 Steps [2026]
- OpenAI Flags AI Agent's DNS Escape in 15 Minutes [2026]
