Supersonic Labs logo

Julia 2

From context to decisions. Read once, ask everything, decide in milliseconds.

Julia 2 โ€” monochrome geometric artwork

Julia 2 is a decision model. You give it a situation โ€” a support ticket, a transaction, an agent trace, a JSON record, a conversation that is still going on โ€” and the decisions you need to take about it, each with the options you allow. It returns a calibrated probability for every option of every question, and it does it in a single pass over the situation: the state is read once, and every question is a short branch on top of it. Nothing is generated, so there is nothing to parse and no answer outside the options you gave.

Julia 2 is the second generation of the Julia family, and it is built for decisions that the first generation could not take:

  • Decisions while things are happening. The state can keep growing โ€” a call, a chat, a stream of events โ€” and the same questions are answered again after every new chunk, without re-reading what came before. "Is this a scam?" is answered while the caller is still talking.
  • Decisions on what is said and seen. Speech and images are read in the same pass as text and JSON, with no transcription or captioning step, so the decision skills learned on text apply to a voice or a photo.
  • Many decisions on one situation for the price of one. The state is read once; routing, urgency, risk and policy checks are short branches on top of it.
  • Real policies and real label sets. Long states, written rules, negations and numbers are followed; option names are read as meaning, up to 255 options per question and more in two rounds.
  • Small enough to run anywhere. 1.06B parameters, in bf16, int8 and int4, on a GPU or a CPU.

It keeps the request and answer format of Julia 1 and Julia 1.5, so an application written for them works unchanged; what changed underneath is in From the first generation to the second.

1.06B parameters ยท text, JSON, images and speech ยท live calls ยท 32k tokens tested ยท English, Portuguese and many more languages ยท bf16, int8 and int4 ยท Julia 1 / 1.5 API

Julia 2 vs Julia 1.5 vs Julia 1

How Julia 2 decides

What a decision model is for

Most software decisions are small, frequent and structured: which team gets this ticket, is this transaction suspicious, does this answer follow the policy, how urgent is this message, which tool should the agent call next, is the caller on this line being pressured into a transfer. A chat model can answer them, but it answers by writing, which is slow, costs per token, and leaves you parsing free text and handling answers you did not allow. Julia 2 is built for exactly this kind of decision. It reads the situation, considers only the options you defined, and returns numbers your code can branch on, in tens of milliseconds.

It is a fast, single-pass model โ€” the "System 1" of an application. Use it where a decision has to be taken many times, quickly and consistently: routing and triage, moderation and safety checks, policy and eligibility checks, rubric scoring, intent and category detection with large label sets, picking the next step or tool in an agent, and watching a conversation or an event stream as it happens. It is not a writer and not a calculator: when a decision needs a long computation or knowledge that is not in the state, do that step upstream and give Julia 2 the result.

Using it well

A decision model rewards a different habit from a chat model. You do not write instructions on how to answer; you describe the situation and the decision, and the model does the rest. The sections below go through the choices that make the biggest difference, each with an example.

1. Ask for a decision, not for an answer

A question should name one decision with a closed set of outcomes. Writing it like a prompt adds nothing, because the model can only answer with your options anyway โ€” and a vague question gives vague probabilities.

# weak: a request to "analyse", with no decision in it
{"type": "choice", "instructions": "Please read the ticket carefully and tell us what you think.",
 "criteria": {"billing": "billing", "tech": "tech"}}

# better: the decision your code will act on
{"type": "choice", "instructions": "Which team should handle this ticket?",
 "criteria": {"billing": "Payments: charges, refunds, invoices",
              "tech": "Technical support: login, app errors, connectivity"}}

If you need several decisions, ask several questions (see 4). If you find yourself writing "and alsoโ€ฆ", it is probably a second question.

2. Describe what each option means

Julia 2 reads option keys and descriptions as language: it compares the situation with what each option says. It does not memorise label ids โ€” renaming billing to team_7 changes nothing โ€” so the description is where you decide what the option covers. Give each one a short definition, and when two options are close, say how they differ; that is where most mistakes between neighbours come from.

"criteria": {
    "refund":     "The customer wants money back for a charge that already happened",
    "chargeback": "The customer says the charge was not made by them (possible fraud)",
    "cancel":     "The customer wants to stop an order or a subscription before it is charged"}

