Sori-1B-MCQ — sori (소리) is Korean for sound — listens to a clip and answers typed questions about it: which of these options, how far along this scale, is this true. It returns the answer, a probability for every option you defined, and a confidence — never prose, never a token stream to parse. Code stays in charge: your program defines the options, reads the numbers and decides what to do. It is the decision model of the Sori Agent project at the Human Interface Lab, Seoul National University.
Inspired by TypeSafe's System One model,
Jev. Jev showed what a model built for software rather than for conversation looks like: a
state, typed questions, calibrated
probabilities, one call for many questions. Sori-1B-MCQ is that idea for
sound. Its request, its three question types, its answers, its errors and its
confidence follow TypeSafe's API deliberately and
closely, so code written against Jev reads audio here by pointing the client's base_url at this model. TypeSafe built
the interface; this model brings audio to it. We are not affiliated with TypeSafe, and any mistake in the correspondence
is ours.
Setup
pip install "transformers>=5.13" "torch>=2.6" soundfile scipy numpy pandas pyarrow
hf auth login
Everything the model needs travels with the checkpoint (trust_remote_code=True loads the model and its processor).
The audio tower always runs in bfloat16, the dtype it was trained in; the reader and the head follow the dtype you load.
Load in float32 (the default here) and the answers do not depend on how many clips share a call; bfloat16 is faster on
a GPU and moves a few answers per hundred. Report the dtype beside any score.
Audio is read with soundfile (wav, flac, ogg, and mp3 with libsndfile 1.1+) and resampled to 16 kHz; any sample rate
and any length are accepted, and clips are never cut. CPU works.
Usage
from transformers import AutoModel, AutoProcessor
model = AutoModel.from_pretrained("snkii/Sori-1B-MCQ", trust_remote_code=True).eval()
proc = AutoProcessor.from_pretrained("snkii/Sori-1B-MCQ", trust_remote_code=True)
r = model.ask(
state={"clip": {"type": "audio", "path": "street.wav"}, "location": "a train station"},
questions={
"source": {"type": "choice", "instructions": "What makes the loudest sound?",
"criteria": {"train": None, "announcement": "a voice over a PA system", "crowd": None}},
"busy": {"type": "score", "instructions": "How crowded does the place sound?",
"criteria": ["empty, no voices", "a few people", "a dense crowd"]},
"horn": {"type": "noul", "instructions": "Is a train horn heard?"},
},
processor=proc)
r["answers"]["source"]["choice"] # 'train'
r["answers"]["source"]["probabilities"] # {'train': ..., 'announcement': ..., 'crowd': ...}
r["answers"]["busy"]["score"] # a position along your levels, 0 to 2 here
r["answers"]["horn"]["noul"] # the probability that the answer is yes
Many clips at once. model.ask_batch([(state, questions), ...], processor=proc) answers a list of states in
one forward — the call to use for a benchmark or a busy server. Loaded in float32 it answers exactly what ask answers clip by
clip; loaded in bfloat16 a few answers per hundred move, because a bf16 kernel sums a batch in a different order. One invalid item rejects the whole list.
Three question types, as in TypeSafe's primitives. A choice picks one of the options you name and returns a probability for each. A score places the clip on ordered levels you describe and returns a position along them. A noul answers a yes/no question with the probability of yes. Choice and score answers also carry a confidence: how concentrated the distribution is, 1 for a point mass and 0 for a flat one, so code can act, ask or escalate.
The state. The state is the material the questions are about: a clip, or
a JSON object holding a clip and text fields ({"clip": ..., "speakers": [...]}), or an array — up to eight clips in one
state, so one question can compare them. Questions in one call are answered independently against the same state, and the
audio is read once.
As a service. serve.py travels with the model and answers over HTTP in the same shape, so a client
written for that API can talk to it — including TypeSafe's own Python SDK, which is MIT-licensed and takes any base_url:
python serve.py --model snkii/Sori-1B-MCQ --port 8790 # --device cuda, --api_key_env KEY to require a key
curl -s http://127.0.0.1:8790/v1/ask -H 'Content-Type: application/json' -d '{
"model": "sori-latest",
"state": {"type": "audio", "path": "street.wav"},
"questions": {"source": {"type": "choice", "instructions": "What is loudest?", "criteria": {"train": null, "crowd": null}}}}'
On a benchmark. example_mmau.py fetches this model and a benchmark, answers it clip by clip and
scores it — one command, nothing to download by hand:
python example_mmau.py --limit 25 # add --device mps on a Mac, --device cuda on a GPU, --batch 8 to fill it
It reads MMAU test-mini as its authors publish it on the Hub
(gamma-lab-umd/MMAU-test-mini, audio included); nothing of
the benchmark is redistributed here. --bench takes a local file instead.
The model
An audio tower, a projector and a reader: 1.05 billion parameters. The tower is NVIDIA's Audio Flamingo Next encoder, fine-tuned in this work (its weights are modified; LICENSE identifies the modifications as NVIDIA's Section 3.2 requires); the reader is Liquid AI's LFM2.5-Encoder-350M, a bidirectional encoder, also trained further here. The projector that turns the tower's frames into the reader's tokens ends in three of the reader's own blocks -- its bottom convolution, convolution and attention layers, copied from the reader and trained further as a mixer over the sound. The model answers only inside the options a question defines. Everything it needs to run and to serve travels with the checkpoint. This is a research preview under active development, for academic use.
License
Sori-1B-MCQ is for academic use only: within that, use it, share it and build on it under the same terms, with attribution. Models, data and systems derived from it or from its outputs carry this license, a notice of what was changed, and a citation of this work; so do publications whose results depend on it. The limit is not ours to relax — the audio tower is NVIDIA's Audio Flamingo Next encoder, fine-tuned here and redistributed under the NVIDIA OneWay Noncommercial License (22 Mar 2022, academic), whose Section 3.3 reads "non-commercially" as for academic purposes only and carries that limit into every derivative work. The model it reads with remains under Liquid AI's LFM Open License v1.0. Both licenses are reproduced in full, and the parts covered by our own terms are named file by file, in LICENSE.
Trademarks
TypeSafe, System One and Jev are TypeSafe's names for TypeSafe's products; they appear here only to credit the interface this model follows and the work that inspired it. This model is not a TypeSafe product and is not affiliated with or endorsed by TypeSafe, and it contains no TypeSafe code, weights, data or model outputs. NVIDIA and Audio Flamingo are NVIDIA's marks, and Liquid AI and LFM are Liquid AI's; neither license grants rights in them beyond the notices this repository reproduces.
Citation
@software{kim_sori_mcq_2026,
author = {Kim, Seonuk},
title = {{Sori-1B-MCQ: An Audio Multiple-Choice Question Solver}},
year = {2026},
month = sep,
institution = {Human Interface Laboratory, Seoul National University},
url = {https://huggingface.co/snkii/Sori-1B-MCQ}
}