The same applies to large label sets: with 150 or 255 intents, one line per intent is enough, and you can add a new intent tomorrow without retraining.

3. Put the rules and the facts in the state

When the right answer depends on a policy, a threshold or an attribute, write it into the state. Facts in the state take precedence over what the model knows in general, which is how you keep decisions current without retraining and how you make them auditable: the rule that was applied is in the request.

state = {
    "order": {"id": "A-963", "days_since_purchase": 41, "charges": [{"amount_usd": 75, "status": "captured"}]},
    "refund_policy": "Duplicate captured charges are refundable within 30 days of purchase. "
                     "Pending or voided charges are never refunded."}
questions = {"eligible": {"type": "noul", "instructions": "Is the customer eligible for a refund under the policy?"}}

Julia 2 chooses; it does not calculate. If a decision needs a sum, a date difference or a lookup, do it in your code and put the result in the state ("days_since_purchase": 41, not two dates to subtract).

4. Ask everything about the same state in one request

All questions of a request share one reading of the state: the state is processed once and every question is a short branch on top of it. Asking five things at once costs little more than asking one, and it keeps the answers consistent with each other because they are based on the same reading.

questions = {
    "team":     {"type": "choice", "instructions": "Which team should handle this ticket?", "criteria": teams},
    "urgent":   {"type": "noul",   "instructions": "Does this need an answer today?"},
    "angry":    {"type": "noul",   "instructions": "Is the customer angry?"},
    "priority": {"type": "score",  "instructions": "Support priority", "criteria": ["low", "medium", "high"]},
    "refund":   {"type": "noul",   "instructions": "Is the customer asking for money back?"}}

5. Choose the type that matches the decision

Use choice when exactly one option applies (a team, an intent, a next action). Use noul for a yes/no decision; you get P(true) directly. Use score when the options are an ordered scale and the distance between levels matters (priority, severity, quality on a rubric); you get the most likely level and the expected level, which is often the better number to sort by.

A common mistake is to turn a choice into one yes/no per option ("is it billing?", "is it tech?", โ€ฆ). Those questions are answered independently, so more than one can come out "yes". If exactly one answer applies, ask a single choice; if several can apply at once, separate yes/no questions are the right tool.

6. Turn probabilities into actions with thresholds you measured

The probabilities are calibrated on held-out decision data (expected calibration error around 0.03), so 0.9 means roughly nine in ten. That makes it natural to act automatically only when the model is sure and to route the rest:

p = result["answers"]["refund"]["noul"]
if p > 0.95:   approve()          # automate the clear cases
elif p < 0.05: decline()
else:          send_to_review()   # the uncertain middle goes to a person

Pick the two thresholds on a few hundred of your own requests with known outcomes, not on intuition: calibration is good on average, but it is weaker where the model lacks knowledge.

7. Send what the decision needs

Julia 2 reads states of tens of thousands of tokens, but accuracy still decreases slowly with length (63% at 2k tokens, 53% at 32k on decisions that hinge on one buried fact). A focused state โ€” the ticket and the relevant account fields, not the whole account history โ€” is faster and more accurate. JSON is fine as it is; key order and formatting do not matter.

8. For live inputs, keep the state open

When the situation is still unfolding โ€” a chat, a call, an event stream โ€” the same questions can be re-asked as the state grows, without reading the earlier part again: open a live session and push each chunk as it arrives (see Live calls and audio).

Quickstart

Python 3.10+ and PyTorch. The runtime is small and has its own forward pass: it needs torch, safetensors, tokenizers, numpy and pillow (plus soundfile and scipy for audio files), not transformers. A CUDA GPU is recommended; the CPU path works for small loads.

pip install huggingface_hub
python -c "from huggingface_hub import snapshot_download; snapshot_download('SupersonicLabs/Julia-2', local_dir='Julia-2')"
pip install -e ./Julia-2/runtime            # optional fast kernels: pip install -e "./Julia-2/runtime[fast]"
from julia2 import Runtime

rt = Runtime('Julia-2')            # load once, keep it alive (CUDA if available, else CPU)
                                   # Runtime('Julia-2', precision='int8' | 'int4', device='cpu') for smaller hardware

result = rt.predict_questions(
    state={'ticket': 'I was charged twice for order #4821 and the second charge is still pending.',
           'customer_tier': 'gold'},
    questions={
        'intent': {
            'type': 'choice',
            'instructions': 'What does the customer want?',
            'criteria': {'refund': 'Get money back', 'cancel': 'Cancel the order', 'track': 'Track a delivery'},
        },
        'urgent': {'type': 'noul', 'instructions': 'Should this ticket be escalated today?'},
        'priority': {'type': 'score', 'instructions': 'Support priority', 'criteria': ['low', 'medium', 'high']},
    },
)
print(result['answers']['intent']['choice'], result['answers']['intent']['probabilities'])

rt.predict_batch([...]) scores many requests together; rt.decide(state, instructions, criteria) is the one-question shortcut.

Request

Field Description
state the situation: a string or any JSON value
questions {key: question}; every question is answered on the same reading of the state
Question field Description
type choice, noul or score
instructions the decision, in plain words
criteria choice: {option_key: description}, 2 to 255 options (more with the two-round readout). noul: optional {"true": ..., "false": ...} descriptions. score: a list of level descriptions (level i is index i) or {level: description}

Answer

Type Fields
choice choice (winning key), probabilities over all keys (sum to 1), confidence (top minus second)
noul noul = P(true), confidence = |2ยทP(true) โˆ’ 1|
score score (most likely level), expected_level, probabilities, confidence

Answers carry truncated: true when the state did not fit the configured maximum length.

Images in the state

A state can include images. They are read by the model's own vision encoder in the same pass as the text, placed before the text of the state, so every question of the request sees them โ€” there is no captioning or OCR step in between. Use them when the decision depends on what is visible: whether a product photo shows damage, which document a scan is, whether a screenshot shows an error, how many items are on a shelf, whether a meme or an image is safe to publish.

from PIL import Image

result = rt.predict_questions(
    state='Inspection photo from line 3. Part number 88-1204.',
    images=[Image.open('part.jpg')],              # PIL images, file paths, bytes, base64 strings or data URLs
    questions={
        'damaged': {'type': 'noul', 'instructions': 'Is there visible damage on the part?'},
        'defect':  {'type': 'choice', 'instructions': 'Which defect is visible?',
                    'criteria': {'none': 'No defect', 'scratch': 'Surface scratch', 'dent': 'Dent or deformation',
                                 'crack': 'Crack or break', 'stain': 'Stain or discoloration'}},
    },
)

Over HTTP, or anywhere the request is plain JSON, the state can be a list of parts in the System One format: text parts are strings or {"type": "text", "text": ...}, images are {"type": "image_url", "image_url": {"url": "data:image/png;base64,..."}}.

A few habits make image decisions more reliable. Refer to images by their order when there are several ("the first image", "the second image"), and keep the question about what can actually be seen. Put the context you know in the text of the state โ€” the part number, the expected document type, the store and aisle โ€” rather than hoping the model infers it from pixels. Count questions work best as choice or score with explicit bins ("0", "1", "2", "3 or more"). Images are downscaled to at most 1.6 megapixels; for small print, crop the region that matters instead of sending a large page.

From the first generation to the second

The first generation (Julia 1 and Julia 1.5) was a 144M-parameter encoder that read the question, the options and the state as one sequence of at most 1,024 tokens, with a small head comparing the options. It was fast and small, and Julia 1.5 made it far more reliable, but the design set hard limits: little general knowledge to draw on, at most 20 options, a short context, one full pass for every question, and text only.

Julia 2 keeps the contract and replaces the network. The state is no longer re-read for every question: it is read once, and each question is a short branch on top of it, so asking many things about the same situation costs little more than asking one. The trunk is a hybrid โ€” 18 linear-attention layers that carry a fixed-size recurrent state and 6 full-attention layers โ€” which reads long states cheaply and can extend a state that is still arriving. Because the trunk is a language model, it brings general knowledge and an understanding of what option names and descriptions mean: unseen label sets, renamed keys and new languages work without retraining, and the option list can grow to 255 entries, or more in two rounds. Images and speech enter the same pass through the model's own vision and audio encoders, so the decision skills learned on text are reused on what is seen and heard.

The reliability work of Julia 1.5 was carried over as training objectives instead of patches. Option order, negation, the agreement between a choice and its per-option yes/no views, irrelevant options and the bias on an empty state are measured as formal laws during training, and the checkpoint is selected on held-out tasks rather than on the benchmark it is reported on.

What each model can understand and do, side by side:

Julia 1 Julia 1.5 Julia 2
Short text or JSON state Yes Yes Yes
Long states (thousands to tens of thousands of tokens) Partly: runtime 8k, tuned on 1k No: 1,024 tokens Yes
A state that keeps growing (live input) No No Yes
Images in the state No No Yes
Speech and live calls No No Yes
Written rules and policies in the state No Yes Yes
Negated questions ("is it NOT eligible?") No Partly: trained phrasings only Yes
Numbers compared correctly (8,143 vs 8,134) No No Yes
Yes/no answers that depend on the state, not a default Partly Partly Yes
General knowledge to fill gaps No No Partly
Option descriptions read as meaning Partly Partly Yes
New label sets and renamed keys without retraining Partly Partly Yes
Same answer when options are reordered No Partly (fully with runtime views) Yes: in the weights
Ignoring an irrelevant option slipped into the list Partly Yes Yes
More than 20 options in one question Partly: grouped router No Yes: up to 255, more in two rounds
Choice, score and yes/no Yes Yes Yes
Several questions on one state One pass each One pass each One reading, short branches
Calibrated probabilities Partly Partly Yes
Same request and answer format Yes Yes Yes

Live calls and audio

Speech is encoded into the same token space the model uses for text, so every decision skill learned on text is reused on what is said, with no transcription step and without losing what text does not carry โ€” tone, hesitation, pressure in a voice. A recording can be part of any state, and a live call is a normal request whose input keeps arriving: you open it with the fixed context and the fixed questions, push audio (or text) as it comes, and read updated answers whenever you want. Earlier audio is never processed again, so asking costs the same at minute one and at minute ten.

# a recording inside a normal request
rt.predict_questions([{"type": "input_audio", "input_audio": "call.flac"}], questions)   # path, bytes, data URL or (array, rate)

# a live call
questions = {
    "scam":     {"type": "noul",  "instructions": "Is the caller trying to scam the customer?"},
    "pressure": {"type": "score", "instructions": "How much pressure is the caller applying?", "criteria": ["none", "some", "strong"]},
    "alert":    {"type": "noul",  "instructions": "Should we warn the customer now?"},
}
live = rt.open_live({"customer": "Ana Souza", "bank": "Banco Meridional"}, questions, lang="pt")
live.turn("caller")
live.push(pcm_chunk)                     # 16 kHz float32 audio, any chunk size (80 ms is fine)
answers, alert = live.ask()              # alert: the "alert" question with hysteresis, so it does not flicker
live.push_text("No, I never gave anyone my PIN.")   # text can be mixed in

The alert follows the question keyed alert with two thresholds (on above 0.6 for two asks, off below 0.4 for three), so it fires once the evidence holds and does not flicker. Re-ask after every turn or every few seconds; a GPU serves dozens of concurrent live calls.

Results

Internal held-out evaluations of this checkpoint (bf16).

Text and JSON decisions

Julia 2
SLCMB 3.0 (920 cases ร— 100 option orders) 64.7 (DEV split 67.7)
Typed business decisions (4 workflows, 6,000 questions) 77.2% ยท ECE 0.033
Unseen tasks / unseen label sets 73.4% / 86.3%
Languages held out from training (mean) 93.5%
Same answer when options are reordered 95.8%
Negated questions answered consistently 100%
Ignores irrelevant options 98.7%
Long context (deciding fact in the state): 2k / 8k / 16k / 32k tokens 63% / 60% / 55% / 53%
300 / 600 / 1,000 options (two-round readout) 51% / 50% / 49%

Speech and live calls

Audio Same state as text Transcribe-then-decide
Decisions on spoken states (354 questions) 70โ€“72% 74.9% 71.5%
Spoken facts: numbers, amounts, dates (268 questions) 93.7% 94.0% โ€”
Real recorded speech, intents (MInDS-14, 2,413 utterances) 75.3% โ€” โ€”
Live calls, 115 held-out calls in English and Portuguese Julia 2
Scam calls flagged by the alert before the call ends 94%
Final accuracy across the six live questions 75.8%
Streaming answer = full re-read of the same audio 99%
False alarms on legitimate calls 32%

Precision variants

The repository holds the same checkpoint in three precisions. The tokenizer, configuration and runtime are shared, and each variant passed an answer-agreement check against bf16 before it was published (models.json lists the numbers).

Variant Size Same answer as bf16: text / speech / live GPU memory Use it for
bf16 (root) 2.1 GB reference 3.7 GB servers and GPUs; the fastest on a GPU
int8/ 1.4 GB 99.3% / 99.4% / 99.4% 2.9 GB smaller GPUs, CPU servers
int4/ 1.2 GB 99.7% / 95.8% / 98.7% 2.7 GB laptops and edge devices; text answers match, speech slightly less
from huggingface_hub import snapshot_download
snapshot_download('SupersonicLabs/Julia-2', local_dir='Julia-2',
                  allow_patterns=['int8/*', 'tokenizer/*', 'trunk/*', 'runtime/**', '*.json', 'LICENSE', 'NOTICE*'])
rt = Runtime('Julia-2', precision='int8')

Production notes

Load the model once per process and keep it alive. All questions of a request share one reading of the state, and requests that arrive together are batched by length. On one NVIDIA RTX PRO 6000 (Blackwell), bf16, with a 183-token state:

p50
One question 4.7 ms
Six questions on the same state 11.7 ms
One question on a 1.6-megapixel image (same image again, cached) 61.6 ms (37.0 ms)
One question on 10 s of speech 49.6 ms
Live call: one 0.96 s audio step / asking six questions 41.8 ms / 6.4 ms

On a 4-thread CPU (bf16) one question takes about 0.8 s and six questions on the same state about 2 s; the int8 and int4 variants are faster where the CPU has int8 instructions.

There is no sampling: the same request on the same hardware and software gives the same probabilities. When requests are batched together, padding changes the shape of the bf16 computation and probabilities can move in the last digits; score requests one by one when that matters.

Files

Path Contents
model.safetensors weights, bf16 (readout and audio projector fp32; 2.1 GB)
int8/, int4/ the same checkpoint in int8 and int4 (weight-only)
config.json model manifest (architecture, sizes, checkpoint hash; also used by the Hub to count downloads)
models.json the variants in this repository, with size, agreement checks and latency
trunk/, tokenizer/ trunk architecture configuration and tokenizer, read by the runtime
runtime/ julia2 runtime: Runtime.predict_questions, predict_batch, decide, open_live; tests and benchmark
metrics/, provenance.json evaluations, agreement checks, benchmarks and checkpoint provenance
LICENSE, NOTICE, NOTICE_audio.md, licenses/ licence and third-party notices

Limits

Julia 2 chooses; it does not compute. Multi-step arithmetic and long calculations are unreliable, and so is exam-level knowledge that is not in the state (national entrance exams, professional exams) โ€” compute or retrieve those upstream. Long states work, but accuracy decays with length, from 63% at 2k tokens to 53% at 32k on needle decisions. The per-option yes/no view is not yet perfectly coherent with the choice view: asked separately about each option, the model can say yes to more than one plausible option, so use choice when exactly one answer applies. Probabilities are well calibrated on average but over-confident where knowledge is missing; check them on your own data before using them as hard thresholds. Images are read without decision training on images yet, so check image decisions on your own data. Speech decisions are a few points below the same state written as text, weaker on very fast speech and on Portuguese recordings than on English, and the live-call questions still raise too many alerts on legitimate calls (32%): treat the alert as a prompt to look, not as a verdict.

The model artifacts are licensed under Apache 2.0.


Supersonic Labs

Downloads last month
7
Safetensors
Model size
1B params
Tensor type
F32
ยท
BF16
ยท
Inference Providers NEW
This model isn't deployed by any Inference Provider. ๐Ÿ™‹ Ask for provider support

Model tree for SupersonicLabs/Julia-2

Finetunes
2 models

Collection including SupersonicLabs/Julia-2

Evaluation results

  • SLCMB score (DEV) on SLCMB 3.0, DEV split (461 cases x 100 option orders)
    self-reported
    67.700
  • Accuracy on Typed decisions (held-out)
    self-reported
    0.772